Files
mtusi2026lab7/src/reconcile.ts
T

261 lines
14 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Сверка 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;
}
}