npm - @rocicorp/zero - Versions diffs - 1.11.0-canary.21 → 1.11.0-canary.23 - Mend

@rocicorp/zero 1.11.0-canary.21 → 1.11.0-canary.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (109) hide show

package/out/zero-cache/src/services/change-streamer/storer.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"storer.js","names":["#lc","#shard","#taskID","#discoveryAddress","#discoveryProtocol","#makeConnectionPool","#db","#inserter","#purger","#replicaVersion","#onCommitted","#onFatal","#queue","#backPressureThresholdBytes","#statementTimeoutMs","#changeLogBatchSize","#drainTimeoutMs","#progressMonitor","#withTimeout","#cdc","#approximateQueuedBytes","#running","#readyForMore","#stopped","#processQueue","#cancelQueueEntries","#startCatchup","#flushChangeLog","#trackBackfillMetadata","#maybeReleaseBackPressure","#catchup","#cookieStmts","#upsertTableMetadataStmt","#upsertColumnBackfillStmt","#tx","#released","#failureThresholdMs","#onFailure","#taskUpdates","#timer"],"sources":["../../../../../../zero-cache/src/services/change-streamer/storer.ts"],"sourcesContent":["import {getHeapStatistics} from 'node:v8';\nimport type {LogContext} from '@rocicorp/logger';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport {type PendingQuery, type Row} from 'postgres';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {assert, unreachable} from '../../../../shared/src/asserts.ts';\nimport {\n BigIntJSON,\n type JSONObject,\n} from '../../../../shared/src/bigint-json.ts';\nimport {Queue} from '../../../../shared/src/queue.ts';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport * as v from '../../../../shared/src/valita.ts';\nimport * as Mode from '../../db/mode-enum.ts';\nimport {runTx} from '../../db/run-transaction.ts';\nimport {sharedSnapshot, TransactionPool} from '../../db/transaction-pool.ts';\nimport {type PostgresDB, type PostgresTransaction} from '../../types/pg.ts';\nimport {cdcSchema, type ShardID} from '../../types/shards.ts';\nimport {orTimeout} from '../../types/timeout.ts';\nimport {\n backfillRequestSchema,\n isDataChange,\n isSchemaChange,\n type BackfillID,\n type BackfillRequest,\n type Change,\n type DataChange,\n type Identifier,\n type SchemaChange,\n type TableMetadata,\n} from '../change-source/protocol/current.ts';\nimport {\n type ChangeStreamData,\n type Commit,\n} from '../change-source/protocol/current/downstream.ts';\nimport type {UpstreamStatusMessage} from '../change-source/protocol/current/status.ts';\nimport {\n cookieOps,\n type BackfillCookie,\n type CookieOp,\n type CookieSet,\n type TableMetadataCookie,\n} from '../replicator/change-log-cookies.ts';\nimport type {ReplicatorMode} from '../replicator/replicator.ts';\nimport type {Service} from '../service.ts';\nimport {\n reconstructWatermarkedChange,\n serializeChangeStreamDataWithChange,\n type ChangeLogEntry,\n type SerializedChangeStreamData,\n} from './change-log-codec.ts';\nimport * as ErrorType from './error-type-enum.ts';\nimport {\n AutoResetSignal,\n markResetRequired,\n type BackfillingColumn,\n type TableMetadataRow,\n} from './schema/tables.ts';\nimport type {Subscriber} from './subscriber.ts';\n\n/*\n Factory for creating dynamic connection pools used by the Storer to\n * isolate concurrent transactions into separate pg clients.\n /\nexport type PostgresDBProvider = (\n applicationName: string,\n maxConns: number,\n) => PostgresDB;\n\ntype SubscriberAndMode = {\n subscriber: Subscriber;\n mode: ReplicatorMode;\n};\n\ntype QueueEntry =\n \| [\n 'change',\n watermark: string,\n json: string,\n storedChange: string,\n orig: Exclude<Change, DataChange> \| null, // null for DataChanges\n ]\n \| ['ready', callback: () => void]\n \| ['subscriber', SubscriberAndMode]\n \| ['abort']\n \| 'stop';\n\ntype PendingTransaction = {\n pool: TransactionPool;\n preCommitWatermark: string;\n pos: number;\n startingReplicationState: Promise<ReplicationOwner>;\n ack: boolean;\n // changeLog rows buffered for the next multi-row INSERT flush.\n batch: ChangeLogRow[];\n // The most recently issued flush (or metadata) process, awaited to bound\n // pipeline depth and to order the commit-time replicationState update.\n lastFlush: Promise<unknown> \| undefined;\n};\n\ntype ReplicationOwner = {\n owner: string \| null;\n};\n\nconst backfillRequestsSchema = v.array(backfillRequestSchema);\n\nexport type TuningOptions = {\n backPressureLimitHeapProportion: number;\n statementTimeoutMs: number;\n changeLogBatchSize: number;\n drainTimeoutMs?: number \| undefined;\n};\n\n/\n A single `changeLog` row, accumulated in {@link PendingTransaction.batch}\n * and written via `json_to_recordset()` (see `#flushChangeLog()`).\n /\ntype ChangeLogRow = {\n watermark: string;\n precommit: string \| null;\n pos: number;\n change: string;\n};\n\n/\n Handles the storage of changes and the catchup of subscribers\n * that are behind.\n \n In the context of catchup and cleanup, it is the responsibility of the\n * Storer to decide whether a client can be caught up, or whether the\n * changes needed to catch a client up have been purged.\n \n Maintained invariant: The Change DB is only empty for a\n * completely new replica (i.e. initial-sync with no changes from the\n * replication stream).\n * * In this case, all new subscribers are expected start from the\n * `replicaVersion`, which is the version at which initial sync\n * was performed, and any attempts to catchup from a different\n * point fail.\n \n Conversely, if non-initial changes have flowed through the system\n * (i.e. via the replication stream), the ChangeDB must not be empty,\n * and the earliest change in the `changeLog` represents the earliest\n * \"commit\" from (after) which a subscriber can be caught up.\n * * Any attempts to catchup from an earlier point must fail with\n * a `WatermarkTooOld` error.\n * * Failure to do so could result in streaming changes to the\n * subscriber such that there is a gap in its replication history.\n \n Note: Subscribers (i.e. `incremental-syncer`) consider an \"error\" signal\n * an unrecoverable error and shut down in response. This allows the\n * production system to replace it with a new task and fresh copy of the\n * replica backup.\n /\nexport class Storer implements Service {\n readonly id = 'storer';\n readonly #lc: LogContext;\n readonly #shard: ShardID;\n readonly #taskID: string;\n readonly #discoveryAddress: string;\n readonly #discoveryProtocol: string;\n readonly #makeConnectionPool: PostgresDBProvider;\n\n // Isolated connection pools for steady-state, potentially concurrent\n // queries, in order to avoid a postgres.js connection-swapping bug:\n // https://github.com/porsager/postgres/issues/1204\n readonly #db: PostgresDB;\n readonly #inserter: PostgresDB;\n readonly #purger: PostgresDB;\n\n readonly #replicaVersion: string;\n readonly #onCommitted: (c: Commit) => void;\n readonly #onFatal: (err: Error) => void;\n readonly #queue = new Queue<QueueEntry>();\n readonly #backPressureThresholdBytes: number;\n readonly #statementTimeoutMs: number;\n readonly #changeLogBatchSize: number;\n readonly #drainTimeoutMs: number;\n readonly #progressMonitor: ProgressMonitor;\n\n #approximateQueuedBytes = 0;\n #running = false;\n\n constructor(\n lc: LogContext,\n shard: ShardID,\n taskID: string,\n discoveryAddress: string,\n discoveryProtocol: string,\n dbProvider: PostgresDBProvider,\n replicaVersion: string,\n onCommitted: (c: Commit \| UpstreamStatusMessage) => void,\n onFatal: (err: Error) => void,\n {\n backPressureLimitHeapProportion,\n statementTimeoutMs,\n changeLogBatchSize,\n drainTimeoutMs = 30_000,\n }: TuningOptions,\n ) {\n this.#lc = lc.withContext('component', 'change-log');\n this.#shard = shard;\n this.#taskID = taskID;\n this.#discoveryAddress = discoveryAddress;\n this.#discoveryProtocol = discoveryProtocol;\n this.#makeConnectionPool = dbProvider;\n this.#db = dbProvider('change-stream-init', 3);\n this.#inserter = dbProvider('change-log-inserter', 1);\n this.#purger = dbProvider('change-log-purger', 1);\n this.#replicaVersion = replicaVersion;\n this.#onCommitted = onCommitted;\n this.#onFatal = onFatal;\n this.#statementTimeoutMs = statementTimeoutMs;\n this.#changeLogBatchSize = Math.max(1, changeLogBatchSize);\n this.#drainTimeoutMs = drainTimeoutMs;\n this.#progressMonitor = new ProgressMonitor(\n lc,\n statementTimeoutMs,\n onFatal,\n );\n\n const heapStats = getHeapStatistics();\n this.#backPressureThresholdBytes =\n (heapStats.heap_size_limit - heapStats.used_heap_size) \n backPressureLimitHeapProportion;\n\n this.#lc.info?.(\n `Using up to ${(this.#backPressureThresholdBytes / 1024 2).toFixed(2)} MB of ` +\n `--max-old-space-size (~${(heapStats.heap_size_limit / 1024 2).toFixed(2)} MB) ` +\n `to absorb upstream spikes`,\n {heapStats},\n );\n }\n\n // For readability in SQL statements.\n #cdc(table: string) {\n return this.#db(`${cdcSchema(this.#shard)}.${table}`);\n }\n\n /*\n Bounds a one-off db call (i.e. not part of the main storer loop or the\n * background catchup read, which are tracked by the ProgressMonitor\n * instead) with a plain timeout. This covers calls like\n * {@link assumeOwnership} and {@link getStartStreamInitializationParameters}\n * that are made by the caller before {@link run()} -- and thus before the\n * ProgressMonitor's polling starts -- as well as ones made well after,\n * where a continuously-polling watchdog would be overkill for a single\n * bounded db round trip.\n \n Does not cancel `promise` on timeout (there is no cancellation mechanism\n * for a postgres.js query); it just stops waiting for it, and swallows a\n * later rejection so it doesn't surface as an unhandled rejection.\n /\n async #withTimeout<T>(name: string, promise: Promise<T>): Promise<T> {\n const result = await orTimeout(promise, this.#statementTimeoutMs);\n if (result === 'timed-out') {\n void promise.catch(() => {});\n throw new AbortError(\n `${name} did not complete within ${this.#statementTimeoutMs}ms`,\n );\n }\n return result;\n }\n\n async assumeOwnership(purgeLock?: PurgeLock \| null) {\n const db = this.#db;\n const owner = this.#taskID;\n const ownerAddress = this.#discoveryAddress;\n const ownerProtocol = this.#discoveryProtocol;\n // we omit `ws://` so that old view syncer versions that are not expecting the protocol continue to not get it\n const addressWithProtocol =\n ownerProtocol === 'ws'\n ? ownerAddress\n : `${ownerProtocol}://${ownerAddress}`;\n this.#lc.info?.(`assuming ownership at ${addressWithProtocol}`);\n const start = performance.now();\n await this.#withTimeout(\n 'assume-ownership',\n db`UPDATE ${this.#cdc('replicationState')} SET ${db({owner, ownerAddress: addressWithProtocol})}`,\n );\n const elapsed = (performance.now() - start).toFixed(2);\n this.#lc.info?.(\n `assumed ownership at ${addressWithProtocol} (${elapsed} ms)`,\n );\n\n if (purgeLock) {\n // Once ownership has been assumed, any initial purge-lock preventing the\n // purging of change-log records can be released, as a change-streamer\n // that was attempting to purge records will correspondingly abort on the\n // ownership check.\n void purgeLock.release();\n }\n }\n\n /\n The whole of what a stream connection starts from: where to resume, what to\n * ask the change source to backfill, and the raw cookie set those requests\n * were derived from.\n \n All four statements run in one REPEATABLE READ transaction, so they see one\n * snapshot. That is invariant 15 — the resume watermark and the cookies must\n * come from the same store, read at the same position — and it is why the\n * cookies are read here rather than by a second call: a cookie set paired\n * with a watermark it was not folded to loses every backfill that completed\n * in the interval, and those rows are not replayable from the slot.\n \n `cookies` is not `backfillRequests` in another shape. The request list is\n * driven off `backfilling`, so it drops the metadata of every table with no\n * in-flight backfill — correct for starting a stream, lossy as the cookie\n * snapshot that the SQLite change log continues folding onto.\n /\n async getStartStreamInitializationParameters(): Promise<{\n lastWatermark: string;\n backfillRequests: BackfillRequest[];\n cookies: CookieSet;\n }> {\n const [[{lastWatermark}], result, tableMetadata, backfilling] =\n await this.#withTimeout(\n 'get-stream-params',\n runTx(\n this.#db,\n sql => [\n sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}`,\n\n // Formats a BackfillRequest using json_object_agg() to construct the\n // `columns` object. It is LEFT JOIN'ed with the `tableMetadata` table\n // to make it optional and possibly `null`. The change log does not\n // track backfill progress, so the columns have no `progress`\n // (i.e. they are backfilled from scratch).\n sql`\n SELECT\n json_build_object(\n 'schema', b.\"schema\",\n 'name', b.\"table\",\n 'metadata', t.\"metadata\"\n ) as \"table\",\n json_object_agg(b.\"column\", json_build_object('id', b.\"backfill\"))\n as \"columns\"\n FROM ${this.#cdc('backfilling')} as b\n LEFT JOIN ${this.#cdc('tableMetadata')} as t\n ON (b.\"schema\" = t.\"schema\" AND b.\"table\" = t.\"table\")\n GROUP BY b.\"schema\", b.\"table\", t.\"metadata\"\n `,\n\n // Ordered by primary key, so that this set and the SQLite change log's\n // can be compared row for row. `COLLATE \"C\"` because that comparison is\n // against a store whose TEXT columns sort by byte: a linguistic\n // collation orders `foo-bar` and `foobar` differently than SQLite's\n // BINARY does, which would read as a divergence rather than as the\n // identical set it is.\n sql<TableMetadataCookie[]>`\n SELECT \"schema\", \"table\", \"metadata\" FROM ${this.#cdc('tableMetadata')}\n ORDER BY \"schema\" COLLATE \"C\", \"table\" COLLATE \"C\"`,\n\n sql<BackfillCookie[]>`\n SELECT \"schema\", \"table\", \"column\", \"backfill\" FROM ${this.#cdc('backfilling')}\n ORDER BY \"schema\" COLLATE \"C\", \"table\" COLLATE \"C\", \"column\" COLLATE \"C\"`,\n ],\n {mode: Mode.READONLY},\n ),\n );\n\n return {\n lastWatermark,\n backfillRequests: v.parse(result, backfillRequestsSchema),\n cookies: {\n tableMetadata: [...tableMetadata],\n backfilling: [...backfilling],\n },\n };\n }\n\n async getMinWatermarkForCatchup(): Promise<string \| null> {\n const [{minWatermark}] = await this.#withTimeout(\n 'get-min-watermark',\n this.#db<{minWatermark: string \| null}[]> /sql/ `\n SELECT min(watermark) as \"minWatermark\" FROM ${this.#cdc('changeLog')}`,\n );\n return minWatermark;\n }\n\n /\n Returns the retained Postgres catchup bounds.\n * `minWatermark` is the oldest transaction, or `null` for a new replica.\n * `lastWatermark` is the durable head.\n /\n async getCatchupBounds(): Promise<{\n minWatermark: string \| null;\n lastWatermark: string;\n }> {\n const [bounds] = await this.#withTimeout(\n 'get-catchup-bounds',\n this.#db<{minWatermark: string \| null; lastWatermark: string}[]> /sql/ `\n SELECT\n (SELECT min(watermark) FROM ${this.#cdc('changeLog')}) as \"minWatermark\",\n (SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}) as \"lastWatermark\"`,\n );\n return bounds;\n }\n\n /\n Lists at most `limit` committed transaction watermarks in\n * `(afterWatermark, throughWatermark]`, in ascending order.\n /\n async listCommitWatermarks(\n afterWatermark: string,\n throughWatermark: string,\n limit: number,\n ): Promise<string[]> {\n const rows = await this.#db<{watermark: string}[]> /sql/ `\n SELECT watermark FROM ${this.#cdc('changeLog')}\n WHERE precommit IS NOT NULL\n AND watermark > ${afterWatermark}\n AND watermark <= ${throughWatermark}\n ORDER BY watermark\n LIMIT ${limit}`;\n return rows.map(({watermark}) => watermark);\n }\n\n /\n Reads `(afterWatermark, throughWatermark]` in stream order and bounded batches.\n * This query matches the subscriber catchup query.\n \n Both queries fail when an escaped NUL reaches `change->'tag'`.\n * Postgres cannot convert that value to text.\n /\n readCatchupRange(\n afterWatermark: string,\n throughWatermark: string,\n batchRows = 2000,\n ): AsyncIterable<ChangeLogEntry[]> {\n assert(\n Number.isSafeInteger(batchRows) && batchRows > 0,\n 'Postgres change log batch size must be a positive safe integer',\n );\n return this.#db<ChangeLogEntry[]> /sql/ `\n SELECT watermark, change->'tag' as tag, change::text FROM ${this.#cdc('changeLog')}\n WHERE watermark > ${afterWatermark}\n AND watermark <= ${throughWatermark}\n ORDER BY watermark, pos`.cursor(batchRows) as AsyncIterable<\n ChangeLogEntry[]\n >;\n }\n\n // Note: These are the only db `await`s that are not tracked by the\n // ProgressMonitor, as the delete can legitimately block and/or take\n // an arbitrary amount of time. Luckily, this is a background call and\n // thus cannot cause the storer loop to hang.\n purgeRecordsBefore(watermark: string): Promise<number> {\n return runTx(this.#purger, async sql => {\n // This NOWAIT pre-check is an optimization to abort the transaction\n // (and release associated resources) early.\n await sql<{watermark: string}[]>`\n SELECT watermark FROM ${this.#cdc('changeLog')}\n ORDER BY watermark, pos LIMIT 1\n FOR UPDATE NOWAIT\n `;\n // If the row is purge-locked by an incoming replication-manager, it\n // will assume ownership of the change-log before releasing the lock.\n // This DELETE blocks until the lock is released, allowing the change\n // in ownership to be reliably detected (and the transaction aborted)\n // in the subsequent check.\n const [{deleted}] = await sql<{deleted: bigint}[]>`\n -- The backup watermark can be ahead of the durable changeLog if the\n -- storer is behind but the backup replica has consumed forwarded\n -- changes. Preserve the latest durable changeLog transaction as the\n -- catchup boundary instead of assuming the backup watermark exists.\n -- The storer inserts each changeLog transaction atomically, so any\n -- durable row for a watermark implies the full transaction is durable.\n WITH keep AS (\n SELECT max(watermark) AS watermark\n FROM ${this.#cdc('changeLog')}\n ), purged AS (\n DELETE FROM ${this.#cdc('changeLog')} WHERE watermark < ${watermark} \n AND watermark < (SELECT watermark FROM keep)\n RETURNING watermark, pos\n ) SELECT COUNT() as deleted FROM purged;`;\n\n const [{owner}] = await sql<ReplicationOwner[]>`\n SELECT \"owner\" FROM ${this.#cdc('replicationState')} FOR SHARE`;\n if (owner !== this.#taskID) {\n throw new AbortError(\n `aborting changeLog purge to ${watermark} because ownership has been taken by ${owner}`,\n );\n }\n return Number(deleted);\n });\n }\n\n /*\n @returns The JSON stringified stream message to be sent downstream.\n /\n store(\n watermark: string,\n data: ChangeStreamData,\n serialized: SerializedChangeStreamData = serializeChangeStreamDataWithChange(\n data,\n ),\n ) {\n // Eagerly stringify the JSON payload to:\n // - avoid redundant stringification when fanning out to subscribers\n // - efficiently estimate the amount of memory the payload consumes\n const {json, change: storedChange} = serialized;\n this.#approximateQueuedBytes += json.length;\n\n const change = data[1];\n this.#queue.enqueue([\n 'change',\n watermark,\n json,\n storedChange,\n isDataChange(change) ? null : change, // drop DataChanges to save memory\n ]);\n\n return json;\n }\n\n abort() {\n this.#queue.enqueue(['abort']);\n }\n\n catchup(subscriber: Subscriber, mode: ReplicatorMode) {\n this.#queue.enqueue(['subscriber', {subscriber, mode}]);\n }\n\n #readyForMore: Resolver<void> \| null = null;\n\n readyForMore(): Promise<void> \| undefined {\n if (!this.#running) {\n return undefined;\n }\n if (\n this.#readyForMore === null &&\n this.#approximateQueuedBytes > this.#backPressureThresholdBytes\n ) {\n this.#lc.warn?.(\n `applying back pressure with ${this.#queue.size()} queued changes (~${(this.#approximateQueuedBytes / 1024 * 2).toFixed(2)} MB)\\n` +\n `\\n` +\n `To inspect changeLog backlog in your change DB:\\n` +\n ` SELECT\\n` +\n ` (change->'relation'->>'schema') \|\| '.' \|\| (change->'relation'->>'name') AS table_name,\\n` +\n ` change->>'tag' AS operation,\\n` +\n ` COUNT() AS count\\n` +\n ` FROM \"<app_id>/cdc\".\"changeLog\"\\n` +\n ` GROUP BY 1, 2\\n` +\n ` ORDER BY 3 DESC\\n` +\n ` LIMIT 20;`,\n );\n this.#readyForMore = resolver();\n }\n return this.#readyForMore?.promise;\n }\n\n #maybeReleaseBackPressure() {\n if (this.#readyForMore !== null) {\n // Wait for at least 20% of the threshold to free up.\n if (\n this.#approximateQueuedBytes <\n this.#backPressureThresholdBytes 0.8\n ) {\n this.#lc.info?.(\n `releasing back pressure with ${this.#queue.size()} queued changes (~${(this.#approximateQueuedBytes / 1024 2).toFixed(2)} MB)`,\n );\n this.#readyForMore.resolve();\n this.#readyForMore = null;\n }\n }\n }\n\n /\n * Flushes any buffered {@link PendingTransaction.batch} rows to the changeLog.\n \n Uses `json_to_recordset()` so the batch is a single JSON parameter: the\n * statement text stays constant regardless of batch size, avoiding the\n * unbounded prepared-statement variants (and Postgres memory growth) that a\n * multi-row INSERT would produce. See rocicorp/mono#3511.\n \n Returns (and updates) {@link PendingTransaction.lastFlush}; a no-op when the\n * batch is empty.\n /\n #flushChangeLog(tx: PendingTransaction): Promise<unknown> \| undefined {\n const {batch} = tx;\n if (batch.length === 0) {\n return tx.lastFlush;\n }\n tx.batch = [];\n tx.lastFlush = tx.pool.process(sql => [\n sql`\n INSERT INTO ${this.#cdc('changeLog')} (\"watermark\", \"pos\", \"change\", \"precommit\")\n SELECT \"watermark\", \"pos\", \"change\"::json, \"precommit\"\n FROM json_to_recordset(${batch}) AS x(\n \"watermark\" TEXT,\n \"pos\" INT8,\n \"change\" TEXT,\n \"precommit\" TEXT\n )`,\n ]);\n return tx.lastFlush;\n }\n\n #stopped = promiseVoid;\n\n /\n Runs the storer loop until {@link stop()} is called, or an error is thrown.\n * Once {@link run()} completes, it can be called again.\n /\n async run() {\n assert(!this.#running, `storer is already running`);\n\n const {promise: stopped, resolve: signalStopped} = resolver();\n this.#running = true;\n this.#stopped = stopped;\n\n this.#lc.info?.('starting storer');\n this.#progressMonitor.start(); // Note: This is stopped in stop()\n let err: unknown;\n try {\n await this.#processQueue();\n } catch (e) {\n err = e; // used in finally\n throw e;\n } finally {\n // Release any pending backpressure so the upstream can proceed\n if (this.#readyForMore !== null) {\n this.#readyForMore.resolve();\n this.#readyForMore = null;\n }\n this.#cancelQueueEntries(\n this.#queue.drain().filter(entry => entry !== undefined),\n err,\n );\n this.#running = false;\n signalStopped();\n this.#lc.info?.('storer stopped');\n }\n }\n\n #cancelQueueEntries(queue: QueueEntry[], e: unknown) {\n if (queue.length === 0) {\n return;\n }\n this.#lc.info?.(\n `canceling ${queue.length} entries from the changeLog queue`,\n );\n const err = e instanceof Error ? e : new AbortError('server shutting down');\n for (const entry of queue) {\n if (entry === 'stop') {\n continue;\n }\n const type = entry[0];\n switch (type) {\n case 'subscriber': {\n // Disconnect subscribers waiting to be caught up so that they can\n // reconnect and try again.\n const {subscriber} = entry[1];\n this.#lc.info?.(`disconnecting ${subscriber.id}`);\n subscriber.fail(err);\n break;\n }\n }\n }\n }\n\n async #processQueue() {\n let tx: PendingTransaction \| null = null;\n let msg: QueueEntry \| false;\n\n // Track the progress of each (previous and next) queue entry before it is\n // processed in the loop.\n let lastTaskDone: TaskDoneFn \| undefined;\n const nextMessage = async () => {\n lastTaskDone?.();\n lastTaskDone = undefined;\n const entry = await this.#queue.dequeue();\n if (entry !== 'stop') {\n lastTaskDone = this.#progressMonitor.trackTask({\n task: 'queue-entry',\n // Note: TaskKeys are logged, so only include entry[0] (the type) to\n // avoid logging application data.\n type: entry[0],\n });\n }\n return entry;\n };\n\n const catchupQueue: SubscriberAndMode[] = [];\n try {\n while ((msg = await nextMessage()) !== 'stop') {\n const [msgType] = msg;\n switch (msgType) {\n case 'ready': {\n const signalReady = msg[1];\n signalReady();\n continue;\n }\n case 'subscriber': {\n const subscriber = msg[1];\n if (tx) {\n catchupQueue.push(subscriber); // Wait for the current tx to complete.\n } else {\n await this.#startCatchup([subscriber]); // Catch up immediately.\n }\n continue;\n }\n case 'abort': {\n if (tx) {\n tx.pool.abort();\n await tx.pool.done();\n tx = null;\n }\n continue;\n }\n }\n // msgType === 'change'\n const [_, watermark, json, storedChange, change] = msg;\n const tag = change?.tag;\n this.#approximateQueuedBytes -= json.length;\n\n if (tag === 'begin') {\n assert(!tx, 'received BEGIN in the middle of a transaction');\n const {promise, resolve, reject} = resolver<ReplicationOwner>();\n void promise.catch(() => {}); // handle rejections before the await\n tx = {\n pool: new TransactionPool(\n this.#lc.withContext('watermark', watermark),\n {mode: Mode.READ_COMMITTED},\n ),\n preCommitWatermark: watermark,\n pos: 0,\n startingReplicationState: promise,\n ack: !change.skipAck,\n batch: [],\n lastFlush: undefined,\n };\n tx.pool.run(this.#inserter);\n // Acquire a lock on the replicationState row to detect and/or prevent\n // a concurrent ownership change.\n void tx.pool.process(tx => {\n tx<ReplicationOwner[]> /sql/ `\n SELECT \"owner\" FROM ${this.#cdc('replicationState')} FOR UPDATE`.then(\n ([result]) => resolve(result),\n reject,\n );\n return [];\n });\n } else {\n assert(tx, () => `received change outside of transaction: ${json}`);\n tx.pos++;\n }\n\n const entry: ChangeLogRow = {\n watermark: tag === 'commit' ? watermark : tx.preCommitWatermark,\n precommit: tag === 'commit' ? tx.preCommitWatermark : null,\n pos: tx.pos,\n // For backwards compatibility, only the change message is stored\n // in the cdc changeLog. It was serialized separately with the\n // downstream envelope, so no full-message scan is needed here.\n change: storedChange,\n };\n\n if (change !== null && isSchemaChange(change)) {\n // Schema changes carry backfill / table-metadata statements that\n // must be applied in stream order relative to the changeLog rows.\n // Flush any buffered rows first, then write this row together with\n // its metadata statements as a single unit (preserving the previous\n // per-change ordering for schema changes).\n await this.#flushChangeLog(tx);\n tx.lastFlush = tx.pool.process(sql => [\n sql`INSERT INTO ${this.#cdc('changeLog')} ${sql(entry)}`,\n ...this.#trackBackfillMetadata(sql, change),\n ]);\n } else {\n // Accumulate plain changeLog rows (begin, data changes, commit) and\n // write them as a single multi-row INSERT. Collapsing the per-change\n // single-row INSERTs into batches is the dominant cost reduction for\n // large transactions, where the previous one-statement-per-change\n // path dominated the upstream replication lag.\n tx.batch.push(entry);\n if (tx.batch.length >= this.#changeLogBatchSize) {\n // Bound pipeline depth (and thus memory) by awaiting the previous\n // flush before issuing the next. This is the batched analog of the\n // previous per-100-statement backpressure await, and likewise\n // guards against memory blowup on very large transactions.\n const prevFlush = tx.lastFlush;\n void this.#flushChangeLog(tx);\n await prevFlush;\n }\n }\n this.#maybeReleaseBackPressure();\n\n if (tag === 'commit') {\n // Flush any remaining buffered changeLog rows (including this commit\n // row) before updating the replication state, so the state update is\n // ordered after all changeLog inserts for this transaction.\n void this.#flushChangeLog(tx);\n\n const {owner} = await tx.startingReplicationState;\n if (owner !== this.#taskID) {\n // Ownership change reflected in the replicationState read in 'begin'.\n tx.pool.fail(\n new AbortError(\n `changeLog ownership has been assumed by ${owner}`,\n ),\n );\n } else {\n // Update the replication state.\n const lastWatermark = watermark;\n void tx.pool.process(tx => [\n tx`\n UPDATE ${this.#cdc('replicationState')} SET ${tx({lastWatermark})}`,\n ]);\n tx.pool.setDone();\n }\n\n await tx.pool.done();\n\n // ACK the LSN to the upstream Postgres.\n if (tx.ack) {\n this.#onCommitted(['commit', change, {watermark}]);\n }\n tx = null;\n\n // Before beginning the next transaction, open a READONLY snapshot to\n // concurrently catchup any queued subscribers.\n await this.#startCatchup(catchupQueue.splice(0));\n } else if (tag === 'rollback') {\n // Aborted transactions are not stored in the changeLog. Abort the current tx\n // and process catchup of subscribers that were waiting for it to end.\n tx.pool.abort();\n await tx.pool.done();\n tx = null;\n\n await this.#startCatchup(catchupQueue.splice(0));\n }\n }\n } catch (e) {\n catchupQueue.forEach(({subscriber}) => subscriber.fail(e));\n throw e;\n }\n }\n\n async #startCatchup(subs: SubscriberAndMode[]) {\n const numCatchups = subs.length;\n if (numCatchups === 0) {\n return;\n }\n\n const lc = this.#lc.withContext('pool', 'catchup');\n const {init, cleanup, snapshotID} = sharedSnapshot();\n const reader = new TransactionPool(lc, {\n mode: Mode.READONLY,\n init,\n cleanup,\n initialWorkers: subs.length,\n });\n\n // A dynamic connection pool is created for catchup, sized to the number\n // of subscribers being caught up.\n const catchupConns = this.#makeConnectionPool(\n 'subscriber-catchup',\n numCatchups,\n );\n reader.run(catchupConns);\n\n let lastWatermark: string \| undefined;\n const catchupSnapshotted = this.#progressMonitor.trackTask({\n task: 'capture-catchup-snapshot',\n subscribers: subs.map(({subscriber: s}) => s.id),\n });\n try {\n // Ensure that the transaction has started (and is thus holding a snapshot\n // of the database) before continuing on to commit more changes. This is\n // done by performing a single read on the db, which determines the\n // snapshot for the REPEATABLE_READ transaction.\n [{lastWatermark}] = await reader.processReadTask(\n sql => sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}\n `,\n );\n lc.info?.(\n `snapshotted db at ${lastWatermark} (${await snapshotID}) ` +\n `to catchup ${numCatchups} subscriber(s)`,\n );\n } catch (e) {\n subs.map(({subscriber}) => subscriber.fail(e));\n // Nothing will run the catchup tasks that normally finalize the pool\n // (below), so tear it down here. Otherwise its workers (each holding an\n // open READ ONLY transaction) and the connection pool are leaked.\n reader.abort();\n void catchupConns.end().catch(() => {});\n throw e;\n } finally {\n catchupSnapshotted();\n }\n\n // Run the actual catchup queries in the background. Errors are handled in\n // #catchup() by disconnecting the associated subscriber.\n void Promise.allSettled(\n subs.map(sub =>\n this.#catchup(\n lc.withContext('subscriber', sub.subscriber.id),\n sub,\n lastWatermark,\n reader,\n ),\n ),\n ).finally(() => {\n reader.setDone();\n void catchupConns.end().catch(() => {});\n });\n }\n\n async #catchup(\n lc: LogContext,\n {subscriber: sub, mode}: SubscriberAndMode,\n lastWatermark: string,\n reader: TransactionPool,\n ) {\n let entriesReceived = 0;\n let catchupProgressed = this.#progressMonitor.trackTask({\n task: 'catchup',\n subscriber: sub.id,\n entriesReceived,\n });\n try {\n lc.info?.(`starting catchup`);\n await reader.processReadTask(async tx => {\n lc.info?.(`catching up`);\n const start = Date.now();\n\n // When starting from initial-sync, there won't be a change with a watermark\n // equal to the replica version. This is the empty changeLog scenario.\n let watermarkFound = sub.watermark === this.#replicaVersion;\n let count = 0;\n let lastBatchConsumed: Promise<unknown> \| undefined;\n\n for await (const entries of tx<ChangeLogEntry[]> /sql/ `\n SELECT watermark, change->'tag' as tag, change::text FROM ${this.#cdc('changeLog')}\n WHERE watermark >= ${sub.watermark}\n AND watermark <= ${lastWatermark}\n ORDER BY watermark, pos`.cursor(2000)) {\n catchupProgressed();\n entriesReceived += entries.length;\n\n try {\n // Wait for the last batch of entries to be consumed by the\n // subscriber before sending down the current batch. This pipelining\n // allows one batch of changes to be received from the change-db\n // while the previous batch of changes are sent to the subscriber,\n // resulting in flow control that caps the number of changes\n // referenced in memory to 2 batch-size.\n const start = performance.now();\n await lastBatchConsumed;\n const elapsed = performance.now() - start;\n if (lastBatchConsumed) {\n lc[elapsed > 100 ? 'info' : 'debug']?.(\n `waited ${elapsed.toFixed(3)} ms for ${sub.id} to consume last batch of catchup entries`,\n );\n }\n\n for (const entry of entries) {\n if (entry.watermark === sub.watermark) {\n // This should be the first entry.\n // Catchup starts from after the watermark.\n watermarkFound = true;\n } else if (watermarkFound) {\n lastBatchConsumed = sub.catchup(\n reconstructWatermarkedChange(entry),\n );\n count++;\n } else if (mode === 'backup') {\n throw new AutoResetSignal(\n `backup replica at watermark ${sub.watermark} is behind change db: ${entry.watermark})`,\n );\n } else {\n lc.warn?.(\n `rejecting subscriber at watermark ${sub.watermark} (earliest watermark: ${entry.watermark})`,\n );\n sub.close(\n ErrorType.WatermarkTooOld,\n `earliest supported watermark is ${entry.watermark} (requested ${sub.watermark})`,\n );\n return;\n }\n }\n } finally {\n // Track the db's read of the next chunk of changes.\n catchupProgressed = this.#progressMonitor.trackTask({\n task: 'catchup',\n subscriber: sub.id,\n entriesReceived,\n });\n }\n }\n catchupProgressed();\n\n if (watermarkFound) {\n await lastBatchConsumed;\n lc.info?.(\n `caught up ${sub.id} with ${count} changes (${\n Date.now() - start\n } ms)`,\n );\n } else {\n // The subscriber is ahead of the latest durable changeLog entry\n // (lastWatermark). This can legitimately happen: changes are\n // forwarded to subscribers (the backup replica and view-syncers)\n // concurrently with — and can outrun — the durable store, so a\n // replica may briefly lead the change DB after the storer falls\n // behind or the change-streamer restarts. No catchup is possible or\n // needed; once the change DB catches back up, forwarding resumes and\n // the subscriber dedups any watermarks it already has. Unlike the\n // AutoResetSignal / WatermarkTooOld cases above, this is not a gap in\n // replication history, so the subscriber is simply marked caught up.\n lc.warn?.(\n `subscriber ${sub.id} at watermark ${sub.watermark} is ahead of ` +\n `the latest durable watermark ${lastWatermark}; waiting for the ` +\n `change DB to catch up`,\n );\n }\n // Start draining messages buffered during catchup. The returned promise\n // is intentionally not awaited here: while the drain is in progress,\n // new sends keep appending to the subscriber backlog and inherit its\n // byte-based backpressure.\n void sub.setCaughtUp();\n });\n } catch (err) {\n lc.error?.(`error while catching up subscriber ${sub.id}`, err);\n if (err instanceof AutoResetSignal) {\n await markResetRequired(this.#db, this.#shard);\n this.#onFatal(err);\n }\n sub.fail(err);\n } finally {\n catchupProgressed();\n }\n }\n\n /*\n Returns the db statements necessary to track backfill and table metadata\n * presented in the `change`, if any.\n \n This is the Postgres interpreter of {@link cookieOps}, which is also\n * interpreted against the SQLite change log by `ChangeLogCookieWriter`. The\n * two stores have to agree on every transition forever, and the failure mode\n * if they drift is a backfill that is silently never re-requested — so the\n * decision of what a schema change means lives in one place and only its\n * transport lives here.\n /\n #trackBackfillMetadata(sql: PostgresTransaction, change: SchemaChange) {\n return cookieOps(change).flatMap(op => this.#cookieStmts(sql, op));\n }\n\n #cookieStmts(sql: PostgresTransaction, op: CookieOp): PendingQuery<Row[]>[] {\n switch (op.op) {\n case 'upsert-metadata':\n return [this.#upsertTableMetadataStmt(sql, op.table, op.metadata)];\n\n case 'upsert-backfill':\n return [\n this.#upsertColumnBackfillStmt(sql, op.table, op.column, op.backfill),\n ];\n\n case 'rename-table': {\n const {old} = op;\n const row = {schema: op.new.schema, table: op.new.name};\n return [\n sql`UPDATE ${this.#cdc('tableMetadata')} SET ${sql(row)}\n WHERE \"schema\" = ${old.schema} AND \"table\" = ${old.name}`,\n sql`UPDATE ${this.#cdc('backfilling')} SET ${sql(row)}\n WHERE \"schema\" = ${old.schema} AND \"table\" = ${old.name}`,\n ];\n }\n\n case 'drop-table': {\n const {schema, name} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('tableMetadata')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name}`,\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name}`,\n ];\n }\n\n case 'rename-column': {\n const {schema, name: table} = op.table;\n return [\n sql`UPDATE ${this.#cdc('backfilling')} SET \"column\" = ${op.new}\n WHERE \"schema\" = ${schema} AND \"table\" = ${table} AND \"column\" = ${op.old}`,\n ];\n }\n\n case 'drop-column': {\n const {schema, name} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name} AND \"column\" = ${op.column}`,\n ];\n }\n\n case 'complete-backfill': {\n const {schema, name: table} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${table} AND \"column\" IN ${sql([...op.columns])}`,\n ];\n }\n\n default:\n unreachable(op);\n }\n }\n\n #upsertTableMetadataStmt(\n sql: PostgresTransaction,\n {schema, name: table}: Identifier,\n metadata: TableMetadata,\n ) {\n const row: TableMetadataRow = {schema, table, metadata};\n return sql`\n INSERT INTO ${this.#cdc('tableMetadata')} ${sql(row)}\n ON CONFLICT (\"schema\", \"table\")\n DO UPDATE SET ${sql(row)};\n `;\n }\n\n #upsertColumnBackfillStmt(\n sql: PostgresTransaction,\n {schema, name: table}: Identifier,\n column: string,\n backfill: BackfillID,\n ) {\n const row: BackfillingColumn = {schema, table, column, backfill};\n return sql`\n INSERT INTO ${this.#cdc('backfilling')} ${sql(row)}\n ON CONFLICT (\"schema\", \"table\", \"column\")\n DO UPDATE SET ${sql(row)};\n `;\n }\n\n /\n Waits until all currently queued entries have been processed.\n * This is only used in tests.\n /\n async allProcessed() {\n if (this.#running) {\n const {promise, resolve} = resolver();\n this.#queue.enqueue(['ready', resolve]);\n await promise;\n }\n }\n\n /\n Stops the storer and waits up to a drain timeout for entries to drain,\n * throwing an exception if it doesn't drain in time, in order to abort\n * the server when PG (or the connection to it) appears to be wedged.\n /\n async stop() {\n if (this.#running) {\n this.#progressMonitor.stop();\n this.#lc.info?.(`draining ${this.#queue.size()} changeLog entries`);\n this.abort(); // for cleanliness, abort any open transactions\n this.#queue.enqueue('stop');\n }\n if (\n (await orTimeout(this.#stopped, this.#drainTimeoutMs)) === 'timed-out'\n ) {\n throw new AbortError(\n `changeLog did not drain within ${this.#drainTimeoutMs}ms`,\n );\n }\n }\n}\n\nexport class PurgeLock {\n readonly #lc: LogContext;\n readonly #tx: TransactionPool;\n readonly replicaVersion: string;\n readonly minWatermark: string;\n\n constructor(\n lc: LogContext,\n tx: TransactionPool,\n replicaVersion: string,\n watermark: string,\n ) {\n this.#lc = lc;\n this.#tx = tx;\n this.replicaVersion = replicaVersion;\n this.minWatermark = watermark;\n }\n\n #released = false;\n\n async release() {\n if (this.#released) {\n return;\n }\n this.#released = true;\n this.#tx.setDone();\n await this.#tx\n .done()\n .catch(e => this.#lc.warn?.(`error from purge-lock release`, e));\n this.#lc.info?.(`released purge lock on ${this.minWatermark}`);\n }\n}\n\nexport class PurgeLocker {\n readonly #lc: LogContext;\n readonly #shard: ShardID;\n readonly #db: PostgresDB;\n\n constructor(lc: LogContext, shard: ShardID, db: PostgresDB) {\n this.#lc = lc.withContext('component', 'purge-locker');\n this.#shard = shard;\n this.#db = db;\n }\n\n // For readability in SQL statements.\n #cdc(table: string) {\n return this.#db(`${cdcSchema(this.#shard)}.${table}`);\n }\n\n async acquire() {\n const tx = new TransactionPool(this.#lc, {mode: Mode.READ_COMMITTED}).run(\n this.#db,\n );\n const row = await tx.processReadTask(\n sql => sql<{watermark: string}[]>`\n SELECT watermark FROM ${this.#cdc('changeLog')}\n ORDER BY watermark, pos LIMIT 1\n FOR SHARE \n `,\n );\n if (row.length === 0) {\n this.#lc.info?.(`changeLog is empty. No rows to purge-lock.`);\n tx.setDone();\n await tx.done();\n return null;\n }\n const [{watermark}] = row;\n const [{replicaVersion}] = await tx.processReadTask(\n sql => sql<{replicaVersion: string}[]>`\n SELECT \"replicaVersion\" FROM ${this.#cdc('replicationConfig')}\n `,\n );\n this.#lc.info?.(\n `locked watermark ${watermark} from being purged from replica@${replicaVersion}`,\n );\n return new PurgeLock(this.#lc, tx, replicaVersion, watermark);\n }\n}\n\n// A TaskKey, keyed by identity, representing an db task monitored by the\n// ProgressMonitor. The contents are stringified in error messages if the\n// task fails to make progress for more than a failure threshold interval.\ntype TaskKey = JSONObject;\n\ntype TaskDoneFn = () => void;\n\n/\n Periodic monitor for detecting the pathological condition in which a db\n * query hangs forever because of a connection problem, such as a half-closed\n * socket.\n \n Use this for db calls that recur or accumulate progress within a single\n * logical operation on the main storer loop (e.g. the queue-processing loop,\n * or a multi-batch catchup read), where \"no progress for N ms\" is the\n * meaningful signal. For a one-off db call -- including ones made before\n * {@link Storer.run} starts this monitor's polling -- use a plain timeout\n * (see `Storer.#withTimeout`) instead.\n \n The failure handler should stop the server. The ProgressMonitor will\n * assume this and stop itself after calling it.\n \n Internal to the Storer, but exported for testing.\n /\nexport class ProgressMonitor {\n readonly #lc: LogContext;\n readonly #failureThresholdMs;\n readonly #onFailure: (err: Error) => void;\n readonly #taskUpdates = new Map<TaskKey, Date>();\n\n #timer: NodeJS.Timeout \| undefined;\n\n constructor(\n lc: LogContext,\n failureThresholdMs: number,\n onFailure: (err: Error) => void,\n ) {\n this.#lc = lc.withContext('component', 'storer-progress-monitor');\n this.#failureThresholdMs = failureThresholdMs;\n this.#onFailure = onFailure;\n }\n\n start() {\n clearInterval(this.#timer);\n this.#timer = setInterval(\n () => this.checkTaskProgress(new Date()),\n this.#failureThresholdMs,\n ).unref();\n }\n\n // Called by an internal periodic timer, but exported for testing.\n checkTaskProgress(now: Date) {\n for (const [task, lastUpdate] of this.#taskUpdates.entries()) {\n if (now.getTime() - lastUpdate.getTime() >= this.#failureThresholdMs) {\n this.#lc.error?.(\n `Last task update was more than ${this.#failureThresholdMs}ms ago`,\n {task, lastUpdate},\n );\n this.#onFailure(\n new Error(\n `Task failed to progress for over ${this.#failureThresholdMs}ms: ${BigIntJSON.stringify(task)}`,\n ),\n );\n this.stop();\n return;\n }\n }\n }\n\n /\n Starts a task to be tracked.\n \n @return a callback to invoke when the task is done.\n */\n trackTask(task: TaskKey, now = new Date()): TaskDoneFn {\n this.#taskUpdates.set(task, now);\n return () => {\n this.#taskUpdates.delete(task);\n };\n }\n\n stop() {\n clearInterval(this.#timer);\n this.#taskUpdates.clear();\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"storer.js","names":["#lc","#shard","#taskID","#discoveryAddress","#discoveryProtocol","#makeConnectionPool","#db","#inserter","#purger","#replicaVersion","#onCommitted","#onFatal","#queue","#backPressureThresholdBytes","#statementTimeoutMs","#changeLogBatchSize","#drainTimeoutMs","#progressMonitor","#withTimeout","#ownerAddress","#pendingOwnership","#tryAssumeOwnership","#cdc","#approximateQueuedBytes","#running","#readyForMore","#stopped","#processQueue","#cancelQueueEntries","#startCatchup","#ownershipAssumed","#processChange","#maybeReleaseBackPressure","#flushChangeLog","#trackBackfillMetadata","#catchup","#cookieStmts","#upsertTableMetadataStmt","#upsertColumnBackfillStmt","#tx","#released","#failureThresholdMs","#onFailure","#taskUpdates","#timer"],"sources":["../../../../../../zero-cache/src/services/change-streamer/storer.ts"],"sourcesContent":["import {getHeapStatistics} from 'node:v8';\nimport type {LogContext} from '@rocicorp/logger';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport {type PendingQuery, type Row} from 'postgres';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {assert, unreachable} from '../../../../shared/src/asserts.ts';\nimport {\n BigIntJSON,\n type JSONObject,\n} from '../../../../shared/src/bigint-json.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {Queue} from '../../../../shared/src/queue.ts';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport * as v from '../../../../shared/src/valita.ts';\nimport * as Mode from '../../db/mode-enum.ts';\nimport {runTx} from '../../db/run-transaction.ts';\nimport {sharedSnapshot, TransactionPool} from '../../db/transaction-pool.ts';\nimport {type PostgresDB, type PostgresTransaction} from '../../types/pg.ts';\nimport {cdcSchema, type ShardID} from '../../types/shards.ts';\nimport {orTimeout} from '../../types/timeout.ts';\nimport {\n backfillRequestSchema,\n isDataChange,\n isSchemaChange,\n type BackfillID,\n type BackfillRequest,\n type Change,\n type DataChange,\n type Identifier,\n type SchemaChange,\n type TableMetadata,\n} from '../change-source/protocol/current.ts';\nimport {\n type ChangeStreamData,\n type Commit,\n} from '../change-source/protocol/current/downstream.ts';\nimport type {UpstreamStatusMessage} from '../change-source/protocol/current/status.ts';\nimport {\n cookieOps,\n type BackfillCookie,\n type CookieOp,\n type CookieSet,\n type TableMetadataCookie,\n} from '../replicator/change-log-cookies.ts';\nimport type {ReplicatorMode} from '../replicator/replicator.ts';\nimport type {Service} from '../service.ts';\nimport {\n reconstructWatermarkedChange,\n serializeChangeStreamDataWithChange,\n type ChangeLogEntry,\n type SerializedChangeStreamData,\n} from './change-log-codec.ts';\nimport * as ErrorType from './error-type-enum.ts';\nimport {\n AutoResetSignal,\n markResetRequired,\n reinitializeChangeLog,\n type BackfillingColumn,\n type ChangeLogReinitialization,\n type TableMetadataRow,\n} from './schema/tables.ts';\nimport type {Subscriber} from './subscriber.ts';\n\n/*\n Factory for creating dynamic connection pools used by the Storer to\n * isolate concurrent transactions into separate pg clients.\n /\nexport type PostgresDBProvider = (\n applicationName: string,\n maxConns: number,\n) => PostgresDB;\n\ntype SubscriberAndMode = {\n subscriber: Subscriber;\n mode: ReplicatorMode;\n};\n\ntype QueueEntry =\n \| [\n 'change',\n watermark: string,\n json: string,\n storedChange: string,\n orig: Exclude<Change, DataChange> \| null, // null for DataChanges\n ]\n \| ['ready', callback: () => void]\n \| ['subscriber', SubscriberAndMode]\n \| ['status', watermark: string]\n \| ['abort']\n \| 'stop';\n\n/\n A transaction that is not stored because it was already stored by the\n * previous owner of the change log (see {@link Storer.assumeOwnershipAtHead}).\n /\ntype SkippedTransaction = {\n skipped: true;\n ack: boolean;\n};\n\ntype PendingTransaction = {\n skipped?: undefined;\n pool: TransactionPool;\n preCommitWatermark: string;\n pos: number;\n startingReplicationState: Promise<ReplicationOwner>;\n ack: boolean;\n // changeLog rows buffered for the next multi-row INSERT flush.\n batch: ChangeLogRow[];\n // The most recently issued flush (or metadata) process, awaited to bound\n // pipeline depth and to order the commit-time replicationState update.\n lastFlush: Promise<unknown> \| undefined;\n // Set if ownership of the change log is assumed in this transaction.\n ownershipAssumed: AssumedOwnership \| undefined;\n};\n\n/* The state of the change log at which ownership was assumed. /\ntype AssumedOwnership = {\n /* The last watermark stored by the previous owner. /\n head: string;\n /* Whether the change log has pending backfills. /\n backfilling: boolean;\n};\n\nexport type OwnershipTakeover = {\n /\n The lock that prevents the previous owner from purging the change log\n * (from which this change-streamer's replica was restored), released once\n * ownership is assumed.\n /\n purgeLock: PurgeLock \| null;\n /\n Requests a restart of the change stream (at a transaction boundary),\n * which is used to start pending backfills once ownership is assumed.\n /\n requestRestart: (reason: string) => void;\n};\n\ntype ReplicationOwner = {\n owner: string \| null;\n};\n\nconst backfillRequestsSchema = v.array(backfillRequestSchema);\n\nexport type TuningOptions = {\n backPressureLimitHeapProportion: number;\n statementTimeoutMs: number;\n changeLogBatchSize: number;\n drainTimeoutMs?: number \| undefined;\n};\n\n/\n A single `changeLog` row, accumulated in {@link PendingTransaction.batch}\n * and written via `json_to_recordset()` (see `#flushChangeLog()`).\n /\ntype ChangeLogRow = {\n watermark: string;\n precommit: string \| null;\n pos: number;\n change: string;\n};\n\n/\n Handles the storage of changes and the catchup of subscribers\n * that are behind.\n \n In the context of catchup and cleanup, it is the responsibility of the\n * Storer to decide whether a client can be caught up, or whether the\n * changes needed to catch a client up have been purged.\n \n Maintained invariant: The Change DB is only empty for a\n * completely new replica (i.e. initial-sync with no changes from the\n * replication stream).\n * * In this case, all new subscribers are expected start from the\n * `replicaVersion`, which is the version at which initial sync\n * was performed, and any attempts to catchup from a different\n * point fail.\n \n Conversely, if non-initial changes have flowed through the system\n * (i.e. via the replication stream), the ChangeDB must not be empty,\n * and the earliest change in the `changeLog` represents the earliest\n * \"commit\" from (after) which a subscriber can be caught up.\n * * Any attempts to catchup from an earlier point must fail with\n * a `WatermarkTooOld` error.\n * * Failure to do so could result in streaming changes to the\n * subscriber such that there is a gap in its replication history.\n \n Note: Subscribers (i.e. `incremental-syncer`) consider an \"error\" signal\n * an unrecoverable error and shut down in response. This allows the\n * production system to replace it with a new task and fresh copy of the\n * replica backup.\n /\nexport class Storer implements Service {\n readonly id = 'storer';\n readonly #lc: LogContext;\n readonly #shard: ShardID;\n readonly #taskID: string;\n readonly #discoveryAddress: string;\n readonly #discoveryProtocol: string;\n readonly #makeConnectionPool: PostgresDBProvider;\n\n // Isolated connection pools for steady-state, potentially concurrent\n // queries, in order to avoid a postgres.js connection-swapping bug:\n // https://github.com/porsager/postgres/issues/1204\n readonly #db: PostgresDB;\n readonly #inserter: PostgresDB;\n readonly #purger: PostgresDB;\n\n readonly #replicaVersion: string;\n readonly #onCommitted: (c: Commit) => void;\n readonly #onFatal: (err: Error) => void;\n\n /\n Set while waiting to assume ownership of the change log at its head\n * (see {@link assumeOwnershipAtHead}).\n /\n #pendingOwnership:\n \| (OwnershipTakeover & {\n /* The last known head of the change log, which only moves forward. /\n head: string;\n /* Whether a backfill transaction was skipped. /\n skippedBackfill: boolean;\n start: number;\n })\n \| null = null;\n readonly #queue = new Queue<QueueEntry>();\n readonly #backPressureThresholdBytes: number;\n readonly #statementTimeoutMs: number;\n readonly #changeLogBatchSize: number;\n readonly #drainTimeoutMs: number;\n readonly #progressMonitor: ProgressMonitor;\n\n #approximateQueuedBytes = 0;\n #running = false;\n\n constructor(\n lc: LogContext,\n shard: ShardID,\n taskID: string,\n discoveryAddress: string,\n discoveryProtocol: string,\n dbProvider: PostgresDBProvider,\n replicaVersion: string,\n onCommitted: (c: Commit \| UpstreamStatusMessage) => void,\n onFatal: (err: Error) => void,\n {\n backPressureLimitHeapProportion,\n statementTimeoutMs,\n changeLogBatchSize,\n drainTimeoutMs = 30_000,\n }: TuningOptions,\n ) {\n this.#lc = lc.withContext('component', 'change-log');\n this.#shard = shard;\n this.#taskID = taskID;\n this.#discoveryAddress = discoveryAddress;\n this.#discoveryProtocol = discoveryProtocol;\n this.#makeConnectionPool = dbProvider;\n this.#db = dbProvider('change-stream-init', 3);\n this.#inserter = dbProvider('change-log-inserter', 1);\n this.#purger = dbProvider('change-log-purger', 1);\n this.#replicaVersion = replicaVersion;\n this.#onCommitted = onCommitted;\n this.#onFatal = onFatal;\n this.#statementTimeoutMs = statementTimeoutMs;\n this.#changeLogBatchSize = Math.max(1, changeLogBatchSize);\n this.#drainTimeoutMs = drainTimeoutMs;\n this.#progressMonitor = new ProgressMonitor(\n lc,\n statementTimeoutMs,\n onFatal,\n );\n\n const heapStats = getHeapStatistics();\n this.#backPressureThresholdBytes =\n (heapStats.heap_size_limit - heapStats.used_heap_size) \n backPressureLimitHeapProportion;\n\n this.#lc.info?.(\n `Using up to ${(this.#backPressureThresholdBytes / 1024 2).toFixed(2)} MB of ` +\n `--max-old-space-size (~${(heapStats.heap_size_limit / 1024 2).toFixed(2)} MB) ` +\n `to absorb upstream spikes`,\n {heapStats},\n );\n }\n\n // For readability in SQL statements.\n #cdc(table: string) {\n return this.#db(`${cdcSchema(this.#shard)}.${table}`);\n }\n\n /*\n Bounds a one-off db call (i.e. not part of the main storer loop or the\n * background catchup read, which are tracked by the ProgressMonitor\n * instead) with a plain timeout. This covers calls like\n * {@link assumeOwnership} and {@link getStartStreamInitializationParameters}\n * that are made by the caller before {@link run()} -- and thus before the\n * ProgressMonitor's polling starts -- as well as ones made well after,\n * where a continuously-polling watchdog would be overkill for a single\n * bounded db round trip.\n \n Does not cancel `promise` on timeout (there is no cancellation mechanism\n * for a postgres.js query); it just stops waiting for it, and swallows a\n * later rejection so it doesn't surface as an unhandled rejection.\n /\n async #withTimeout<T>(name: string, promise: Promise<T>): Promise<T> {\n const result = await orTimeout(promise, this.#statementTimeoutMs);\n if (result === 'timed-out') {\n void promise.catch(() => {});\n throw new AbortError(\n `${name} did not complete within ${this.#statementTimeoutMs}ms`,\n );\n }\n return result;\n }\n\n #ownerAddress() {\n const ownerAddress = this.#discoveryAddress;\n const ownerProtocol = this.#discoveryProtocol;\n // we omit `ws://` so that old view syncer versions that are not expecting the protocol continue to not get it\n return ownerProtocol === 'ws'\n ? ownerAddress\n : `${ownerProtocol}://${ownerAddress}`;\n }\n\n /\n Re-initializes a change log that is no longer maintained from the\n * replica's state, taking ownership of it in the process (which is then\n * assumed again at its new head, see {@link assumeOwnershipAtHead}).\n * See {@link reinitializeChangeLog}.\n /\n reinitializeFromReplica(\n params: Omit<ChangeLogReinitialization, 'owner' \| 'ownerAddress'>,\n ): Promise<'reinitialized' \| 'maintained'> {\n return reinitializeChangeLog(\n this.#lc,\n this.#db,\n this.#shard,\n {...params, owner: this.#taskID, ownerAddress: this.#ownerAddress()},\n // The purge lock (if any) is released before the change log is\n // truncated, as it locks a row of it.\n this.#pendingOwnership?.purgeLock ?? undefined,\n );\n }\n\n /\n Prepares to assume ownership of the change log at its head, while it may\n * still be owned and maintained by another change-streamer. This allows the\n * previous owner to continue to serve subscribers while this change-source's\n * upstream decodes the WAL to catch up to the head of the change log, which\n * may be many minutes worth of transactions for large DBs.\n \n Once the change stream is started from the head of the change log:\n \n * Transactions that the change log already contains (i.e. stored by the\n * previous owner) are not stored again, but are otherwise processed\n * normally (e.g. for upstream acks, since they have been stored).\n * * Ownership is assumed in the transaction that stores the first\n * transaction past the head of the change log. The previous owner's\n * (subsequent) transactions fail its ownership check, which makes this\n * transaction the one immediately after the previous owner's last one.\n * * Ownership is also assumed upon a {@link status} at or past the head of\n * the change log (outside of a transaction), which covers an idle\n * upstream: all transactions up to the status position have been\n * received, and any past the head would have been stored.\n \n Subscribers are caught up from the change log as usual, as the stream\n * (which is forwarded to them) starts from its head.\n \n Backfill transactions are synthesized by each change-streamer's change\n * source, and thus never correspond to those stored by the previous owner.\n * Until ownership is assumed, they are not stored, and no backfills are\n * requested from the change log (see\n * {@link getStartStreamInitializationParameters}). Once ownership is\n * assumed, a restart of the change stream is requested if the change log has\n * pending backfills or if a backfill transaction was skipped.\n /\n assumeOwnershipAtHead(takeover: OwnershipTakeover) {\n this.#pendingOwnership = {\n ...takeover,\n head: '',\n skippedBackfill: false,\n start: performance.now(),\n };\n }\n\n /\n Whether ownership of the change log is pending, i.e. after\n * {@link assumeOwnershipAtHead} and before ownership is assumed.\n /\n get ownershipPending(): boolean {\n return this.#pendingOwnership !== null;\n }\n\n /\n Relays a status message received outside of a transaction, which is\n * used to assume ownership of the change log on an idle upstream. A no-op\n * unless ownership is pending.\n /\n status(watermark: string) {\n if (this.#pendingOwnership) {\n this.#queue.enqueue(['status', watermark]);\n }\n }\n\n /\n Assumes ownership if the change log contains nothing past `watermark`.\n * Otherwise, updates the known head of the change log.\n \n @param ifBefore When set, ownership is only assumed if the head of the\n * change log is before (rather than at or before) the `watermark`,\n * i.e. when the watermark is that of a transaction to be stored.\n * @returns The state of the change log at which ownership is assumed (in\n * `tx`), or `null` if ownership was not assumed.\n /\n async #tryAssumeOwnership(\n tx: TransactionPool,\n watermark: string,\n ifBefore: boolean,\n ): Promise<AssumedOwnership \| null> {\n const pending = must(this.#pendingOwnership);\n const [state] = await tx.processReadTask(\n sql => sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')} FOR UPDATE`,\n );\n const head = state.lastWatermark;\n pending.head = head > pending.head ? head : pending.head;\n if (ifBefore ? head >= watermark : head > watermark) {\n return null;\n }\n const owner = this.#taskID;\n const ownerAddress = this.#ownerAddress();\n void tx.process(sql => [\n sql`UPDATE ${this.#cdc('replicationState')} SET ${sql({owner, ownerAddress})}`,\n ]);\n // Read with the replicationState row locked, i.e. consistent with the head.\n const [{backfilling}] = await tx.processReadTask(\n sql => sql<{backfilling: boolean}[]>`\n SELECT EXISTS (SELECT 1 FROM ${this.#cdc('backfilling')}) AS \"backfilling\"`,\n );\n this.#lc.info?.(\n `assuming ownership at ${ownerAddress} after change log head ${head}`,\n );\n return {head, backfilling};\n }\n\n #ownershipAssumed({head, backfilling}: AssumedOwnership) {\n const {purgeLock, requestRestart, skippedBackfill, start} = must(\n this.#pendingOwnership,\n );\n this.#pendingOwnership = null;\n this.#lc.info?.(\n `assumed ownership of the change log at ${head} after ` +\n `${(performance.now() - start).toFixed(2)} ms`,\n );\n // Once ownership has been assumed, the initial purge lock can be released,\n // as a change-streamer that was attempting to purge records will\n // correspondingly abort on the ownership check.\n void purgeLock?.release();\n if (backfilling \|\| skippedBackfill) {\n requestRestart(`resuming backfills after assuming ownership`);\n }\n }\n\n /\n Assumes ownership of the change log immediately, regardless of its head.\n * This is used for in tests.\n \n A production change-streamer instead takes over the change log at its head\n * (see {@link assumeOwnershipAtHead}).\n /\n async assumeOwnership() {\n const db = this.#db;\n const owner = this.#taskID;\n const addressWithProtocol = this.#ownerAddress();\n this.#lc.info?.(`assuming ownership at ${addressWithProtocol}`);\n const start = performance.now();\n await this.#withTimeout(\n 'assume-ownership',\n db`UPDATE ${this.#cdc('replicationState')} SET ${db({owner, ownerAddress: addressWithProtocol})}`,\n );\n const elapsed = (performance.now() - start).toFixed(2);\n this.#lc.info?.(\n `assumed ownership at ${addressWithProtocol} (${elapsed} ms)`,\n );\n }\n\n /\n The whole of what a stream connection starts from: where to resume, what to\n * ask the change source to backfill, and the raw cookie set those requests\n * were derived from.\n \n All four statements run in one REPEATABLE READ transaction, so they see one\n * snapshot. That is invariant 15 — the resume watermark and the cookies must\n * come from the same store, read at the same position — and it is why the\n * cookies are read here rather than by a second call: a cookie set paired\n * with a watermark it was not folded to loses every backfill that completed\n * in the interval, and those rows are not replayable from the slot.\n \n `cookies` is not `backfillRequests` in another shape. The request list is\n * driven off `backfilling`, so it drops the metadata of every table with no\n * in-flight backfill — correct for starting a stream, lossy as the cookie\n * snapshot that the SQLite change log continues folding onto.\n /\n async getStartStreamInitializationParameters(): Promise<{\n lastWatermark: string;\n backfillRequests: BackfillRequest[];\n cookies: CookieSet;\n }> {\n const [[{lastWatermark}], result, tableMetadata, backfilling] =\n await this.#withTimeout(\n 'get-stream-params',\n runTx(\n this.#db,\n sql => [\n sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}`,\n\n // Formats a BackfillRequest using json_object_agg() to construct the\n // `columns` object. It is LEFT JOIN'ed with the `tableMetadata` table\n // to make it optional and possibly `null`. The change log does not\n // track backfill progress, so the columns have no `progress`\n // (i.e. they are backfilled from scratch).\n sql`\n SELECT\n json_build_object(\n 'schema', b.\"schema\",\n 'name', b.\"table\",\n 'metadata', t.\"metadata\"\n ) as \"table\",\n json_object_agg(b.\"column\", json_build_object('id', b.\"backfill\"))\n as \"columns\"\n FROM ${this.#cdc('backfilling')} as b\n LEFT JOIN ${this.#cdc('tableMetadata')} as t\n ON (b.\"schema\" = t.\"schema\" AND b.\"table\" = t.\"table\")\n GROUP BY b.\"schema\", b.\"table\", t.\"metadata\"\n `,\n\n // Ordered by primary key, so that this set and the SQLite change log's\n // can be compared row for row. `COLLATE \"C\"` because that comparison is\n // against a store whose TEXT columns sort by byte: a linguistic\n // collation orders `foo-bar` and `foobar` differently than SQLite's\n // BINARY does, which would read as a divergence rather than as the\n // identical set it is.\n sql<TableMetadataCookie[]>`\n SELECT \"schema\", \"table\", \"metadata\" FROM ${this.#cdc('tableMetadata')}\n ORDER BY \"schema\" COLLATE \"C\", \"table\" COLLATE \"C\"`,\n\n sql<BackfillCookie[]>`\n SELECT \"schema\", \"table\", \"column\", \"backfill\" FROM ${this.#cdc('backfilling')}\n ORDER BY \"schema\" COLLATE \"C\", \"table\" COLLATE \"C\", \"column\" COLLATE \"C\"`,\n ],\n {mode: Mode.READONLY},\n ),\n );\n\n return {\n lastWatermark,\n // Backfills are not requested before ownership is assumed.\n // See assumeOwnershipAtHead().\n backfillRequests: this.#pendingOwnership\n ? []\n : v.parse(result, backfillRequestsSchema),\n cookies: {\n tableMetadata: [...tableMetadata],\n backfilling: [...backfilling],\n },\n };\n }\n\n async getMinWatermarkForCatchup(): Promise<string \| null> {\n const [{minWatermark}] = await this.#withTimeout(\n 'get-min-watermark',\n this.#db<{minWatermark: string \| null}[]> /sql/ `\n SELECT min(watermark) as \"minWatermark\" FROM ${this.#cdc('changeLog')}`,\n );\n return minWatermark;\n }\n\n /\n Returns the retained Postgres catchup bounds.\n * `minWatermark` is the oldest transaction, or `null` for a new replica.\n * `lastWatermark` is the durable head.\n /\n async getCatchupBounds(): Promise<{\n minWatermark: string \| null;\n lastWatermark: string;\n }> {\n const [bounds] = await this.#withTimeout(\n 'get-catchup-bounds',\n this.#db<{minWatermark: string \| null; lastWatermark: string}[]> /sql/ `\n SELECT\n (SELECT min(watermark) FROM ${this.#cdc('changeLog')}) as \"minWatermark\",\n (SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}) as \"lastWatermark\"`,\n );\n return bounds;\n }\n\n /\n Lists at most `limit` committed transaction watermarks in\n * `(afterWatermark, throughWatermark]`, in ascending order.\n /\n async listCommitWatermarks(\n afterWatermark: string,\n throughWatermark: string,\n limit: number,\n ): Promise<string[]> {\n const rows = await this.#db<{watermark: string}[]> /sql/ `\n SELECT watermark FROM ${this.#cdc('changeLog')}\n WHERE precommit IS NOT NULL\n AND watermark > ${afterWatermark}\n AND watermark <= ${throughWatermark}\n ORDER BY watermark\n LIMIT ${limit}`;\n return rows.map(({watermark}) => watermark);\n }\n\n /\n Reads `(afterWatermark, throughWatermark]` in stream order and bounded batches.\n * This query matches the subscriber catchup query.\n \n Both queries fail when an escaped NUL reaches `change->'tag'`.\n * Postgres cannot convert that value to text.\n /\n readCatchupRange(\n afterWatermark: string,\n throughWatermark: string,\n batchRows = 2000,\n ): AsyncIterable<ChangeLogEntry[]> {\n assert(\n Number.isSafeInteger(batchRows) && batchRows > 0,\n 'Postgres change log batch size must be a positive safe integer',\n );\n return this.#db<ChangeLogEntry[]> /sql/ `\n SELECT watermark, change->'tag' as tag, change::text FROM ${this.#cdc('changeLog')}\n WHERE watermark > ${afterWatermark}\n AND watermark <= ${throughWatermark}\n ORDER BY watermark, pos`.cursor(batchRows) as AsyncIterable<\n ChangeLogEntry[]\n >;\n }\n\n // Note: These are the only db `await`s that are not tracked by the\n // ProgressMonitor, as the delete can legitimately block and/or take\n // an arbitrary amount of time. Luckily, this is a background call and\n // thus cannot cause the storer loop to hang.\n purgeRecordsBefore(watermark: string): Promise<number> {\n return runTx(this.#purger, async sql => {\n // This NOWAIT pre-check is an optimization to abort the transaction\n // (and release associated resources) early.\n await sql<{watermark: string}[]>`\n SELECT watermark FROM ${this.#cdc('changeLog')}\n ORDER BY watermark, pos LIMIT 1\n FOR UPDATE NOWAIT\n `;\n // If the row is purge-locked by an incoming replication-manager, it\n // will assume ownership of the change-log before releasing the lock.\n // This DELETE blocks until the lock is released, allowing the change\n // in ownership to be reliably detected (and the transaction aborted)\n // in the subsequent check.\n const [{deleted}] = await sql<{deleted: bigint}[]>`\n -- The backup watermark can be ahead of the durable changeLog if the\n -- storer is behind but the backup replica has consumed forwarded\n -- changes. Preserve the latest durable changeLog transaction as the\n -- catchup boundary instead of assuming the backup watermark exists.\n -- The storer inserts each changeLog transaction atomically, so any\n -- durable row for a watermark implies the full transaction is durable.\n WITH keep AS (\n SELECT max(watermark) AS watermark\n FROM ${this.#cdc('changeLog')}\n ), purged AS (\n DELETE FROM ${this.#cdc('changeLog')} WHERE watermark < ${watermark} \n AND watermark < (SELECT watermark FROM keep)\n RETURNING watermark, pos\n ) SELECT COUNT() as deleted FROM purged;`;\n\n const [{owner}] = await sql<ReplicationOwner[]>`\n SELECT \"owner\" FROM ${this.#cdc('replicationState')} FOR SHARE`;\n if (owner !== this.#taskID) {\n throw new AbortError(\n `aborting changeLog purge to ${watermark} because ownership has been taken by ${owner}`,\n );\n }\n return Number(deleted);\n });\n }\n\n /*\n @returns The JSON stringified stream message to be sent downstream.\n /\n store(\n watermark: string,\n data: ChangeStreamData,\n serialized: SerializedChangeStreamData = serializeChangeStreamDataWithChange(\n data,\n ),\n ) {\n // Eagerly stringify the JSON payload to:\n // - avoid redundant stringification when fanning out to subscribers\n // - efficiently estimate the amount of memory the payload consumes\n const {json, change: storedChange} = serialized;\n this.#approximateQueuedBytes += json.length;\n\n const change = data[1];\n this.#queue.enqueue([\n 'change',\n watermark,\n json,\n storedChange,\n isDataChange(change) ? null : change, // drop DataChanges to save memory\n ]);\n\n return json;\n }\n\n abort() {\n this.#queue.enqueue(['abort']);\n }\n\n catchup(subscriber: Subscriber, mode: ReplicatorMode) {\n this.#queue.enqueue(['subscriber', {subscriber, mode}]);\n }\n\n #readyForMore: Resolver<void> \| null = null;\n\n readyForMore(): Promise<void> \| undefined {\n if (!this.#running) {\n return undefined;\n }\n if (\n this.#readyForMore === null &&\n this.#approximateQueuedBytes > this.#backPressureThresholdBytes\n ) {\n this.#lc.warn?.(\n `applying back pressure with ${this.#queue.size()} queued changes (~${(this.#approximateQueuedBytes / 1024 * 2).toFixed(2)} MB)\\n` +\n `\\n` +\n `To inspect changeLog backlog in your change DB:\\n` +\n ` SELECT\\n` +\n ` (change->'relation'->>'schema') \|\| '.' \|\| (change->'relation'->>'name') AS table_name,\\n` +\n ` change->>'tag' AS operation,\\n` +\n ` COUNT() AS count\\n` +\n ` FROM \"<app_id>/cdc\".\"changeLog\"\\n` +\n ` GROUP BY 1, 2\\n` +\n ` ORDER BY 3 DESC\\n` +\n ` LIMIT 20;`,\n );\n this.#readyForMore = resolver();\n }\n return this.#readyForMore?.promise;\n }\n\n #maybeReleaseBackPressure() {\n if (this.#readyForMore !== null) {\n // Wait for at least 20% of the threshold to free up.\n if (\n this.#approximateQueuedBytes <\n this.#backPressureThresholdBytes 0.8\n ) {\n this.#lc.info?.(\n `releasing back pressure with ${this.#queue.size()} queued changes (~${(this.#approximateQueuedBytes / 1024 2).toFixed(2)} MB)`,\n );\n this.#readyForMore.resolve();\n this.#readyForMore = null;\n }\n }\n }\n\n /\n * Flushes any buffered {@link PendingTransaction.batch} rows to the changeLog.\n \n Uses `json_to_recordset()` so the batch is a single JSON parameter: the\n * statement text stays constant regardless of batch size, avoiding the\n * unbounded prepared-statement variants (and Postgres memory growth) that a\n * multi-row INSERT would produce. See rocicorp/mono#3511.\n \n Returns (and updates) {@link PendingTransaction.lastFlush}; a no-op when the\n * batch is empty.\n /\n #flushChangeLog(tx: PendingTransaction): Promise<unknown> \| undefined {\n const {batch} = tx;\n if (batch.length === 0) {\n return tx.lastFlush;\n }\n tx.batch = [];\n tx.lastFlush = tx.pool.process(sql => [\n sql`\n INSERT INTO ${this.#cdc('changeLog')} (\"watermark\", \"pos\", \"change\", \"precommit\")\n SELECT \"watermark\", \"pos\", \"change\"::json, \"precommit\"\n FROM json_to_recordset(${batch}) AS x(\n \"watermark\" TEXT,\n \"pos\" INT8,\n \"change\" TEXT,\n \"precommit\" TEXT\n )`,\n ]);\n return tx.lastFlush;\n }\n\n #stopped = promiseVoid;\n\n /\n Runs the storer loop until {@link stop()} is called, or an error is thrown.\n * Once {@link run()} completes, it can be called again.\n /\n async run() {\n assert(!this.#running, `storer is already running`);\n\n const {promise: stopped, resolve: signalStopped} = resolver();\n this.#running = true;\n this.#stopped = stopped;\n\n this.#lc.info?.('starting storer');\n this.#progressMonitor.start(); // Note: This is stopped in stop()\n let err: unknown;\n try {\n await this.#processQueue();\n } catch (e) {\n err = e; // used in finally\n throw e;\n } finally {\n // Release any pending backpressure so the upstream can proceed\n if (this.#readyForMore !== null) {\n this.#readyForMore.resolve();\n this.#readyForMore = null;\n }\n this.#cancelQueueEntries(\n this.#queue.drain().filter(entry => entry !== undefined),\n err,\n );\n this.#running = false;\n signalStopped();\n this.#lc.info?.('storer stopped');\n }\n }\n\n #cancelQueueEntries(queue: QueueEntry[], e: unknown) {\n if (queue.length === 0) {\n return;\n }\n this.#lc.info?.(\n `canceling ${queue.length} entries from the changeLog queue`,\n );\n const err = e instanceof Error ? e : new AbortError('server shutting down');\n for (const entry of queue) {\n if (entry === 'stop') {\n continue;\n }\n const type = entry[0];\n switch (type) {\n case 'subscriber': {\n // Disconnect subscribers waiting to be caught up so that they can\n // reconnect and try again.\n const {subscriber} = entry[1];\n this.#lc.info?.(`disconnecting ${subscriber.id}`);\n subscriber.fail(err);\n break;\n }\n }\n }\n }\n\n async #processQueue() {\n let tx: PendingTransaction \| SkippedTransaction \| null = null;\n let msg: QueueEntry \| false;\n\n // Track the progress of each (previous and next) queue entry before it is\n // processed in the loop.\n let lastTaskDone: TaskDoneFn \| undefined;\n const nextMessage = async () => {\n lastTaskDone?.();\n lastTaskDone = undefined;\n const entry = await this.#queue.dequeue();\n if (entry !== 'stop') {\n lastTaskDone = this.#progressMonitor.trackTask({\n task: 'queue-entry',\n // Note: TaskKeys are logged, so only include entry[0] (the type) to\n // avoid logging application data.\n type: entry[0],\n });\n }\n return entry;\n };\n\n const catchupQueue: SubscriberAndMode[] = [];\n try {\n while ((msg = await nextMessage()) !== 'stop') {\n const [msgType] = msg;\n switch (msgType) {\n case 'ready': {\n const signalReady = msg[1];\n signalReady();\n continue;\n }\n case 'subscriber': {\n const subscriber = msg[1];\n if (tx) {\n catchupQueue.push(subscriber); // Wait for the current tx to complete.\n } else {\n await this.#startCatchup([subscriber]); // Catch up immediately.\n }\n continue;\n }\n case 'status': {\n const pending = this.#pendingOwnership;\n if (pending && !tx && msg[1] >= pending.head) {\n const pool = new TransactionPool(this.#lc, {\n mode: Mode.READ_COMMITTED,\n });\n pool.run(this.#inserter);\n const assumed = await this.#tryAssumeOwnership(\n pool,\n msg[1],\n false,\n );\n if (assumed === null) {\n pool.abort();\n await pool.done();\n } else {\n pool.setDone();\n await pool.done();\n this.#ownershipAssumed(assumed);\n }\n }\n continue;\n }\n case 'abort': {\n if (tx && !tx.skipped) {\n tx.pool.abort();\n await tx.pool.done();\n }\n tx = null;\n continue;\n }\n }\n // msgType === 'change'\n this.#approximateQueuedBytes -= msg[2].length;\n tx = await this.#processChange(tx, msg);\n // Released once the change has been processed (e.g. flushed), so that\n // the upstream is held back by the progress of the change log.\n this.#maybeReleaseBackPressure();\n if (tx === null) {\n // Before beginning the next transaction, open a READONLY snapshot to\n // concurrently catchup subscribers that were waiting for the\n // transaction to end.\n await this.#startCatchup(catchupQueue.splice(0));\n }\n }\n // Subscribers waiting for a transaction that was interrupted (i.e.\n // aborted before stopping) are disconnected so that they can reconnect,\n // like those that are still in the queue.\n this.#cancelQueueEntries(\n catchupQueue.splice(0).map(sub => ['subscriber', sub]),\n undefined,\n );\n } catch (e) {\n catchupQueue.forEach(({subscriber}) => subscriber.fail(e));\n throw e;\n }\n }\n\n /\n Processes a change from the queue, i.e. stores it in the change log as\n * part of the current transaction (or skips it, see\n * {@link assumeOwnershipAtHead}).\n \n @returns The transaction that is open after the change, or `null` if the\n * change ended (or was outside of) a transaction.\n /\n async #processChange(\n tx: PendingTransaction \| SkippedTransaction \| null,\n msg: Extract<QueueEntry, ['change', ...unknown[]]>,\n ): Promise<PendingTransaction \| SkippedTransaction \| null> {\n const [_, watermark, json, storedChange, change] = msg;\n const tag = change?.tag;\n\n if (tag === 'begin') {\n assert(!tx, 'received BEGIN in the middle of a transaction');\n const pending = this.#pendingOwnership;\n if (pending) {\n // Backfill transactions are neither stored nor used to assume\n // ownership. See assumeOwnershipAtHead().\n if (change.skipAck) {\n pending.skippedBackfill = true;\n return {skipped: true, ack: false};\n }\n if (watermark <= pending.head) {\n return {skipped: true, ack: true};\n }\n }\n const pool = new TransactionPool(\n this.#lc.withContext('watermark', watermark),\n {mode: Mode.READ_COMMITTED},\n );\n pool.run(this.#inserter);\n\n const {promise, resolve, reject} = resolver<ReplicationOwner>();\n void promise.catch(() => {}); // handle rejections before the await\n\n const assumed = pending\n ? await this.#tryAssumeOwnership(pool, watermark, true)\n : undefined;\n if (assumed === null) {\n // Stored by the previous owner in the meantime.\n pool.abort();\n await pool.done();\n return {skipped: true, ack: true};\n }\n if (pending) {\n // Ownership was assumed in this transaction.\n resolve({owner: this.#taskID});\n } else {\n // Acquire a lock on the replicationState row to detect and/or prevent\n // a concurrent ownership change.\n void pool.process(tx => {\n tx<ReplicationOwner[]> /sql/ `\n SELECT \"owner\" FROM ${this.#cdc('replicationState')} FOR UPDATE`.then(\n ([result]) => resolve(result),\n reject,\n );\n return [];\n });\n }\n\n tx = {\n pool,\n preCommitWatermark: watermark,\n pos: 0,\n startingReplicationState: promise,\n ack: !change.skipAck,\n batch: [],\n lastFlush: undefined,\n ownershipAssumed: assumed,\n };\n } else if (tx?.skipped) {\n if (tag === 'commit' && tx.ack) {\n this.#onCommitted(['commit', change, {watermark}]);\n }\n return tag === 'commit' \|\| tag === 'rollback' ? null : tx;\n } else {\n assert(tx, () => `received change outside of transaction: ${json}`);\n tx.pos++;\n }\n\n const entry: ChangeLogRow = {\n watermark: tag === 'commit' ? watermark : tx.preCommitWatermark,\n precommit: tag === 'commit' ? tx.preCommitWatermark : null,\n pos: tx.pos,\n // For backwards compatibility, only the change message is stored\n // in the cdc changeLog. It was serialized separately with the\n // downstream envelope, so no full-message scan is needed here.\n change: storedChange,\n };\n\n if (change !== null && isSchemaChange(change)) {\n // Schema changes carry backfill / table-metadata statements that\n // must be applied in stream order relative to the changeLog rows.\n // Flush any buffered rows first, then write this row together with\n // its metadata statements as a single unit (preserving the previous\n // per-change ordering for schema changes).\n await this.#flushChangeLog(tx);\n tx.lastFlush = tx.pool.process(sql => [\n sql`INSERT INTO ${this.#cdc('changeLog')} ${sql(entry)}`,\n ...this.#trackBackfillMetadata(sql, change),\n ]);\n } else {\n // Accumulate plain changeLog rows (begin, data changes, commit) and\n // write them as a single multi-row INSERT. Collapsing the per-change\n // single-row INSERTs into batches is the dominant cost reduction for\n // large transactions, where the previous one-statement-per-change\n // path dominated the upstream replication lag.\n tx.batch.push(entry);\n if (tx.batch.length >= this.#changeLogBatchSize) {\n // Bound pipeline depth (and thus memory) by awaiting the previous\n // flush before issuing the next. This is the batched analog of the\n // previous per-100-statement backpressure await, and likewise\n // guards against memory blowup on very large transactions.\n const prevFlush = tx.lastFlush;\n void this.#flushChangeLog(tx);\n await prevFlush;\n }\n }\n if (tag === 'commit') {\n // Flush any remaining buffered changeLog rows (including this commit\n // row) before updating the replication state, so the state update is\n // ordered after all changeLog inserts for this transaction.\n void this.#flushChangeLog(tx);\n\n const {owner} = await tx.startingReplicationState;\n if (owner !== this.#taskID) {\n // Ownership change reflected in the replicationState read in 'begin'.\n tx.pool.fail(\n new AbortError(`changeLog ownership has been assumed by ${owner}`),\n );\n } else {\n // Update the replication state.\n const lastWatermark = watermark;\n void tx.pool.process(tx => [\n tx`\n UPDATE ${this.#cdc('replicationState')} SET ${tx({lastWatermark})}`,\n ]);\n tx.pool.setDone();\n }\n\n await tx.pool.done();\n\n const {ownershipAssumed, ack} = tx;\n tx = null;\n if (ownershipAssumed) {\n this.#ownershipAssumed(ownershipAssumed);\n }\n // ACK the LSN to the upstream Postgres.\n if (ack) {\n this.#onCommitted(['commit', change, {watermark}]);\n }\n } else if (tag === 'rollback') {\n // Aborted transactions are not stored in the changeLog.\n tx.pool.abort();\n await tx.pool.done();\n tx = null;\n }\n return tx;\n }\n\n async #startCatchup(subs: SubscriberAndMode[]) {\n const numCatchups = subs.length;\n if (numCatchups === 0) {\n return;\n }\n\n const lc = this.#lc.withContext('pool', 'catchup');\n const {init, cleanup, snapshotID} = sharedSnapshot();\n const reader = new TransactionPool(lc, {\n mode: Mode.READONLY,\n init,\n cleanup,\n initialWorkers: subs.length,\n });\n\n // A dynamic connection pool is created for catchup, sized to the number\n // of subscribers being caught up.\n const catchupConns = this.#makeConnectionPool(\n 'subscriber-catchup',\n numCatchups,\n );\n reader.run(catchupConns);\n\n let lastWatermark: string \| undefined;\n const catchupSnapshotted = this.#progressMonitor.trackTask({\n task: 'capture-catchup-snapshot',\n subscribers: subs.map(({subscriber: s}) => s.id),\n });\n try {\n // Ensure that the transaction has started (and is thus holding a snapshot\n // of the database) before continuing on to commit more changes. This is\n // done by performing a single read on the db, which determines the\n // snapshot for the REPEATABLE_READ transaction.\n [{lastWatermark}] = await reader.processReadTask(\n sql => sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}\n `,\n );\n lc.info?.(\n `snapshotted db at ${lastWatermark} (${await snapshotID}) ` +\n `to catchup ${numCatchups} subscriber(s)`,\n );\n } catch (e) {\n subs.map(({subscriber}) => subscriber.fail(e));\n // Nothing will run the catchup tasks that normally finalize the pool\n // (below), so tear it down here. Otherwise its workers (each holding an\n // open READ ONLY transaction) and the connection pool are leaked.\n reader.abort();\n void catchupConns.end().catch(() => {});\n throw e;\n } finally {\n catchupSnapshotted();\n }\n\n // Run the actual catchup queries in the background. Errors are handled in\n // #catchup() by disconnecting the associated subscriber.\n void Promise.allSettled(\n subs.map(sub =>\n this.#catchup(\n lc.withContext('subscriber', sub.subscriber.id),\n sub,\n lastWatermark,\n reader,\n ),\n ),\n ).finally(() => {\n reader.setDone();\n void catchupConns.end().catch(() => {});\n });\n }\n\n async #catchup(\n lc: LogContext,\n {subscriber: sub, mode}: SubscriberAndMode,\n lastWatermark: string,\n reader: TransactionPool,\n ) {\n let entriesReceived = 0;\n let catchupProgressed = this.#progressMonitor.trackTask({\n task: 'catchup',\n subscriber: sub.id,\n entriesReceived,\n });\n try {\n lc.info?.(`starting catchup`);\n await reader.processReadTask(async tx => {\n lc.info?.(`catching up`);\n const start = Date.now();\n\n // When starting from initial-sync, there won't be a change with a watermark\n // equal to the replica version. This is the empty changeLog scenario.\n let watermarkFound = sub.watermark === this.#replicaVersion;\n let count = 0;\n let lastBatchConsumed: Promise<unknown> \| undefined;\n\n for await (const entries of tx<ChangeLogEntry[]> /sql/ `\n SELECT watermark, change->'tag' as tag, change::text FROM ${this.#cdc('changeLog')}\n WHERE watermark >= ${sub.watermark}\n AND watermark <= ${lastWatermark}\n ORDER BY watermark, pos`.cursor(2000)) {\n catchupProgressed();\n entriesReceived += entries.length;\n\n try {\n // Wait for the last batch of entries to be consumed by the\n // subscriber before sending down the current batch. This pipelining\n // allows one batch of changes to be received from the change-db\n // while the previous batch of changes are sent to the subscriber,\n // resulting in flow control that caps the number of changes\n // referenced in memory to 2 batch-size.\n const start = performance.now();\n await lastBatchConsumed;\n const elapsed = performance.now() - start;\n if (lastBatchConsumed) {\n lc[elapsed > 100 ? 'info' : 'debug']?.(\n `waited ${elapsed.toFixed(3)} ms for ${sub.id} to consume last batch of catchup entries`,\n );\n }\n\n for (const entry of entries) {\n if (entry.watermark === sub.watermark) {\n // This should be the first entry.\n // Catchup starts from after the watermark.\n watermarkFound = true;\n } else if (watermarkFound) {\n lastBatchConsumed = sub.catchup(\n reconstructWatermarkedChange(entry),\n );\n count++;\n } else if (mode === 'backup') {\n throw new AutoResetSignal(\n `backup replica at watermark ${sub.watermark} is behind change db: ${entry.watermark})`,\n );\n } else {\n lc.warn?.(\n `rejecting subscriber at watermark ${sub.watermark} (earliest watermark: ${entry.watermark})`,\n );\n sub.close(\n ErrorType.WatermarkTooOld,\n `earliest supported watermark is ${entry.watermark} (requested ${sub.watermark})`,\n );\n return;\n }\n }\n } finally {\n // Track the db's read of the next chunk of changes.\n catchupProgressed = this.#progressMonitor.trackTask({\n task: 'catchup',\n subscriber: sub.id,\n entriesReceived,\n });\n }\n }\n catchupProgressed();\n\n if (watermarkFound) {\n await lastBatchConsumed;\n lc.info?.(\n `caught up ${sub.id} with ${count} changes (${\n Date.now() - start\n } ms)`,\n );\n } else {\n // The subscriber is ahead of the latest durable changeLog entry\n // (lastWatermark). This can legitimately happen: changes are\n // forwarded to subscribers (the backup replica and view-syncers)\n // concurrently with — and can outrun — the durable store, so a\n // replica may briefly lead the change DB after the storer falls\n // behind or the change-streamer restarts. No catchup is possible or\n // needed; once the change DB catches back up, forwarding resumes and\n // the subscriber dedups any watermarks it already has. Unlike the\n // AutoResetSignal / WatermarkTooOld cases above, this is not a gap in\n // replication history, so the subscriber is simply marked caught up.\n lc.warn?.(\n `subscriber ${sub.id} at watermark ${sub.watermark} is ahead of ` +\n `the latest durable watermark ${lastWatermark}; waiting for the ` +\n `change DB to catch up`,\n );\n }\n // Start draining messages buffered during catchup. The returned promise\n // is intentionally not awaited here: while the drain is in progress,\n // new sends keep appending to the subscriber backlog and inherit its\n // byte-based backpressure.\n void sub.setCaughtUp();\n });\n } catch (err) {\n lc.error?.(`error while catching up subscriber ${sub.id}`, err);\n if (err instanceof AutoResetSignal) {\n await markResetRequired(this.#db, this.#shard);\n this.#onFatal(err);\n }\n sub.fail(err);\n } finally {\n catchupProgressed();\n }\n }\n\n /*\n Returns the db statements necessary to track backfill and table metadata\n * presented in the `change`, if any.\n \n This is the Postgres interpreter of {@link cookieOps}, which is also\n * interpreted against the SQLite change log by `ChangeLogCookieWriter`. The\n * two stores have to agree on every transition forever, and the failure mode\n * if they drift is a backfill that is silently never re-requested — so the\n * decision of what a schema change means lives in one place and only its\n * transport lives here.\n /\n #trackBackfillMetadata(sql: PostgresTransaction, change: SchemaChange) {\n return cookieOps(change).flatMap(op => this.#cookieStmts(sql, op));\n }\n\n #cookieStmts(sql: PostgresTransaction, op: CookieOp): PendingQuery<Row[]>[] {\n switch (op.op) {\n case 'upsert-metadata':\n return [this.#upsertTableMetadataStmt(sql, op.table, op.metadata)];\n\n case 'upsert-backfill':\n return [\n this.#upsertColumnBackfillStmt(sql, op.table, op.column, op.backfill),\n ];\n\n case 'rename-table': {\n const {old} = op;\n const row = {schema: op.new.schema, table: op.new.name};\n return [\n sql`UPDATE ${this.#cdc('tableMetadata')} SET ${sql(row)}\n WHERE \"schema\" = ${old.schema} AND \"table\" = ${old.name}`,\n sql`UPDATE ${this.#cdc('backfilling')} SET ${sql(row)}\n WHERE \"schema\" = ${old.schema} AND \"table\" = ${old.name}`,\n ];\n }\n\n case 'drop-table': {\n const {schema, name} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('tableMetadata')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name}`,\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name}`,\n ];\n }\n\n case 'rename-column': {\n const {schema, name: table} = op.table;\n return [\n sql`UPDATE ${this.#cdc('backfilling')} SET \"column\" = ${op.new}\n WHERE \"schema\" = ${schema} AND \"table\" = ${table} AND \"column\" = ${op.old}`,\n ];\n }\n\n case 'drop-column': {\n const {schema, name} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${name} AND \"column\" = ${op.column}`,\n ];\n }\n\n case 'complete-backfill': {\n const {schema, name: table} = op.table;\n return [\n sql`DELETE FROM ${this.#cdc('backfilling')}\n WHERE \"schema\" = ${schema} AND \"table\" = ${table} AND \"column\" IN ${sql([...op.columns])}`,\n ];\n }\n\n default:\n unreachable(op);\n }\n }\n\n #upsertTableMetadataStmt(\n sql: PostgresTransaction,\n {schema, name: table}: Identifier,\n metadata: TableMetadata,\n ) {\n const row: TableMetadataRow = {schema, table, metadata};\n return sql`\n INSERT INTO ${this.#cdc('tableMetadata')} ${sql(row)}\n ON CONFLICT (\"schema\", \"table\")\n DO UPDATE SET ${sql(row)};\n `;\n }\n\n #upsertColumnBackfillStmt(\n sql: PostgresTransaction,\n {schema, name: table}: Identifier,\n column: string,\n backfill: BackfillID,\n ) {\n const row: BackfillingColumn = {schema, table, column, backfill};\n return sql`\n INSERT INTO ${this.#cdc('backfilling')} ${sql(row)}\n ON CONFLICT (\"schema\", \"table\", \"column\")\n DO UPDATE SET ${sql(row)};\n `;\n }\n\n /\n Waits until all currently queued entries have been processed.\n * This is only used in tests.\n /\n async allProcessed() {\n if (this.#running) {\n const {promise, resolve} = resolver();\n this.#queue.enqueue(['ready', resolve]);\n await promise;\n }\n }\n\n /\n Stops the storer and waits up to a drain timeout for entries to drain,\n * throwing an exception if it doesn't drain in time, in order to abort\n * the server when PG (or the connection to it) appears to be wedged.\n /\n async stop() {\n if (this.#running) {\n this.#progressMonitor.stop();\n this.#lc.info?.(`draining ${this.#queue.size()} changeLog entries`);\n this.abort(); // for cleanliness, abort any open transactions\n this.#queue.enqueue('stop');\n }\n if (\n (await orTimeout(this.#stopped, this.#drainTimeoutMs)) === 'timed-out'\n ) {\n throw new AbortError(\n `changeLog did not drain within ${this.#drainTimeoutMs}ms`,\n );\n }\n }\n}\n\nexport class PurgeLock {\n readonly #lc: LogContext;\n readonly #tx: TransactionPool;\n readonly replicaVersion: string;\n readonly minWatermark: string;\n\n constructor(\n lc: LogContext,\n tx: TransactionPool,\n replicaVersion: string,\n watermark: string,\n ) {\n this.#lc = lc;\n this.#tx = tx;\n this.replicaVersion = replicaVersion;\n this.minWatermark = watermark;\n }\n\n #released = false;\n\n async release() {\n if (this.#released) {\n return;\n }\n this.#released = true;\n this.#tx.setDone();\n await this.#tx\n .done()\n .catch(e => this.#lc.warn?.(`error from purge-lock release`, e));\n this.#lc.info?.(`released purge lock on ${this.minWatermark}`);\n }\n}\n\nexport class PurgeLocker {\n readonly #lc: LogContext;\n readonly #shard: ShardID;\n readonly #db: PostgresDB;\n\n constructor(lc: LogContext, shard: ShardID, db: PostgresDB) {\n this.#lc = lc.withContext('component', 'purge-locker');\n this.#shard = shard;\n this.#db = db;\n }\n\n // For readability in SQL statements.\n #cdc(table: string) {\n return this.#db(`${cdcSchema(this.#shard)}.${table}`);\n }\n\n /\n Locks the oldest row of the change log, preventing it from being purged.\n \n @param slotWatermark The position of the replication slot from which the\n * change log is to be resumed (as a watermark). If specified and the\n * head of the change log is behind it, the change log may be missing\n * transactions that the slot will not stream, in which case nothing is\n * locked and `'behind-slot'` is returned. Conversely, a head at or past\n * the slot's position means that the stream (which resumes from the\n * head) will not skip anything.\n * @returns `null` if the change log is empty.\n /\n acquire(): Promise<PurgeLock \| null>;\n acquire(\n slotWatermark?: string \| undefined,\n ): Promise<PurgeLock \| null \| 'behind-slot'>;\n async acquire(\n slotWatermark?: string,\n ): Promise<PurgeLock \| null \| 'behind-slot'> {\n const tx = new TransactionPool(this.#lc, {mode: Mode.READ_COMMITTED}).run(\n this.#db,\n );\n if (slotWatermark !== undefined) {\n const [{lastWatermark}] = await tx.processReadTask(\n sql => sql<{lastWatermark: string}[]>`\n SELECT \"lastWatermark\" FROM ${this.#cdc('replicationState')}`,\n );\n if (lastWatermark < slotWatermark) {\n this.#lc.info?.(\n `changeLog@${lastWatermark} is behind the replication slot@${slotWatermark}`,\n );\n tx.setDone();\n await tx.done();\n return 'behind-slot';\n }\n }\n const row = await tx.processReadTask(\n sql => sql<{watermark: string}[]>`\n SELECT watermark FROM ${this.#cdc('changeLog')}\n ORDER BY watermark, pos LIMIT 1\n FOR SHARE \n `,\n );\n if (row.length === 0) {\n this.#lc.info?.(`changeLog is empty. No rows to purge-lock.`);\n tx.setDone();\n await tx.done();\n return null;\n }\n const [{watermark}] = row;\n const [{replicaVersion}] = await tx.processReadTask(\n sql => sql<{replicaVersion: string}[]>`\n SELECT \"replicaVersion\" FROM ${this.#cdc('replicationConfig')}\n `,\n );\n this.#lc.info?.(\n `locked watermark ${watermark} from being purged from replica@${replicaVersion}`,\n );\n return new PurgeLock(this.#lc, tx, replicaVersion, watermark);\n }\n}\n\n// A TaskKey, keyed by identity, representing an db task monitored by the\n// ProgressMonitor. The contents are stringified in error messages if the\n// task fails to make progress for more than a failure threshold interval.\ntype TaskKey = JSONObject;\n\ntype TaskDoneFn = () => void;\n\n/\n Periodic monitor for detecting the pathological condition in which a db\n * query hangs forever because of a connection problem, such as a half-closed\n * socket.\n \n Use this for db calls that recur or accumulate progress within a single\n * logical operation on the main storer loop (e.g. the queue-processing loop,\n * or a multi-batch catchup read), where \"no progress for N ms\" is the\n * meaningful signal. For a one-off db call -- including ones made before\n * {@link Storer.run} starts this monitor's polling -- use a plain timeout\n * (see `Storer.#withTimeout`) instead.\n \n The failure handler should stop the server. The ProgressMonitor will\n * assume this and stop itself after calling it.\n \n Internal to the Storer, but exported for testing.\n /\nexport class ProgressMonitor {\n readonly #lc: LogContext;\n readonly #failureThresholdMs;\n readonly #onFailure: (err: Error) => void;\n readonly #taskUpdates = new Map<TaskKey, Date>();\n\n #timer: NodeJS.Timeout \| undefined;\n\n constructor(\n lc: LogContext,\n failureThresholdMs: number,\n onFailure: (err: Error) => void,\n ) {\n this.#lc = lc.withContext('component', 'storer-progress-monitor');\n this.#failureThresholdMs = failureThresholdMs;\n this.#onFailure = onFailure;\n }\n\n start() {\n clearInterval(this.#timer);\n this.#timer = setInterval(\n () => this.checkTaskProgress(new Date()),\n this.#failureThresholdMs,\n ).unref();\n }\n\n // Called by an internal periodic timer, but exported for testing.\n checkTaskProgress(now: Date) {\n for (const [task, lastUpdate] of this.#taskUpdates.entries()) {\n if (now.getTime() - lastUpdate.getTime() >= this.#failureThresholdMs) {\n this.#lc.error?.(\n `Last task update was more than ${this.#failureThresholdMs}ms ago`,\n {task, lastUpdate},\n );\n this.#onFailure(\n new Error(\n `Task failed to progress for over ${this.#failureThresholdMs}ms: ${BigIntJSON.stringify(task)}`,\n ),\n );\n this.stop();\n return;\n }\n }\n }\n\n /\n Starts a task to be tracked.\n \n @return a callback to invoke when the task is done.\n */\n trackTask(task: TaskKey, now = new Date()): TaskDoneFn {\n this.#taskUpdates.set(task, now);\n return () => {\n this.#taskUpdates.delete(task);\n };\n }\n\n stop() {\n clearInterval(this.#timer);\n this.#taskUpdates.clear();\n }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-streamer/upstream-acker.d.ts CHANGED Viewed

@@ -33,13 +33,15 @@ export declare class UpstreamAcker {
      * connection, so it counts as committed on this one: a status watermark past
      * it waits for the tracked stores to reach it, as it would for a commit on
      * this connection. Otherwise the first keepalive of a stream that resumes
-     * ahead of the stores -- a SQLite change log ahead of its backup, which is
-     * the normal state -- would move the replication slot past transactions that
-     * no store has persisted, and a task restored from the backup would then
+     * ahead of the stores -- a change log ahead of its backup, which is the
+     * normal state -- would move the replication slot past transactions that the
+     * backup has not persisted, and a task restored from the backup would then
      * resume below the slot, which the upstream moves forward without a word.
      *
-     * Pass `''` when the stream resumes from what a tracked store has itself
-     * persisted, which leaves nothing before it outstanding.
+     * When the PG change log is tracked, the stream resumes from its head, so
+     * `resumeWatermark` has been persisted in it (by this or another
+     * change-streamer). Without this, status messages would not be acked on an
+     * idle upstream until a commit is stored.
      */
     reset(upstream: Sink<ChangeSourceUpstream>, resumeWatermark: string): void;
     trackDownstream(downstream: ChangeStreamMessage): void;

package/out/zero-cache/src/services/change-streamer/upstream-acker.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"upstream-acker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/upstream-acker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAE9C,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;;IAYxB,YAAY,EAAC,gBAAgB,EAAE,WAAW,EAAC,EAAE,IAAI,EAOhD;IAED~~;;;;;;;;;;;;;;;OAeG~~;IACH,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,CAAC,EAAE,eAAe,EAAE,MAAM,~~QAKlE~~;IAED,eAAe,CAAC,UAAU,EAAE,mBAAmB,QAe9C;IAED,gBAAgB,CAAC,kBAAkB,EAAE,MAAM,QAO1C;IAED,WAAW,CAAC,iBAAiB,EAAE,MAAM,QAIpC;CA2BF"}
1	+ {"version":3,"file":"upstream-acker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/upstream-acker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAE9C,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;;IAYxB,YAAY,EAAC,gBAAgB,EAAE,WAAW,EAAC,EAAE,IAAI,EAOhD;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,CAAC,EAAE,eAAe,EAAE,MAAM,QAalE;IAED,eAAe,CAAC,UAAU,EAAE,mBAAmB,QAe9C;IAED,gBAAgB,CAAC,kBAAkB,EAAE,MAAM,QAO1C;IAED,WAAW,CAAC,iBAAiB,EAAE,MAAM,QAIpC;CA2BF"}

package/out/zero-cache/src/services/change-streamer/upstream-acker.js CHANGED Viewed

@@ -41,19 +41,23 @@ var UpstreamAcker = class {
 	* connection, so it counts as committed on this one: a status watermark past
 	* it waits for the tracked stores to reach it, as it would for a commit on
 	* this connection. Otherwise the first keepalive of a stream that resumes
-	* ahead of the stores -- a SQLite change log ahead of its backup, which is
-	* the normal state -- would move the replication slot past transactions that
-	* no store has persisted, and a task restored from the backup would then
+	* ahead of the stores -- a change log ahead of its backup, which is the
+	* normal state -- would move the replication slot past transactions that the
+	* backup has not persisted, and a task restored from the backup would then
 	* resume below the slot, which the upstream moves forward without a word.
 	*
-	* Pass `''` when the stream resumes from what a tracked store has itself
-	* persisted, which leaves nothing before it outstanding.
+	* When the PG change log is tracked, the stream resumes from its head, so
+	* `resumeWatermark` has been persisted in it (by this or another
+	* change-streamer). Without this, status messages would not be acked on an
+	* idle upstream until a commit is stored.
 	*/
 	reset(upstream, resumeWatermark) {
 		this.#upstream = upstream;
 		this.#lastTx = resumeWatermark;
 		this.#lastStatus = "";
 		this.#lastAck = "";
+		if (this.#trackPgChangeLog) this.#pgChangeLogWatermark = max(resumeWatermark, this.#pgChangeLogWatermark);
+		this.#maybeAck();
 	}
 	trackDownstream(downstream) {
 		const [tag, msg] = downstream;

package/out/zero-cache/src/services/change-streamer/upstream-acker.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"upstream-acker.js","names":["#trackPgChangeLog","#trackBackup","#upstream","#lastTx","#lastStatus","#lastAck","#~~maybeAck~~","#~~pgChangeLogWatermark~~","#backupWatermark"],"sources":["../../../../../../zero-cache/src/services/change-streamer/upstream-acker.ts"],"sourcesContent":["import {assert} from '../../../../shared/src/asserts.ts';\nimport {max, min} from '../../types/lexi-version.ts';\nimport type {Sink} from '../../types/streams.ts';\nimport type {\n ChangeSourceUpstream,\n ChangeStreamMessage,\n} from '../change-source/protocol/current.ts';\n\ntype Opts = {\n trackPgChangeLog: boolean;\n trackBackup: boolean;\n};\n\n/*\n Tracks the progress (watermark) of multiple streams:\n * - downstream transactions and status messages (the latter\n * indicating LSNs that are not relevant to the publication\n * but nevertheless need to be ACKed)\n * - PG change-log commits\n * - backup watermarks\n \n and sends upstream ACKs accordingly. When both the PG change-log\n * and backup watermarks are being considered for upstream ACKs\n * (i.e. RMv1.5), only watermarks that have been reached by both\n * stores are acked.\n \n The UpstreamAcker also takes into account that an upstream\n * connection can be disconnected and {@link reset()}. In this case,\n * the progress of the persistent stores is retained and the acks\n * are resent on the new upstream connection as necessary.\n /\nexport class UpstreamAcker {\n readonly #trackPgChangeLog: boolean;\n readonly #trackBackup: boolean;\n\n #pgChangeLogWatermark = '';\n #backupWatermark = '';\n\n #upstream: Sink<ChangeSourceUpstream> \| undefined;\n #lastTx = '';\n #lastStatus = '';\n #lastAck = '';\n\n constructor({trackPgChangeLog, trackBackup}: Opts) {\n assert(\n trackPgChangeLog \|\| trackBackup,\n `At least one of trackPgChangeLog or trackBackup must be true`,\n );\n this.#trackPgChangeLog = trackPgChangeLog;\n this.#trackBackup = trackBackup;\n }\n\n /\n Starts tracking a new upstream connection, which resumes the change stream\n * after `resumeWatermark`.\n \n Everything at or before `resumeWatermark` was committed on an earlier\n * connection, so it counts as committed on this one: a status watermark past\n * it waits for the tracked stores to reach it, as it would for a commit on\n * this connection. Otherwise the first keepalive of a stream that resumes\n * ahead of the stores -- a ~~SQLite~~ change log ahead of its backup, which is\n * ~~the~~ normal state -- would move the replication slot past transactions that\n * no ~~store~~ has persisted, and a task restored from the backup would then\n * resume below the slot, which the upstream moves forward without a word.\n \n ~~Pass~~ ~~`''`~~ ~~when~~ the stream resumes from ~~what~~ a ~~tracked~~ ~~store~~ has ~~itself~~\n * ~~persisted~~, ~~which~~ ~~leaves~~ ~~nothing~~ ~~before~~ it ~~outstanding~~.\n */\n reset(upstream: Sink<ChangeSourceUpstream>, resumeWatermark: string) {\n this.#upstream = upstream;\n this.#lastTx = resumeWatermark;\n this.#lastStatus = '';\n this.#lastAck = '';\n }\n\n trackDownstream(downstream: ChangeStreamMessage) {\n const [tag, msg] = downstream;\n switch (tag) {\n case 'status':\n if (msg.ack) {\n this.#lastStatus = downstream[2].watermark;\n }\n this.#maybeAck();\n break;\n case 'commit':\n // A commit replayed from below the resume watermark does not lower it.\n this.#lastTx = max(this.#lastTx, downstream[2].watermark);\n this.#maybeAck();\n break;\n }\n }\n\n trackPgChangeLog(committedWatermark: string) {\n // Watermarks should never move backwards, but use max() defensively.\n this.#pgChangeLogWatermark = max(\n committedWatermark,\n this.#pgChangeLogWatermark,\n );\n this.#maybeAck();\n }\n\n trackBackup(backedUpWatermark: string) {\n // Watermarks should never move backwards, but use max() defensively.\n this.#backupWatermark = max(backedUpWatermark, this.#backupWatermark);\n this.#maybeAck();\n }\n\n #maybeAck() {\n const currentWatermark = !this.#trackBackup\n ? this.#pgChangeLogWatermark\n : !this.#trackPgChangeLog\n ? this.#backupWatermark\n : min(this.#pgChangeLogWatermark, this.#backupWatermark);\n if (currentWatermark > this.#lastAck) {\n this.#upstream?.push([\n 'status',\n {tag: 'commit'},\n {watermark: currentWatermark},\n ]);\n this.#lastAck = currentWatermark;\n }\n // If all committed transactions have been acked, ack any outstanding\n // status LSN's thereafter (i.e. non-publication upstream changes).\n if (this.#lastAck >= this.#lastTx && this.#lastStatus > this.#lastAck) {\n this.#upstream?.push([\n 'status',\n {ack: true},\n {watermark: this.#lastStatus},\n ]);\n this.#lastAck = this.#lastStatus;\n }\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,gBAAb,MAA2B;CACzB;CACA;CAEA,wBAAwB;CACxB,mBAAmB;CAEnB;CACA,UAAU;CACV,cAAc;CACd,WAAW;CAEX,YAAY,EAAC,kBAAkB,eAAoB;EACjD,OACE,oBAAoB,aACpB,8DACF;EACA,KAAKA,oBAAoB;EACzB,KAAKC,eAAe;CACtB~~;;;;;;;;;;;;;;;;;CAkBA~~,MAAM,UAAsC,iBAAyB;EACnE,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,cAAc;EACnB,KAAKC,WAAW;~~CAClB~~;CAEA,gBAAgB,YAAiC;EAC/C,MAAM,CAAC,KAAK,OAAO;EACnB,QAAQ,KAAR;GACE,KAAK;IACH,IAAI,IAAI,KACN,~~KAAKD~~,cAAc,WAAW,GAAG;IAEnC,~~KAAKE~~,UAAU;IACf;GACF,KAAK;IAEH,~~KAAKH~~,UAAU,IAAI,KAAKA,SAAS,WAAW,GAAG,SAAS;IACxD,~~KAAKG~~,UAAU;IACf;EACJ;CACF;CAEA,iBAAiB,oBAA4B;EAE3C,~~KAAKC~~,wBAAwB,IAC3B,oBACA,KAAKA,qBACP;EACA,~~KAAKD~~,UAAU;CACjB;CAEA,YAAY,mBAA2B;EAErC,~~KAAKE~~,mBAAmB,IAAI,mBAAmB,KAAKA,gBAAgB;EACpE,~~KAAKF~~,UAAU;CACjB;CAEA,YAAY;EACV,MAAM,mBAAmB,CAAC,~~KAAKL~~,eAC3B,~~KAAKM~~,wBACL,CAAC,~~KAAKP~~,oBACJ,KAAKQ,mBACL,IAAI,~~KAAKD~~,uBAAuB,~~KAAKC~~,gBAAgB;EAC3D,IAAI,mBAAmB,KAAKH,UAAU;GACpC,KAAKH,WAAW,KAAK;IACnB;IACA,EAAC,KAAK,SAAQ;IACd,EAAC,WAAW,iBAAgB;GAC9B,CAAC;GACD,KAAKG,WAAW;EAClB;EAGA,IAAI,KAAKA,YAAY,KAAKF,WAAW,KAAKC,cAAc,KAAKC,UAAU;GACrE,KAAKH,WAAW,KAAK;IACnB;IACA,EAAC,KAAK,KAAI;IACV,EAAC,WAAW,KAAKE,YAAW;GAC9B,CAAC;GACD,KAAKC,WAAW,KAAKD;EACvB;CACF;AACF"}
1	+ {"version":3,"file":"upstream-acker.js","names":["#trackPgChangeLog","#trackBackup","#upstream","#lastTx","#lastStatus","#lastAck","#pgChangeLogWatermark","#maybeAck","#backupWatermark"],"sources":["../../../../../../zero-cache/src/services/change-streamer/upstream-acker.ts"],"sourcesContent":["import {assert} from '../../../../shared/src/asserts.ts';\nimport {max, min} from '../../types/lexi-version.ts';\nimport type {Sink} from '../../types/streams.ts';\nimport type {\n ChangeSourceUpstream,\n ChangeStreamMessage,\n} from '../change-source/protocol/current.ts';\n\ntype Opts = {\n trackPgChangeLog: boolean;\n trackBackup: boolean;\n};\n\n/*\n Tracks the progress (watermark) of multiple streams:\n * - downstream transactions and status messages (the latter\n * indicating LSNs that are not relevant to the publication\n * but nevertheless need to be ACKed)\n * - PG change-log commits\n * - backup watermarks\n \n and sends upstream ACKs accordingly. When both the PG change-log\n * and backup watermarks are being considered for upstream ACKs\n * (i.e. RMv1.5), only watermarks that have been reached by both\n * stores are acked.\n \n The UpstreamAcker also takes into account that an upstream\n * connection can be disconnected and {@link reset()}. In this case,\n * the progress of the persistent stores is retained and the acks\n * are resent on the new upstream connection as necessary.\n /\nexport class UpstreamAcker {\n readonly #trackPgChangeLog: boolean;\n readonly #trackBackup: boolean;\n\n #pgChangeLogWatermark = '';\n #backupWatermark = '';\n\n #upstream: Sink<ChangeSourceUpstream> \| undefined;\n #lastTx = '';\n #lastStatus = '';\n #lastAck = '';\n\n constructor({trackPgChangeLog, trackBackup}: Opts) {\n assert(\n trackPgChangeLog \|\| trackBackup,\n `At least one of trackPgChangeLog or trackBackup must be true`,\n );\n this.#trackPgChangeLog = trackPgChangeLog;\n this.#trackBackup = trackBackup;\n }\n\n /\n Starts tracking a new upstream connection, which resumes the change stream\n * after `resumeWatermark`.\n \n Everything at or before `resumeWatermark` was committed on an earlier\n * connection, so it counts as committed on this one: a status watermark past\n * it waits for the tracked stores to reach it, as it would for a commit on\n * this connection. Otherwise the first keepalive of a stream that resumes\n * ahead of the stores -- a change log ahead of its backup, which is the\n * normal state -- would move the replication slot past transactions that the\n * backup has not persisted, and a task restored from the backup would then\n * resume below the slot, which the upstream moves forward without a word.\n \n When the PG change log is tracked, the stream resumes from its head, so\n * `resumeWatermark` has been persisted in it (by this or another\n * change-streamer). Without this, status messages would not be acked on an\n * idle upstream until a commit is stored.\n */\n reset(upstream: Sink<ChangeSourceUpstream>, resumeWatermark: string) {\n this.#upstream = upstream;\n this.#lastTx = resumeWatermark;\n this.#lastStatus = '';\n this.#lastAck = '';\n if (this.#trackPgChangeLog) {\n this.#pgChangeLogWatermark = max(\n resumeWatermark,\n this.#pgChangeLogWatermark,\n );\n }\n // Re-ack what the stores have persisted on the new connection.\n this.#maybeAck();\n }\n\n trackDownstream(downstream: ChangeStreamMessage) {\n const [tag, msg] = downstream;\n switch (tag) {\n case 'status':\n if (msg.ack) {\n this.#lastStatus = downstream[2].watermark;\n }\n this.#maybeAck();\n break;\n case 'commit':\n // A commit replayed from below the resume watermark does not lower it.\n this.#lastTx = max(this.#lastTx, downstream[2].watermark);\n this.#maybeAck();\n break;\n }\n }\n\n trackPgChangeLog(committedWatermark: string) {\n // Watermarks should never move backwards, but use max() defensively.\n this.#pgChangeLogWatermark = max(\n committedWatermark,\n this.#pgChangeLogWatermark,\n );\n this.#maybeAck();\n }\n\n trackBackup(backedUpWatermark: string) {\n // Watermarks should never move backwards, but use max() defensively.\n this.#backupWatermark = max(backedUpWatermark, this.#backupWatermark);\n this.#maybeAck();\n }\n\n #maybeAck() {\n const currentWatermark = !this.#trackBackup\n ? this.#pgChangeLogWatermark\n : !this.#trackPgChangeLog\n ? this.#backupWatermark\n : min(this.#pgChangeLogWatermark, this.#backupWatermark);\n if (currentWatermark > this.#lastAck) {\n this.#upstream?.push([\n 'status',\n {tag: 'commit'},\n {watermark: currentWatermark},\n ]);\n this.#lastAck = currentWatermark;\n }\n // If all committed transactions have been acked, ack any outstanding\n // status LSN's thereafter (i.e. non-publication upstream changes).\n if (this.#lastAck >= this.#lastTx && this.#lastStatus > this.#lastAck) {\n this.#upstream?.push([\n 'status',\n {ack: true},\n {watermark: this.#lastStatus},\n ]);\n this.#lastAck = this.#lastStatus;\n }\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,gBAAb,MAA2B;CACzB;CACA;CAEA,wBAAwB;CACxB,mBAAmB;CAEnB;CACA,UAAU;CACV,cAAc;CACd,WAAW;CAEX,YAAY,EAAC,kBAAkB,eAAoB;EACjD,OACE,oBAAoB,aACpB,8DACF;EACA,KAAKA,oBAAoB;EACzB,KAAKC,eAAe;CACtB;;;;;;;;;;;;;;;;;;;CAoBA,MAAM,UAAsC,iBAAyB;EACnE,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,cAAc;EACnB,KAAKC,WAAW;EAChB,IAAI,KAAKL,mBACP,KAAKM,wBAAwB,IAC3B,iBACA,KAAKA,qBACP;EAGF,KAAKC,UAAU;CACjB;CAEA,gBAAgB,YAAiC;EAC/C,MAAM,CAAC,KAAK,OAAO;EACnB,QAAQ,KAAR;GACE,KAAK;IACH,IAAI,IAAI,KACN,KAAKH,cAAc,WAAW,GAAG;IAEnC,KAAKG,UAAU;IACf;GACF,KAAK;IAEH,KAAKJ,UAAU,IAAI,KAAKA,SAAS,WAAW,GAAG,SAAS;IACxD,KAAKI,UAAU;IACf;EACJ;CACF;CAEA,iBAAiB,oBAA4B;EAE3C,KAAKD,wBAAwB,IAC3B,oBACA,KAAKA,qBACP;EACA,KAAKC,UAAU;CACjB;CAEA,YAAY,mBAA2B;EAErC,KAAKC,mBAAmB,IAAI,mBAAmB,KAAKA,gBAAgB;EACpE,KAAKD,UAAU;CACjB;CAEA,YAAY;EACV,MAAM,mBAAmB,CAAC,KAAKN,eAC3B,KAAKK,wBACL,CAAC,KAAKN,oBACJ,KAAKQ,mBACL,IAAI,KAAKF,uBAAuB,KAAKE,gBAAgB;EAC3D,IAAI,mBAAmB,KAAKH,UAAU;GACpC,KAAKH,WAAW,KAAK;IACnB;IACA,EAAC,KAAK,SAAQ;IACd,EAAC,WAAW,iBAAgB;GAC9B,CAAC;GACD,KAAKG,WAAW;EAClB;EAGA,IAAI,KAAKA,YAAY,KAAKF,WAAW,KAAKC,cAAc,KAAKC,UAAU;GACrE,KAAKH,WAAW,KAAK;IACnB;IACA,EAAC,KAAK,KAAI;IACV,EAAC,WAAW,KAAKE,YAAW;GAC9B,CAAC;GACD,KAAKC,WAAW,KAAKD;EACvB;CACF;AACF"}

package/out/zero-cache/src/services/litestream/commands.d.ts CHANGED Viewed

@@ -18,18 +18,10 @@ export declare class BackupNotFoundException extends Error {
 }
 export declare function tryRestore(lc: LogContext, config: LitestreamConfig, replicaFile: string, replicaConstraints: ReplicaConstraints | undefined, role: LitestreamRole, signal?: AbortSignal): Promise<RestoreAttempt>;
 /**
- * The interval at which litestream v5 syncs the WAL on its own.
- *
- * With the sync requester enabled, zero-cache requests syncs at the
- * incremental backup interval (see LitestreamSyncRequester), and litestream's
- * own monitor becomes a backstop that keeps backups and checkpoints
- * progressing if zero-cache stops requesting them. litestream resets its
- * monitor tick after every requested sync, so the backstop only fires once
- * requests stop for a full interval. It must still be longer than the request
- * interval, or timer jitter would occasionally let a tick slip in just before
- * a request and seal an extra backup file.
+ * Deletes litestream's local state for `replicaFile` (its default meta
+ * directory, `.<file>-litestream`).
  */
-export declare function litestreamMonitorIntervalSeconds(incrementalBackupIntervalSeconds: number, syncRequesterEnabled: boolean): number;
+export declare function deleteLitestreamMetaDir(replicaFile: string): void;
 export declare function startReplicaBackupProcess(lc: LogContext, config: LitestreamConfig, replicaFile: string): ChildProcess;
 /**
  * Returns the time of the most recent object (snapshot or WAL segment)

package/out/zero-cache/src/services/litestream/commands.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAIrD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAI3D,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAWL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAKF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD,YAAY,SAAS,EAAE,MAAM,GAAG,SAAS,EAExC;CACF;~~AA6FD~~,wBAAsB,UAAU,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,~~CAwIzB~~;~~AAoGD;;;;;;;;;;;GAWG~~;AACH,wBAAgB,~~gCAAgC~~,~~CAC9C~~,~~gCAAgC~~,EAAE,MAAM,~~EACxC,oBAAoB,EAAE,OAAO,GAC5B,MAAM,CAIR~~;~~AAED~~,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,YAAY,CAuCd;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AA8DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,GAAG,KAAK,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CAoBR"}
1	+ {"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAIrD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAI3D,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAWL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAKF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD,YAAY,SAAS,EAAE,MAAM,GAAG,SAAS,EAExC;CACF;AA8FD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAyBzB;AAmJD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,QAK1D;AAoGD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,YAAY,CAuCd;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AA8DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,GAAG,KAAK,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CAoBR"}

package/out/zero-cache/src/services/litestream/commands.js CHANGED Viewed

@@ -16,7 +16,7 @@ import { basename, dirname, join } from "node:path";
 var MAX_LOGGED_RESTORE_DIRECTORY_ENTRIES = 100;
 var LEGACY_RESTORE_WAL_INDEX = /^[0-9a-f]{8}$/;
 function getLitestream(mode, config, replicaFile, logLevelOverride) {
-	const { executable, executableV5, restoreUsingV5, backupUsingV5, backupURL, logLevel, configPath, configPathV5, endpoint, region, port, checkpointThresholdMB, minCheckpointPageCount = checkpointThresholdMB * 256, maxCheckpointPageCount = minCheckpointPageCount * 10, forceCheckpointThresholdMB, incrementalBackupIntervalMinutes, incrementalBackupIntervalSeconds, syncRequesterEnabled, snapshotBackupIntervalHours, multipartConcurrency, multipartSize } = config;
+	const { executable, executableV5, restoreUsingV5, backupUsingV5, backupURL, logLevel, configPath, configPathV5, endpoint, region, port, checkpointThresholdMB, minCheckpointPageCount = checkpointThresholdMB * 256, maxCheckpointPageCount = minCheckpointPageCount * 10, forceCheckpointThresholdMB, incrementalBackupIntervalMinutes, incrementalBackupIntervalSeconds, snapshotBackupIntervalHours, multipartConcurrency, multipartSize } = config;
 	const v5 = mode === "restore" && restoreUsingV5 || mode === "replicate" && backupUsingV5;
 	const litestream = (v5 ? executableV5 : executable) ?? must(executable, `Missing --litestream-executable`);
 	const litestreamConfig = v5 ? configPathV5 : configPath;
@@ -31,7 +31,7 @@ function getLitestream(mode, config, replicaFile, logLevelOverride) {
 			["ZERO_LITESTREAM_MAX_CHECKPOINT_PAGE_COUNT"]: String(maxCheckpointPageCount),
 			["ZERO_LITESTREAM_INCREMENTAL_BACKUP_INTERVAL_MINUTES"]: String(incrementalBackupIntervalMinutes),
 			["ZERO_LITESTREAM_INCREMENTAL_BACKUP_INTERVAL_SECONDS"]: String(incrementalBackupIntervalSeconds),
-			["ZERO_LITESTREAM_MONITOR_INTERVAL_SECONDS"]: String(litestreamMonitorIntervalSeconds(incrementalBackupIntervalSeconds, syncRequesterEnabled)),
+			["ZERO_LITESTREAM_MONITOR_INTERVAL_SECONDS"]: String(2 * incrementalBackupIntervalSeconds),
 			["ZERO_LITESTREAM_TRUNCATE_PAGE_N"]: String(truncatePageN),
 			["ZERO_LITESTREAM_LOG_LEVEL"]: logLevelOverride ?? logLevel,
 			["ZERO_LITESTREAM_SNAPSHOT_BACKUP_INTERVAL_HOURS"]: String(snapshotBackupIntervalHours),
@@ -49,13 +49,21 @@ function getLitestream(mode, config, replicaFile, logLevelOverride) {
 	};
 }
 async function tryRestore(lc, config, replicaFile, replicaConstraints, role, signal) {
+	const { reusedExisting, ...attempt } = await restoreOnce(lc, config, replicaFile, replicaConstraints, role, signal);
+	if (attempt.result === "invalid_replica" && reusedExisting) {
+		const { reusedExisting: _, ...retry } = await restoreOnce(lc, config, replicaFile, replicaConstraints, role, signal);
+		return retry;
+	}
+	return attempt;
+}
+async function restoreOnce(lc, config, replicaFile, replicaConstraints, role, signal) {
 	const { backupURL } = config;
 	const attrs = litestreamRestoreMetricAttrs(config, role, backupURL);
 	let result = "error";
 	try {
 		logRestoreDirectoryContents(lc, replicaFile, "before-temp-cleanup");
 		deleteRestoreTempFiles(replicaFile);
-		const replicaExistedBeforeRestore = existsSync(replicaFile);
+		const reusedExisting = existsSync(replicaFile);
 		const { litestream, env } = getLitestream("restore", config, replicaFile, "debug");
 		const { restoreParallelism: parallelism, multipartConcurrency, multipartSize } = config;
 		lc.info?.(`starting litestream restore`, {
@@ -119,7 +127,8 @@ async function tryRestore(lc, config, replicaFile, replicaConstraints, role, sig
 			return {
 				restored: false,
 				backupURL,
-				result
+				result,
+				reusedExisting
 			};
 		}
 		const validationStart = performance.now();
@@ -136,11 +145,12 @@ async function tryRestore(lc, config, replicaFile, replicaConstraints, role, sig
 			return {
 				restored: false,
 				backupURL,
-				result
+				result,
+				reusedExisting
 			};
 		}
 		result = "success";
-		if (!replicaExistedBeforeRestore) {
+		if (!reusedExisting) {
 			deleteChangeLogDB(replicaFile);
 			litestreamRestoredDbBytes().add(statSync(replicaFile).size, {
 				...attrs,
@@ -150,7 +160,8 @@ async function tryRestore(lc, config, replicaFile, replicaConstraints, role, sig
 		return {
 			restored: true,
 			backupURL,
-			result
+			result,
+			reusedExisting
 		};
 	} finally {
 		try {
@@ -168,6 +179,16 @@ async function tryRestore(lc, config, replicaFile, replicaConstraints, role, sig
 		});
 	}
 }
+/**
+* Deletes litestream's local state for `replicaFile` (its default meta
+* directory, `.<file>-litestream`).
+*/
+function deleteLitestreamMetaDir(replicaFile) {
+	rmSync(join(dirname(replicaFile), `.${basename(replicaFile)}-litestream`), {
+		recursive: true,
+		force: true
+	});
+}
 function deleteRestoreTempFiles(replicaFile) {
 	const temporaryReplicaFile = `${replicaFile}.tmp`;
 	deleteLiteDB(temporaryReplicaFile);
@@ -230,21 +251,6 @@ function replicaIsValid(lc, replica, constraints) {
 		db?.close();
 	}
 }
-/**
-* The interval at which litestream v5 syncs the WAL on its own.
-*
-* With the sync requester enabled, zero-cache requests syncs at the
-* incremental backup interval (see LitestreamSyncRequester), and litestream's
-* own monitor becomes a backstop that keeps backups and checkpoints
-* progressing if zero-cache stops requesting them. litestream resets its
-* monitor tick after every requested sync, so the backstop only fires once
-* requests stop for a full interval. It must still be longer than the request
-* interval, or timer jitter would occasionally let a tick slip in just before
-* a request and seal an extra backup file.
-*/
-function litestreamMonitorIntervalSeconds(incrementalBackupIntervalSeconds, syncRequesterEnabled) {
-	return syncRequesterEnabled ? 2 * incrementalBackupIntervalSeconds : incrementalBackupIntervalSeconds;
-}
 function startReplicaBackupProcess(lc, config, replicaFile) {
 	const { litestream, env } = getLitestream("replicate", config, replicaFile);
 	const attrs = litestreamBackupProcessMetricAttrs(config);
@@ -379,6 +385,6 @@ function parseBackupCreatedTimes(lc, command, output) {
 	return times;
 }
 //#endregion
-export { getLastBackupTime, startReplicaBackupProcess, tryRestore };
+export { deleteLitestreamMetaDir, getLastBackupTime, startReplicaBackupProcess, tryRestore };
 //# sourceMappingURL=commands.js.map