forked from mtusi2026/mtusi2026lab7
183 lines
12 KiB
TypeScript
183 lines
12 KiB
TypeScript
// Вложения: приём PNG/JPEG в устойчивый staging, фоновая обработка worker-ом, скачивание только через API.
|
||
//
|
||
// Приём (lab5): ответ 202 означает, что устойчиво сохранено всё, что нужно для завершения работы без клиента:
|
||
// 1. INSERT строки pending (запись-намерение с ключами staging и оригинала) — COMMIT;
|
||
// 2. поток байтов: клиент → проверка формата + SHA-256 → S3 staging/<id>;
|
||
// 3. одна транзакция: pending → queued, job и строка outbox (transactional outbox) — COMMIT → 202.
|
||
// Брокер в этот момент не нужен: relay (src/jobs/relay.ts) опубликует задание после COMMIT, даже если брокер
|
||
// поднимется позже. Ошибка на шагах 2–3 → компенсация; падение процесса → pending-строку уберёт reconciler.
|
||
// Lab6: строка outbox запоминает trace context запроса загрузки — publish и обработка worker-ом продолжат этот trace.
|
||
import { createHash, randomUUID } from 'node:crypto';
|
||
import { Transform } from 'node:stream';
|
||
import { failpoint } from '../failpoints.ts';
|
||
import type { Ctx, Result } from '../http/context.ts';
|
||
import { badRequest, conflict, notFound, tooLarge, unavailable, unsupported } from '../http/errors.ts';
|
||
import { isText, mediaType, uuidParam } from '../http/request.ts';
|
||
import { log, traceCarrier } from '../otel.ts';
|
||
import { requireMember } from './chats.ts';
|
||
import { imageValidator, type Dimensions } from './images.ts';
|
||
import type { User } from './model.ts';
|
||
import { authenticate } from './sessions.ts';
|
||
|
||
const FORBIDDEN_IN_FILENAME = /[/\\\p{Cc}]/u; // разделители путей, NUL и управляющие символы C0/C1
|
||
const VARIANTS = ['thumbnail', 'crop', 'optimized'];
|
||
// Варианты — опубликованной версии pipeline; у queued/processing/failed их нет.
|
||
const columns = `a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.state AS status, a.error_code,
|
||
rfc3339(a.created_at) AS created_at, rfc3339(a.updated_at) AS updated_at,
|
||
COALESCE((SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type, 'size_bytes', v.size_bytes,
|
||
'width', v.width, 'height', v.height, 'sha256', v.sha256) ORDER BY v.name)
|
||
FROM attachment_variants v WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version), '[]') AS variants`;
|
||
const VISIBLE = `('queued', 'processing', 'ready', 'failed')`; // pending ещё не принято, lost — в карантине
|
||
|
||
type Row = Record<string, unknown> & { object_key?: string; pipeline_version?: number | null };
|
||
|
||
// Ключи объектов и внутренняя версия pipeline наружу не отдаются.
|
||
const view = ({ object_key: _, pipeline_version: __, ...row }: Row) => row;
|
||
|
||
// POST /api/v1/chats/{chat_id}/attachments?filename=… — сырые байты одного PNG/JPEG → 202 queued.
|
||
// Все лимиты проверяются до чтения тела; тело не буферизуется целиком ни в памяти, ни на диске API.
|
||
export async function uploadAttachment(c: Ctx): Promise<Result> {
|
||
const user = await authenticate(c);
|
||
const chatId = await requireMember(c, user);
|
||
const filename = c.url.searchParams.get('filename');
|
||
if (!isText(filename, 1, 255) || FORBIDDEN_IN_FILENAME.test(filename)) {
|
||
throw badRequest('filename: 1–255 символов, без / \\ и управляющих символов');
|
||
}
|
||
const type = mediaType(c.req);
|
||
if (type !== 'image/png' && type !== 'image/jpeg') throw unsupported('Ожидается image/png или image/jpeg');
|
||
const declared = c.req.headers['content-length'];
|
||
if (declared === undefined || !/^\d+$/.test(declared)) throw badRequest('Нужен Content-Length: файл передаётся потоком в S3');
|
||
const length = Number(declared);
|
||
if (length > c.config.maxUploadBytes) throw tooLarge(`Файл больше ${c.config.maxUploadBytes} байт`);
|
||
if (length === 0) throw unsupported('Пустое тело не является изображением');
|
||
|
||
const id = randomUUID();
|
||
const staging = `staging/${id}`; // filename только для отображения и в ключи не попадает
|
||
await c.db.query(`INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, object_key, staging_key)
|
||
VALUES ($1, $2, $3, $4, $5, $6, $7)`, [id, chatId, user.id, filename, type, `originals/${id}`, staging]);
|
||
let row: Row;
|
||
try {
|
||
const dims = await store(c, staging, type, length);
|
||
await failpoint(c.db, 'api_after_staging', id, filename); // байты в staging, задания ещё нет
|
||
row = await accept(c, id, length, dims);
|
||
} catch (err) {
|
||
void discard(c, id, staging); // в фоне: при зависшем S3 клиент не ждёт ещё и DELETE
|
||
throw err;
|
||
}
|
||
await failpoint(c.db, 'api_after_commit', id, filename); // задание в outbox, публикации ещё не было
|
||
c.relay.kick();
|
||
return [202, view(row)];
|
||
}
|
||
|
||
// pending → queued + job + outbox одной транзакцией: после COMMIT работа не теряется при падении API.
|
||
async function accept(c: Ctx, id: string, length: number, dims: { sha256: string; width: number; height: number }): Promise<Row> {
|
||
const client = await c.db.connect();
|
||
try {
|
||
await client.query('BEGIN');
|
||
const r = await client.query(`UPDATE attachments AS a SET state = 'queued', size_bytes = $2, sha256 = $3, width = $4, height = $5,
|
||
updated_at = clock_timestamp() WHERE a.id = $1 AND a.state = 'pending' RETURNING ${columns}`, [id, length, dims.sha256, dims.width, dims.height]);
|
||
if (!r.rowCount) throw unavailable('Загрузка не завершилась вовремя'); // строку уже убрал reconciler
|
||
const { traceparent, tracestate } = traceCarrier();
|
||
await client.query(`WITH j AS (INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES (gen_random_uuid(), $1, $2) RETURNING job_id)
|
||
INSERT INTO outbox (job_id, attempt, traceparent, tracestate) SELECT job_id, 1, $3, $4 FROM j`, [id, c.config.jobs.pipelineVersion, traceparent, tracestate]);
|
||
await client.query('COMMIT');
|
||
return r.rows[0];
|
||
} catch (err) {
|
||
await client.query('ROLLBACK').catch(() => {});
|
||
throw err;
|
||
} finally {
|
||
client.release();
|
||
}
|
||
}
|
||
|
||
// Клиент → проверка + SHA-256 → S3. Обратное давление: пока S3 не принял кусок, следующий не читается из сокета,
|
||
// поэтому память на загрузку не зависит от размера файла. Последний кусок уходит в S3 только после полной
|
||
// проверки файла: S3 не получит все Content-Length байт невалидного изображения, и объект не создастся.
|
||
async function store(c: Ctx, key: string, type: 'image/png' | 'image/jpeg', length: number) {
|
||
const check = imageValidator(type, c.config.maxImagePixels);
|
||
const hash = createHash('sha256');
|
||
const abort = new AbortController();
|
||
let received = 0;
|
||
let dims: Dimensions | undefined;
|
||
let failure: unknown;
|
||
const fail = (err: unknown) => {
|
||
failure ??= err;
|
||
abort.abort();
|
||
};
|
||
const body = new Transform({
|
||
transform(chunk: Buffer, _encoding, done) {
|
||
received += chunk.length;
|
||
hash.update(chunk);
|
||
check.write(chunk)
|
||
.then(async () => { if (received === length) dims = await check.end(); })
|
||
.then(() => done(null, chunk), done);
|
||
},
|
||
});
|
||
body.on('error', fail);
|
||
c.req.on('close', () => { if (!c.req.complete) fail(badRequest('Загрузка прервана клиентом')); });
|
||
c.req.pipe(body);
|
||
try {
|
||
await c.s3.put(key, body, length, type, abort.signal);
|
||
if (failure) throw failure;
|
||
if (!dims) throw new Error('S3 принял объект до конца проверки');
|
||
return { sha256: hash.digest('hex'), ...dims };
|
||
} catch (err) {
|
||
// Остаток тела читаем и выбрасываем: иначе ответ с ошибкой не дойдёт до клиента, который ещё отправляет файл.
|
||
c.req.unpipe(body);
|
||
c.req.resume();
|
||
body.destroy();
|
||
check.close();
|
||
throw failure ?? err;
|
||
}
|
||
}
|
||
|
||
// Компенсация неудачной загрузки. Объект удаляется, только если строка точно не стала queued: при
|
||
// неоднозначной ошибке COMMIT (соединение оборвалось) строка могла зафиксироваться, и байты нужны worker-у.
|
||
// Сбой здесь не теряет учёт: останется pending-строка с ключом staging, её подберёт reconciler.
|
||
async function discard(c: Ctx, id: string, key: string): Promise<void> {
|
||
try {
|
||
const deleted = await c.db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'`, [id]);
|
||
if (!deleted.rowCount && (await c.db.query('SELECT 1 FROM attachments WHERE id = $1', [id])).rowCount) return;
|
||
await c.s3.remove(key);
|
||
} catch (err) {
|
||
log('warn', 'attachment.compensation_failed', `компенсация вложения не завершена, остаток уберёт reconciler: ${(err as Error).message}`, { 'attachment.id': id });
|
||
}
|
||
}
|
||
|
||
// Вложение доступно только участникам его чата; постороннему — тот же 404, что и для несуществующего.
|
||
async function findVisible(c: Ctx, user: User): Promise<Row & { object_key: string }> {
|
||
const r = await c.db.query(`SELECT ${columns}, a.object_key, a.pipeline_version FROM attachments a
|
||
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
||
WHERE a.id = $1 AND a.state IN ${VISIBLE}`, [uuidParam(c, 'attachment_id'), user.id]);
|
||
if (!r.rowCount) throw notFound();
|
||
return r.rows[0];
|
||
}
|
||
|
||
// GET /api/v1/attachments/{attachment_id} — снимок статуса; клиент опрашивает до ready/failed.
|
||
export async function getAttachment(c: Ctx): Promise<Result> {
|
||
return [200, view(await findVisible(c, await authenticate(c)))];
|
||
}
|
||
|
||
// GET /api/v1/attachments/{attachment_id}/content[?variant=original|thumbnail|crop|optimized] — байты потоком из S3.
|
||
// queued/processing/failed — 409; отсутствующий вариант ready-объекта — 404; без redirect.
|
||
export async function downloadAttachment(c: Ctx): Promise<Result> {
|
||
const user = await authenticate(c);
|
||
const variant = c.url.searchParams.get('variant') ?? 'original';
|
||
if (variant !== 'original' && !VARIANTS.includes(variant)) throw badRequest('Неизвестный variant');
|
||
const row = await findVisible(c, user);
|
||
if (row.status !== 'ready') throw conflict(row.status === 'failed' ? 'Обработка вложения завершилась ошибкой' : 'Вложение ещё обрабатывается');
|
||
let target = { key: row.object_key, type: row.content_type as string, size: row.size_bytes as number };
|
||
if (variant !== 'original') {
|
||
const v = await c.db.query(`SELECT object_key, content_type, size_bytes FROM attachment_variants
|
||
WHERE attachment_id = $1 AND pipeline_version = $2 AND name = $3`, [row.id, row.pipeline_version, variant]);
|
||
if (!v.rowCount) throw notFound();
|
||
target = { key: v.rows[0].object_key, type: v.rows[0].content_type, size: v.rows[0].size_bytes };
|
||
}
|
||
const body = await c.s3.get(target.key);
|
||
if (!body) {
|
||
log('error', 'attachment.object_missing', `объект ${variant} вложения отсутствует в S3`, { 'attachment.id': row.id as string }); // reconciler пометит оригинал lost
|
||
throw notFound();
|
||
}
|
||
return [200, body, { 'Content-Type': target.type, 'Content-Length': target.size, 'X-Content-Type-Options': 'nosniff' }];
|
||
}
|