photo-live/services/sync/src/main.ts

// services/sync/src/main.ts —— sync 发送器进程入口（P2 Task 3）。构建产物
// dist/main.js 由根 dev:sync / 生产启动命令运行；env 一律来自进程环境（根
// dotenv-cli 注入），此处不读文件。循环：每 SYNC_PUSH_INTERVAL_MS 轮询一次
// outbox（SYNC_BATCH_SIZE 一批，high 优先——见 sender.ts 排序说明；满批立即
// 追下一轮，积压排空不被轮询间隔拖慢）。失败退避：连续失败按间隔 ×2^n 指数
// 递增、60s 封顶，成功即归零。优雅退出：SIGINT/SIGTERM 停轮询（等待在飞
// 一轮，fetch 超时已封顶 30s）后断开 Prisma。
import { pino } from 'pino';
import { PrismaClient } from '@photo/db-cn';
import {
  SYNC_BATCH_SIZE,
  SYNC_INTERNAL_KEY_ENV,
  SYNC_PUSH_INTERVAL_MS,
} from '@photo/contracts';
import { OutboxSender } from './sender';

/** 失败退避封顶（对齐 SYNC_RECONCILE_INTERVAL_MS 量级：分钟级封顶足够）。 */
const MAX_BACKOFF_MS = 60_000;
/** 单次 HTTP 请求超时。 */
const REQUEST_TIMEOUT_MS = 30_000;

/** 读正整数 env（可覆盖契约默认值）；非法值回退默认并告警。 */
function readIntEnv(
  logger: { warn: (obj: object, msg: string) => void },
  name: string,
  fallback: number,
): number {
  const raw = process.env[name];
  if (raw === undefined || raw === '') {
    return fallback;
  }
  const parsed = Number.parseInt(raw, 10);
  if (!Number.isFinite(parsed) || parsed <= 0) {
    logger.warn({ name, raw }, 'env 非正整数，回退契约默认值');
    return fallback;
  }
  return parsed;
}

const sleep = (ms: number): Promise<void> =>
  new Promise((resolve) => setTimeout(resolve, ms));

async function main(): Promise<void> {
  const logger = pino({ level: process.env.LOG_LEVEL ?? 'info' });
  const intervalMs = readIntEnv(logger, 'SYNC_PUSH_INTERVAL_MS', SYNC_PUSH_INTERVAL_MS);
  const batchSize = readIntEnv(logger, 'SYNC_BATCH_SIZE', SYNC_BATCH_SIZE);
  const ovApiUrl = process.env.OV_API_URL ?? 'http://127.0.0.1:8081';
  const internalKey = process.env[SYNC_INTERNAL_KEY_ENV] ?? '';
  if (internalKey === '') {
    // 与接收端 guard 同一取舍：密钥缺失宁可不可用，绝不裸推。
    logger.error({ env: SYNC_INTERNAL_KEY_ENV }, '缺少内部同步密钥，发送器退出');
    process.exit(1);
  }

  const prisma = new PrismaClient();
  const sender = new OutboxSender({
    prisma,
    ovApiUrl,
    internalKey,
    batchSize,
    timeoutMs: REQUEST_TIMEOUT_MS,
    logger,
  });
  logger.info(
    { ovApiUrl, intervalMs, batchSize },
    'sync sender started',
  );

  let stopping = false;
  let inFlight: Promise<void> | null = null;
  const loop = async (): Promise<void> => {
    let failureStreak = 0;
    while (!stopping) {
      try {
        const stats = await sender.runOnce();
        failureStreak = 0;
        if (stats.picked > 0) {
          logger.info(stats, 'outbox batch pushed');
        }
        if (stats.picked >= batchSize) {
          continue; // 满批：积压未清，立即追下一轮
        }
      } catch (err) {
        failureStreak += 1;
        const backoffMs = Math.min(
          intervalMs * 2 ** (failureStreak - 1),
          MAX_BACKOFF_MS,
        );
        logger.error(
          {
            err: err instanceof Error ? err.message : String(err),
            failureStreak,
            backoffMs,
          },
          'outbox push failed（整批未标记，下轮重推）',
        );
        await sleep(backoffMs);
        continue;
      }
      await sleep(intervalMs);
    }
  };
  inFlight = loop();

  const shutdown = (signal: string): void => {
    if (stopping) return;
    stopping = true;
    logger.info({ signal }, 'sync sender shutting down');
    void (async () => {
      try {
        // 等在飞一轮收尾（runOnce 各步均有界：HTTP 30s 超时 / DB 查询即回）。
        await inFlight;
        await prisma.$disconnect();
      } catch (err) {
        logger.error(
          { err: err instanceof Error ? err.message : String(err) },
          'sync sender 关闭异常',
        );
      } finally {
        process.exit(0);
      }
    })();
  };
  process.once('SIGINT', () => shutdown('SIGINT'));
  process.once('SIGTERM', () => shutdown('SIGTERM'));
}

void main();