forked from mtusi2026/mtusi2026lab7
261 lines
14 KiB
TypeScript
261 lines
14 KiB
TypeScript
// Сверка PostgreSQL ↔ S3: очистка после сбоев загрузки (уровень 4) и исправление расхождений (трек 2).
|
||
// node src/main.ts reconcile — dry-run: только отчёт, ничего не меняет
|
||
// ... reconcile --apply — выполнить исправления
|
||
// --verify дополнительно скачать ready-объекты и сверить SHA-256 (читает все байты bucket)
|
||
// --grace=N pending-строки и объекты без строки моложе N секунд не трогаются (RECONCILE_GRACE_SECONDS, 900)
|
||
// --retention=N staging failed-вложений хранится N секунд для replay (STAGING_RETENTION_SECONDS, 86400)
|
||
// --every=N повторять каждые N секунд (так работает сервис reconciler)
|
||
//
|
||
// Правила. Строки ready/lost не удаляются никогда, используемые сообщениями дополнительно защищены FK.
|
||
// stale_pending pending старше grace: запрос загрузки давно завершён (таймаут API 60 с ≪ grace)
|
||
// → удалить строку, затем объект (если упадём между ними — останется orphan_object)
|
||
// orphan_object объект без строки старше grace → удалить объект. Строка создаётся раньше объекта,
|
||
// ключ случайный, поэтому строка для такого объекта уже не появится
|
||
// missing_object ready без объекта (повторно проверено HEAD) → lost: скрыть из API, ссылки сохранить
|
||
// size_mismatch ready, размер объекта ≠ size_bytes → lost
|
||
// checksum_mismatch ready, SHA-256 объекта ≠ sha256 (только --verify) → lost
|
||
// restored lost, объект на месте и SHA-256 совпал → снова ready (карантин обратим)
|
||
// Lab5, префиксы staging/ и variants/ (объект нужен, пока на него ссылается БД):
|
||
// orphan_staging staging без строки старше grace → удалить
|
||
// published_staging staging ready-вложения старше grace (worker не успел удалить после фиксации) → удалить
|
||
// expired_staging staging failed-вложения старше STAGING_RETENTION_SECONDS → удалить (replay после этого невозможен)
|
||
// orphan_variant объект варианта без строки attachment_variants старше grace (попытка проиграла аренду
|
||
// или упала до фиксации; grace ≫ JOB_TIMEOUT_SECONDS) → удалить
|
||
//
|
||
// Обход: ListObjectsV2 и строки БД, оба отсортированы по ключу побайтово, сливаются как два потока
|
||
// (merge join) — память O(страница), запросов O(N / 1000). Конкурентные загрузки: строки, изменённые после
|
||
// начала обхода (updated_at ≥ t0), не проверяются; их объекты моложе grace и тоже не трогаются.
|
||
import { createHash } from 'node:crypto';
|
||
import type { Readable } from 'node:stream';
|
||
import { setTimeout as sleep } from 'node:timers/promises';
|
||
import type pg from 'pg';
|
||
import { s3Config, secret } from './config.ts';
|
||
import { createPool } from './db.ts';
|
||
import { createStorage, type Storage } from './storage/s3.ts';
|
||
|
||
const PREFIX = 'originals/';
|
||
const PAGE = 1000;
|
||
const PRINT_LIMIT = 20; // находки сверх лимита только считаются
|
||
|
||
type Options = { apply: boolean; verify: boolean; grace: number; retention: number };
|
||
type Obj = { key: string; size: number; modified: Date };
|
||
type Row = { id: string; object_key: string; state: string; size_bytes: number | null; sha256: string | null; settled: boolean };
|
||
|
||
export async function reconcileCommand(args: string[], defaultGrace: number, defaultRetention: number): Promise<void> {
|
||
const flag = (name: string) => args.find((a) => a.startsWith(`--${name}=`))?.split('=')[1];
|
||
const opts: Options = { apply: args.includes('--apply'), verify: args.includes('--verify'), grace: Number(flag('grace') ?? defaultGrace),
|
||
retention: Number(flag('retention') ?? defaultRetention) };
|
||
const every = Number(flag('every') ?? 0);
|
||
if (!Number.isInteger(opts.grace) || opts.grace < 0 || !Number.isInteger(every) || every < 0) throw new Error('--grace/--every: целые секунды');
|
||
const db = createPool(secret('DATABASE_URL'), 2);
|
||
const s3 = createStorage(s3Config());
|
||
process.on('SIGTERM', () => process.exit(0)); // прерванный обход безопасен: каждое действие атомарно
|
||
for (;;) {
|
||
try {
|
||
console.log(JSON.stringify(await reconcile(db, s3, opts)));
|
||
} catch (err) {
|
||
console.error(`сверка не выполнена: ${(err as Error).message}`);
|
||
if (!every) process.exitCode = 1;
|
||
}
|
||
if (!every) break;
|
||
await sleep(every * 1000);
|
||
}
|
||
await db.end();
|
||
}
|
||
|
||
export async function reconcile(db: pg.Pool, s3: Storage, opts: Options) {
|
||
const started = performance.now();
|
||
const lock = await db.connect();
|
||
try {
|
||
// Два reconciler-а одновременно не работают: второй сразу выходит.
|
||
if (!(await lock.query('SELECT pg_try_advisory_lock(4004) AS ok')).rows[0].ok) return { skipped: 'другая сверка уже идёт' };
|
||
try {
|
||
return await run(db, s3, opts, started);
|
||
} finally {
|
||
await lock.query('SELECT pg_advisory_unlock(4004)');
|
||
}
|
||
} finally {
|
||
lock.release();
|
||
}
|
||
}
|
||
|
||
async function run(db: pg.Pool, s3: Storage, { apply, verify, grace, retention }: Options, started: number) {
|
||
const stats = { mode: apply ? 'apply' : 'dry-run', verify, grace_seconds: grace, objects: 0, rows: 0, fresh_skipped: 0,
|
||
s3_list: 0, s3_head: 0, s3_get_bytes: 0, db_queries: 0, findings: {} as Record<string, number>, applied: 0 };
|
||
const t0: Date = (await db.query('SELECT now() AS t0')).rows[0].t0;
|
||
stats.db_queries++;
|
||
const cutoff = t0.getTime() - grace * 1000;
|
||
|
||
const found = async (kind: string, detail: Record<string, unknown>, fix: () => Promise<boolean>) => {
|
||
const n = stats.findings[kind] = (stats.findings[kind] ?? 0) + 1;
|
||
const done = apply && await fix();
|
||
if (done) stats.applied++;
|
||
if (n <= PRINT_LIMIT) console.log(JSON.stringify({ finding: kind, ...detail, action: apply ? (done ? 'fixed' : 'changed meanwhile, skipped') : 'would fix' }));
|
||
};
|
||
const setState = async (id: string, from: string, to: string) => {
|
||
stats.db_queries++;
|
||
return Boolean((await db.query('UPDATE attachments SET state = $3, updated_at = clock_timestamp() WHERE id = $1 AND state = $2',
|
||
[id, from, to])).rowCount);
|
||
};
|
||
const sha256Of = async (key: string) => {
|
||
const body = await s3.get(key);
|
||
if (!body) return null;
|
||
const hash = createHash('sha256');
|
||
for await (const chunk of body as Readable) {
|
||
hash.update(chunk);
|
||
stats.s3_get_bytes += chunk.length;
|
||
}
|
||
return hash.digest('hex');
|
||
};
|
||
|
||
// 1. Зависшие загрузки. Условие повторяется в DELETE: если строка успела измениться, её не трогаем.
|
||
const stale = await db.query(`SELECT id, COALESCE(staging_key, object_key) AS object_key FROM attachments
|
||
WHERE state = 'pending' AND created_at < $1::timestamptz - make_interval(secs => $2)`, [t0, grace]);
|
||
stats.db_queries++;
|
||
for (const r of stale.rows) {
|
||
await found('stale_pending', { id: r.id, key: r.object_key }, async () => {
|
||
stats.db_queries++;
|
||
const d = await db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'
|
||
AND created_at < $2::timestamptz - make_interval(secs => $3)`, [r.id, t0, grace]);
|
||
if (!d.rowCount) return false;
|
||
await s3.remove(r.object_key);
|
||
return true;
|
||
});
|
||
}
|
||
|
||
// 2. Слияние отсортированных потоков объектов и строк.
|
||
const onlyObject = async (o: Obj) => {
|
||
if (o.modified.getTime() > cutoff) {
|
||
stats.fresh_skipped++;
|
||
return;
|
||
}
|
||
await found('orphan_object', { key: o.key, size: o.size, modified: o.modified }, async () => {
|
||
await s3.remove(o.key);
|
||
return true;
|
||
});
|
||
};
|
||
const onlyRow = async (r: Row) => {
|
||
// pending — этап 1; lost — уже в карантине; не settled — строка изменилась после начала обхода.
|
||
if (r.state !== 'ready' || !r.settled) return;
|
||
stats.s3_head++;
|
||
if (await s3.exists(r.object_key)) return; // объект не попал в листинг, но существует — не трогаем
|
||
await found('missing_object', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
|
||
};
|
||
const both = async (o: Obj, r: Row) => {
|
||
// Оригинал до фиксации ready (processing/queued) может уже лежать в originals/: его не проверяем.
|
||
if ((r.state !== 'ready' && r.state !== 'lost') || !r.settled) return;
|
||
if (o.size !== r.size_bytes) {
|
||
if (r.state === 'ready') await found('size_mismatch', { id: r.id, key: r.object_key, expected: r.size_bytes, actual: o.size }, () => setState(r.id, 'ready', 'lost'));
|
||
return;
|
||
}
|
||
if (r.state === 'ready' && !verify) return;
|
||
const actual = await sha256Of(o.key);
|
||
if (r.state === 'ready' && actual !== r.sha256) {
|
||
await found('checksum_mismatch', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
|
||
} else if (r.state === 'lost' && actual === r.sha256) {
|
||
await found('restored', { id: r.id, key: r.object_key }, () => setState(r.id, 'lost', 'ready'));
|
||
}
|
||
};
|
||
|
||
const objs = objects(s3, stats);
|
||
const rows = dbRows(db, t0, stats);
|
||
let o = (await objs.next()).value;
|
||
let r = (await rows.next()).value;
|
||
while (o || r) {
|
||
if (o && (!r || o.key < r.object_key)) {
|
||
stats.objects++;
|
||
await onlyObject(o);
|
||
o = (await objs.next()).value;
|
||
} else if (r && (!o || r.object_key < o.key)) {
|
||
stats.rows++;
|
||
await onlyRow(r);
|
||
r = (await rows.next()).value;
|
||
} else {
|
||
stats.objects++;
|
||
stats.rows++;
|
||
await both(o!, r!);
|
||
o = (await objs.next()).value;
|
||
r = (await rows.next()).value;
|
||
}
|
||
}
|
||
|
||
// 3. staging/ и variants/: постраничный поиск ключей в БД.
|
||
const remove = (key: string) => async () => {
|
||
await s3.remove(key);
|
||
return true;
|
||
};
|
||
for await (const page of pages(s3, 'staging/', stats)) {
|
||
const r = await db.query(`SELECT staging_key AS key, state, updated_at < $2::timestamptz - make_interval(secs => $3) AS expired
|
||
FROM attachments WHERE staging_key = ANY($1)`, [page.map((o) => o.key), t0, retention]);
|
||
stats.db_queries++;
|
||
const rows = new Map(r.rows.map((row) => [row.key, row]));
|
||
for (const o of page) {
|
||
stats.objects++;
|
||
const row = rows.get(o.key);
|
||
const old = o.modified.getTime() <= cutoff;
|
||
if (!row && !old) stats.fresh_skipped++;
|
||
else if (!row) await found('orphan_staging', { key: o.key }, remove(o.key));
|
||
else if (row.state === 'ready' && old) await found('published_staging', { key: o.key }, remove(o.key));
|
||
else if (row.state === 'failed' && row.expired) {
|
||
await found('expired_staging', { key: o.key }, async () => {
|
||
await s3.remove(o.key);
|
||
await db.query(`UPDATE attachments SET staging_key = NULL WHERE staging_key = $1 AND state = 'failed'`, [o.key]);
|
||
return true;
|
||
});
|
||
}
|
||
}
|
||
}
|
||
for await (const page of pages(s3, 'variants/', stats)) {
|
||
const r = await db.query('SELECT object_key FROM attachment_variants WHERE object_key = ANY($1)', [page.map((o) => o.key)]);
|
||
stats.db_queries++;
|
||
const known = new Set(r.rows.map((row) => row.object_key));
|
||
for (const o of page) {
|
||
stats.objects++;
|
||
if (known.has(o.key)) continue;
|
||
if (o.modified.getTime() > cutoff) stats.fresh_skipped++;
|
||
else await found('orphan_variant', { key: o.key }, remove(o.key));
|
||
}
|
||
}
|
||
return { ...stats, duration_ms: Math.round(performance.now() - started), max_rss_mb: Math.round(process.resourceUsage().maxRSS / 1024) };
|
||
}
|
||
|
||
async function* pages(s3: Storage, prefix: string, stats: { s3_list: number }): AsyncGenerator<Obj[], undefined> {
|
||
let token: string | undefined;
|
||
do {
|
||
const page = await s3.list(prefix, token);
|
||
stats.s3_list++;
|
||
yield (page.Contents ?? []).map((item) => ({ key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! }));
|
||
token = page.IsTruncated ? page.NextContinuationToken : undefined;
|
||
} while (token);
|
||
return undefined;
|
||
}
|
||
|
||
async function* objects(s3: Storage, stats: { s3_list: number }): AsyncGenerator<Obj, undefined> {
|
||
let token: string | undefined;
|
||
let last = '';
|
||
do {
|
||
const page = await s3.list(PREFIX, token);
|
||
stats.s3_list++;
|
||
for (const item of page.Contents ?? []) {
|
||
// Слияние корректно только на отсортированных потоках: иначе остановиться, а не удалить лишнее.
|
||
if (item.Key! <= last) throw new Error('S3 вернул ключи не по порядку');
|
||
last = item.Key!;
|
||
yield { key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! };
|
||
}
|
||
token = page.IsTruncated ? page.NextContinuationToken : undefined;
|
||
} while (token);
|
||
return undefined;
|
||
}
|
||
|
||
async function* dbRows(db: pg.Pool, t0: Date, stats: { db_queries: number }): AsyncGenerator<Row, undefined> {
|
||
let last = '';
|
||
for (;;) {
|
||
const r = await db.query<Row>(`SELECT id, object_key, state, size_bytes, sha256, updated_at < $2 AS settled
|
||
FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT ${PAGE}`, [last, t0]);
|
||
stats.db_queries++;
|
||
yield* r.rows;
|
||
if (r.rows.length < PAGE) return undefined;
|
||
last = r.rows[r.rows.length - 1].object_key;
|
||
}
|
||
}
|