- storage: openForDownload accepte un intervalle d'octets - files: serveFile (200/206/416) + route GET /preview inline avec whitelist, sans increment du compteur - admin: creation et reinitialisation ne renvoient plus le mot de passe (envoi par e-mail uniquement) - docs: endpoint preview et whitelist/Range
176 lines
6.1 KiB
TypeScript
176 lines
6.1 KiB
TypeScript
import { createHash, randomUUID } from "node:crypto";
|
|
import { createReadStream, createWriteStream } from "node:fs";
|
|
import { mkdir, rename, rm, stat, statfs } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { Readable, Transform } from "node:stream";
|
|
import { pipeline } from "node:stream/promises";
|
|
import { AppError, type Db } from "./lib/index.js";
|
|
|
|
/**
|
|
* Chemin physique : ${MEDIA_DIR}/${slug emplacement}/${uuid}.
|
|
*
|
|
* Le nom affiche n'apparait jamais dans le chemin. Outre qu'il evite toute
|
|
* escape via "../", il empeche deux depots homonymes de se marcher dessus et
|
|
* rend l'arborescence disque ininteressante a parcourir pour un tiers.
|
|
*/
|
|
|
|
const SLUG = /^[a-z0-9][a-z0-9-]{0,99}$/;
|
|
const EXTENSION = /^[.][a-z0-9]{1,10}$/i;
|
|
|
|
export interface StoredLocation {
|
|
id: number;
|
|
slug: string;
|
|
}
|
|
|
|
/** Extension conservee pour la lisibilite sur disque, jamais pour le routage. */
|
|
const extensionOf = (name: string): string => {
|
|
const ext = path.posix.extname(name);
|
|
return EXTENSION.test(ext) ? ext.toLowerCase() : "";
|
|
};
|
|
|
|
export const relativePathFor = (slug: string, uuid: string, name: string): string =>
|
|
path.posix.join(slug, uuid + extensionOf(name));
|
|
|
|
const resolveInside = (mediaDir: string, relative: string): string => {
|
|
const base = path.resolve(mediaDir);
|
|
const target = path.resolve(base, relative);
|
|
if (target !== base && !target.startsWith(base + path.sep)) {
|
|
throw AppError.badRequest("Chemin de stockage invalide.");
|
|
}
|
|
return target;
|
|
};
|
|
|
|
export const absolutePath = (mediaDir: string, relative: string): string =>
|
|
resolveInside(mediaDir, relative);
|
|
|
|
/**
|
|
* Choix de l'emplacement : celui qui offre le plus de marge. Les comptes sont
|
|
* eux-memes plafonnes, donc cette valeur sert a ne pas remplir un support
|
|
* tandis qu'un autre reste vide.
|
|
*/
|
|
export const chooseLocation = async (db: Db, bytes: bigint): Promise<StoredLocation> => {
|
|
const rows = await db.query<{ id: number; slug: string; remaining: number | null }>(
|
|
`SELECT id, slug,
|
|
CASE WHEN quota_bytes IS NULL THEN NULL
|
|
ELSE quota_bytes - used_bytes END AS remaining
|
|
FROM storage_locations
|
|
WHERE is_active = 1 AND deleted_at IS NULL
|
|
ORDER BY (remaining IS NULL) DESC, remaining DESC, id
|
|
LIMIT 1`,
|
|
);
|
|
const row = rows[0];
|
|
if (!row || !SLUG.test(row.slug)) {
|
|
throw AppError.serviceUnavailable("Aucun emplacement de stockage disponible.");
|
|
}
|
|
if (row.remaining !== null && BigInt(row.remaining) < bytes) {
|
|
throw AppError.payloadTooLarge("L'espace disponible sur le support est insuffisant.");
|
|
}
|
|
return { id: row.id, slug: row.slug };
|
|
};
|
|
|
|
interface WriteResult {
|
|
size: number;
|
|
checksum: string;
|
|
}
|
|
|
|
/**
|
|
* Ecrit le corps de la requete sur disque en une seule passe : hachage,
|
|
* comptage et gravure avancent ensemble, sans jamais faire tenir le fichier
|
|
* en memoire. La lecture est interrompue des que la borne est depassee, donc
|
|
* un envoi enorme ne remplit pas d'abord le disque pour echouer ensuite.
|
|
*/
|
|
export const writeBody = async (
|
|
destination: string,
|
|
body: ReadableStream<Uint8Array>,
|
|
declared: number,
|
|
maxBytes: number,
|
|
): Promise<WriteResult> => {
|
|
const hash = createHash("sha256");
|
|
let received = 0;
|
|
|
|
const meter = new Transform({
|
|
transform(chunk: Buffer, _encoding, callback) {
|
|
received += chunk.length;
|
|
if (received > maxBytes) {
|
|
callback(AppError.payloadTooLarge(`Fichier trop volumineux (maximum ${maxBytes} octets).`));
|
|
return;
|
|
}
|
|
hash.update(chunk);
|
|
callback(null, chunk);
|
|
},
|
|
});
|
|
|
|
const source = Readable.fromWeb(body as Parameters<typeof Readable.fromWeb>[0]);
|
|
await pipeline(source, meter, createWriteStream(destination, { flags: "wx" }));
|
|
|
|
// Taille declaree et taille recue doivent concorder : sans quoi le quota
|
|
// aurait ete reserve sur une valeur que le disque n'a pas confirmee.
|
|
if (received !== declared) {
|
|
throw AppError.badRequest(
|
|
`Longueur incoherente : ${declared} octets annonces, ${received} recus.`,
|
|
);
|
|
}
|
|
|
|
return { size: received, checksum: hash.digest("hex") };
|
|
};
|
|
|
|
export const ensureDir = async (directory: string): Promise<void> => {
|
|
await mkdir(directory, { recursive: true });
|
|
};
|
|
|
|
/** Publie un fichier temporaire : meme systeme de fichiers, donc operation atomique. */
|
|
export const publish = async (temporary: string, destination: string): Promise<void> => {
|
|
await rename(temporary, destination);
|
|
};
|
|
|
|
export const discard = async (...paths: string[]): Promise<void> => {
|
|
await Promise.all(paths.map((entry) => rm(entry, { force: true }).catch(() => undefined)));
|
|
};
|
|
|
|
export const temporaryPath = (mediaDir: string, slug: string): string =>
|
|
path.join(path.resolve(mediaDir), slug, `.upload-${randomUUID()}`);
|
|
|
|
export const fileExists = async (absolute: string): Promise<boolean> => {
|
|
try {
|
|
const info = await stat(absolute);
|
|
return info.isFile();
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Ouvre un fichier en lecture. `range` restreint le flux a un intervalle
|
|
* d'octets inclusif, ce qui permet de repondre a une requete HTTP `Range`
|
|
* (deplacement dans une video ou un morceau audio) sans lire tout le fichier.
|
|
*/
|
|
export const openForDownload = (absolute: string, range?: { start: number; end: number }) =>
|
|
createReadStream(absolute, range);
|
|
|
|
/**
|
|
* Occupation reelle du support qui porte `target`. Sert a refuser un quota
|
|
* plus grand que le disque et a prevenir un eclatement d'ENOSPC : l'espace
|
|
* logique (used_bytes) peut etre disponible alors que le disque est plein.
|
|
*/
|
|
export interface DiskUsage {
|
|
total_bytes: number;
|
|
/** Blocs libres, blocs reserves du systeme de fichiers inclus. */
|
|
free_bytes: number;
|
|
/** Blocs utilisables par le processus (hors reserve root). */
|
|
available_bytes: number;
|
|
}
|
|
|
|
export const diskUsage = async (target: string): Promise<DiskUsage | null> => {
|
|
try {
|
|
const info = await statfs(target, { bigint: true });
|
|
return {
|
|
total_bytes: Number(info.blocks * info.bsize),
|
|
free_bytes: Number(info.bfree * info.bsize),
|
|
available_bytes: Number(info.bavail * info.bsize),
|
|
};
|
|
} catch {
|
|
// Support absent ou non monté : l'appelant decide du repli.
|
|
return null;
|
|
}
|
|
};
|