206 lines
9.0 KiB
JavaScript
206 lines
9.0 KiB
JavaScript
import { createReadStream } from 'node:fs'
|
|
import { link, lstat, mkdir, mkdtemp, open, readlink, rename, rm, stat } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { basename, dirname, extname, join } from 'node:path'
|
|
import { pipeline } from 'node:stream/promises'
|
|
import { Readable } from 'node:stream'
|
|
import { randomUUID } from 'node:crypto'
|
|
import {
|
|
FileManagerError, FileRevisionConflictError, fileError, fileManagerInternals,
|
|
isManagedPath, normalizeAbsolutePath,
|
|
} from './index.mjs'
|
|
import { createArchive } from './archives.mjs'
|
|
|
|
function parseRange(value, size) {
|
|
if (value === undefined) return { start: 0, end: Math.max(0, size - 1), partial: false }
|
|
const match = /^bytes=(\d*)-(\d*)$/.exec(value)
|
|
if (match === null || (match[1] === '' && match[2] === '')) throw new FileManagerError('range is invalid', 416, 'RANGE_INVALID')
|
|
let start
|
|
let end
|
|
if (match[1] === '') {
|
|
const suffix = Number(match[2])
|
|
if (!Number.isSafeInteger(suffix) || suffix < 1) throw new FileManagerError('range is invalid', 416, 'RANGE_INVALID')
|
|
start = Math.max(0, size - suffix)
|
|
end = size - 1
|
|
} else {
|
|
start = Number(match[1])
|
|
end = match[2] === '' ? size - 1 : Number(match[2])
|
|
}
|
|
if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || start >= size || end < start) {
|
|
throw new FileManagerError('range is not satisfiable', 416, 'RANGE_INVALID')
|
|
}
|
|
return { start, end: Math.min(end, size - 1), partial: true }
|
|
}
|
|
|
|
function disposition(name) {
|
|
const fallback = name.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_') || 'download'
|
|
return `attachment; filename="${fallback}"; filename*=UTF-8''${encodeURIComponent(name)}`
|
|
}
|
|
|
|
async function syncDirectory(path) {
|
|
const handle = await open(path, 'r')
|
|
try { await handle.sync() } finally { await handle.close() }
|
|
}
|
|
|
|
async function existingMetadata(path, { requireFile = false } = {}) {
|
|
try {
|
|
const value = await stat(path, { bigint: true })
|
|
if (requireFile && !value.isFile()) throw new FileManagerError('upload target is not a regular file', 415, 'FILE_TYPE_UNSUPPORTED')
|
|
return value
|
|
} catch (error) {
|
|
if (error?.code === 'ENOENT') return undefined
|
|
throw error
|
|
}
|
|
}
|
|
|
|
function renamedPath(path, index) {
|
|
const extension = extname(path)
|
|
const stem = extension === '' ? path : path.slice(0, -extension.length)
|
|
return `${stem} (${String(index)})${extension}`
|
|
}
|
|
|
|
export class FileTransferManager {
|
|
constructor({ isManaged = isManagedPath, stagingRoot = tmpdir() } = {}) {
|
|
this.isManaged = isManaged
|
|
this.stagingRoot = stagingRoot
|
|
}
|
|
|
|
async openDownload(value, { revision, range, signal } = {}) {
|
|
const path = normalizeAbsolutePath(value)
|
|
let handle
|
|
let cleanup
|
|
try {
|
|
const pathStats = await lstat(path, { bigint: true })
|
|
if (pathStats.isDirectory()) {
|
|
if (range !== undefined) throw new FileManagerError('directory downloads do not support ranges', 416, 'RANGE_INVALID')
|
|
const actualRevision = fileManagerInternals.revisionFor(path, pathStats)
|
|
if (revision !== undefined && revision !== '' && revision !== actualRevision) throw new FileRevisionConflictError('download revision changed')
|
|
await mkdir(this.stagingRoot, { recursive: true })
|
|
const staging = await mkdtemp(join(this.stagingRoot, '.dsh-directory-download-'))
|
|
cleanup = () => rm(staging, { recursive: true, force: true })
|
|
const name = basename(path) || 'root'
|
|
const archive = join(staging, `${name}.zip`)
|
|
await createArchive({ format: 'zip', sourceRoot: path === '/' ? path : dirname(path), output: archive, entries: [path === '/' ? '.' : name], signal })
|
|
const download = await this.openDownload(archive, { signal })
|
|
download.path = path
|
|
download.revision = actualRevision
|
|
download.headers['content-disposition'] = disposition(`${name}.zip`)
|
|
download.cleanup = cleanup
|
|
cleanup = undefined
|
|
return download
|
|
}
|
|
handle = await open(path, 'r')
|
|
const before = await handle.stat({ bigint: true })
|
|
if (!before.isFile()) throw new FileManagerError('path is not a regular file', 415, 'FILE_TYPE_UNSUPPORTED')
|
|
const actualRevision = fileManagerInternals.revisionFor(path, before, await readlink(path).catch(() => ''))
|
|
if (revision !== undefined && revision !== '' && revision !== actualRevision) throw new FileRevisionConflictError('download revision changed')
|
|
const size = Number(before.size)
|
|
if (!Number.isSafeInteger(size)) throw new FileManagerError('file is too large', 413, 'FILE_TOO_LARGE')
|
|
if (size === 0 && range !== undefined) throw new FileManagerError('range is not satisfiable', 416, 'RANGE_INVALID')
|
|
const selected = size === 0 ? { start: 0, end: -1, partial: false } : parseRange(range, size)
|
|
const length = selected.end < selected.start ? 0 : selected.end - selected.start + 1
|
|
const stream = length === 0 ? Readable.from([]) : createReadStream(path, {
|
|
fd: handle.fd, autoClose: false, start: selected.start, end: selected.end,
|
|
})
|
|
return {
|
|
path, handle, stream, revision: actualRevision,
|
|
status: selected.partial ? 206 : 200,
|
|
headers: {
|
|
'accept-ranges': 'bytes',
|
|
'cache-control': 'no-store',
|
|
'content-disposition': disposition(basename(path)),
|
|
'content-length': String(length),
|
|
'content-type': 'application/octet-stream',
|
|
etag: `"${actualRevision}"`,
|
|
...(selected.partial ? { 'content-range': `bytes ${String(selected.start)}-${String(selected.end)}/${String(size)}` } : {}),
|
|
},
|
|
}
|
|
} catch (error) {
|
|
await handle?.close().catch(() => {})
|
|
await cleanup?.().catch(() => {})
|
|
throw fileError(error)
|
|
}
|
|
}
|
|
|
|
async sendDownload(response, download, { onProgress = () => {}, signal } = {}) {
|
|
response.writeHead(download.status, download.headers)
|
|
let sent = 0
|
|
download.stream.on('data', chunk => {
|
|
sent += chunk.byteLength
|
|
onProgress(sent, Number(download.headers['content-length']))
|
|
})
|
|
try {
|
|
await pipeline(download.stream, response, { signal })
|
|
} finally {
|
|
await download.handle.close().catch(() => {})
|
|
await download.cleanup?.().catch(() => {})
|
|
}
|
|
}
|
|
|
|
async upload(input, value, { conflict = 'reject', contentLength, onProgress = () => {}, signal } = {}) {
|
|
const requestedPath = normalizeAbsolutePath(value)
|
|
if (!['reject', 'overwrite', 'rename'].includes(conflict)) throw new FileManagerError('upload conflict mode is invalid')
|
|
const parent = dirname(requestedPath)
|
|
const parentStats = await stat(parent).catch(error => { throw fileError(error) })
|
|
if (!parentStats.isDirectory()) throw new FileManagerError('upload parent is not a directory', 415, 'FILE_TYPE_UNSUPPORTED')
|
|
const staging = join(parent, `.dsh-upload-${randomUUID()}.tmp`)
|
|
let handle
|
|
let received = 0
|
|
try {
|
|
const original = await existingMetadata(requestedPath, { requireFile: conflict === 'overwrite' })
|
|
if (original !== undefined && conflict === 'reject') throw new FileManagerError('upload target already exists', 409, 'FILE_EXISTS')
|
|
handle = await open(staging, 'wx', 0o600)
|
|
for await (const chunk of input) {
|
|
signal?.throwIfAborted()
|
|
const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
|
|
received += bytes.byteLength
|
|
await handle.write(bytes)
|
|
onProgress(received, contentLength)
|
|
}
|
|
if (contentLength !== undefined && received !== contentLength) throw new FileManagerError('upload size does not match Content-Length')
|
|
await handle.sync()
|
|
if (original === undefined) await handle.chmod(0o644)
|
|
else {
|
|
await handle.chmod(Number(original.mode & 0o7777n))
|
|
const current = await handle.stat({ bigint: true })
|
|
if (current.uid !== original.uid || current.gid !== original.gid) await handle.chown(Number(original.uid), Number(original.gid))
|
|
}
|
|
await handle.close()
|
|
handle = undefined
|
|
let path = requestedPath
|
|
if (conflict === 'overwrite') await rename(staging, path)
|
|
else if (conflict === 'reject') {
|
|
await link(staging, path)
|
|
await rm(staging)
|
|
} else {
|
|
let index = 0
|
|
for (;;) {
|
|
path = index === 0 ? requestedPath : renamedPath(requestedPath, index)
|
|
try {
|
|
await link(staging, path)
|
|
await rm(staging)
|
|
break
|
|
} catch (error) {
|
|
if (error?.code !== 'EEXIST') throw error
|
|
index += 1
|
|
}
|
|
}
|
|
}
|
|
await syncDirectory(parent)
|
|
const result = await stat(path, { bigint: true })
|
|
return {
|
|
path,
|
|
size: received,
|
|
revision: fileManagerInternals.revisionFor(path, result),
|
|
managed: this.isManaged(path),
|
|
}
|
|
} catch (error) {
|
|
await handle?.close().catch(() => {})
|
|
await rm(staging, { force: true }).catch(() => {})
|
|
throw fileError(error)
|
|
}
|
|
}
|
|
}
|
|
|
|
export const fileTransferInternals = Object.freeze({ parseRange, disposition, renamedPath })
|