Courriels - gabarit HTML brande (logo, couleur #b71c1c, bouton, mention ne pas repondre) dans backend/src/lib/mail-template.ts ; repli texte conserve - MailMessage gagne un champ html optionnel - MAIL_LOGO_URL (defaut PUBLIC_ORIGIN/logo.png) + logo.png servi par le front - notification au nouvel utilisateur a la creation du compte admin - forgot-password, email-change et reset-password passent par le gabarit Espace disque - diskUsage() (statfs) dans storage.ts (total/free/available) - upload et avatar refuses si le disque est plein (507 INSUFFICIENT_STORAGE) - quota d'emplacement borne par la capacite reelle du disque - statistiques disque exposees aux endpoints admin Exploitation - make purge-logs : vide le journal d'audit - make reset : cloud vierge en conservant les administrateurs - docker/reset-cloud.sql ; documentation deployment.md et api.md
170 lines
5.8 KiB
TypeScript
170 lines
5.8 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;
|
|
}
|
|
};
|
|
|
|
export const openForDownload = (absolute: string) => createReadStream(absolute);
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
};
|