// Вложения: приём PNG/JPEG в устойчивый staging, фоновая обработка worker-ом, скачивание только через API. // // Приём (lab5): ответ 202 означает, что устойчиво сохранено всё, что нужно для завершения работы без клиента: // 1. INSERT строки pending (запись-намерение с ключами staging и оригинала) — COMMIT; // 2. поток байтов: клиент → проверка формата + SHA-256 → S3 staging/; // 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 & { 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 { 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 { 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 { 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 { 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 { 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 { 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' }]; }