@substrat-run/kernel 0.148.0 → 0.149.0

package/dist/store-driver-releases.d.ts

@@ -0,0 +1,306 @@
+import type { SwitchSql } from './system-switch.js';
+/** Interpolated into both adapters' directory DDL, so `lint:spine-ddl` sees one spelling on each side. */
+export declare const STORE_DRIVER_RELEASES_DDL = "\n  CREATE TABLE IF NOT EXISTS store_driver_releases (\n    driver        TEXT NOT NULL,\n    sha256        TEXT NOT NULL,\n    source_commit TEXT NOT NULL,\n    uploaded_by   TEXT NOT NULL,\n    uploaded_at   TEXT NOT NULL,\n    PRIMARY KEY (driver, sha256)\n  );\n  CREATE TABLE IF NOT EXISTS store_driver_rollouts (\n    driver               TEXT NOT NULL,\n    seq                  INTEGER NOT NULL,\n    sha256               TEXT NOT NULL,\n    action               TEXT NOT NULL,\n    from_sha256          TEXT,\n    previous_good_sha256 TEXT,\n    state                TEXT NOT NULL,\n    actor                TEXT NOT NULL,\n    -- The hold the rollout runs under: a rolling row whose holder holds nothing has stopped.\n    holder               TEXT NOT NULL,\n    started_at           TEXT NOT NULL,\n    ended_at             TEXT,\n    detail               TEXT,\n    PRIMARY KEY (driver, seq)\n  );\n  CREATE TABLE IF NOT EXISTS store_driver_current (\n    driver TEXT PRIMARY KEY,\n    sha256 TEXT NOT NULL,\n    seq    INTEGER NOT NULL\n  );\n  -- One declaration an attempt walked (#2312). The attempt is the seq of its first row; a row\n  -- continues it while the rows before it are paused at the same release and action.\n  CREATE TABLE IF NOT EXISTS store_driver_rollout_walks (\n    driver           TEXT NOT NULL,\n    attempt          INTEGER NOT NULL,\n    vertical_slug    TEXT NOT NULL,\n    binding          TEXT NOT NULL,\n    first_version_id TEXT NOT NULL,\n    PRIMARY KEY (driver, attempt, vertical_slug, binding, first_version_id)\n  );\n  CREATE TABLE IF NOT EXISTS store_driver_holds (\n    driver     TEXT NOT NULL,\n    holder     TEXT NOT NULL,\n    mode       TEXT NOT NULL,\n    expires_at INTEGER NOT NULL,\n    PRIMARY KEY (driver, holder)\n  );\n  CREATE TABLE IF NOT EXISTS store_driver_rebuilds (\n    driver           TEXT PRIMARY KEY,\n    fingerprint      TEXT NOT NULL,\n    -- When this fingerprint was first walked towards: a restart keeps it, a new fingerprint resets it.\n    fingerprint_since TEXT NOT NULL,\n    cursor           TEXT,\n    failures         TEXT NOT NULL,\n    state            TEXT NOT NULL,\n    holder           TEXT,\n    lease_expires_at INTEGER NOT NULL,\n    -- When this walk began from its first script: a restart or a new fingerprint sets it, a pass\n    -- that continues the walk keeps it.\n    started_at       TEXT NOT NULL,\n    -- The person who attested, when this walk began, that no control-plane deploy was rolling out.\n    attested_by      TEXT,\n    -- When a walk towards this fingerprint last proved every script current; kept across a\n    -- restart at the same fingerprint, cleared by a new one.\n    verified_at      TEXT,\n    updated_at       TEXT NOT NULL,\n    finished_at      TEXT\n  );\n";
+/**
+ * The statements that move a directory built before the rename onto its names, to run before
+ * the directory's DDL on every start: that DDL is all `IF NOT EXISTS`, so it would leave an old
+ * table as it is and create an empty one beside it. Renames keep every row, a release uploaded
+ * before its pin included. Empty once moved, so a later start does nothing.
+ *
+ * A directory can hold both names: code from before the rename, run again after it (a rollback),
+ * creates the old tables empty beside the moved ones, and writes to them while it runs. Then the
+ * name that holds no rows is dropped, and the one that holds them ends under the new name. When
+ * both hold rows, both are left where they are: nothing is merged, and nothing with rows is
+ * dropped.
+ *
+ * `tables` is every table the directory holds; `columnsOf` answers a table's columns, and
+ * `hasRows` whether it holds any.
+ */
+export declare function legacyStoreDriverRenames(tables: readonly string[], columnsOf: (table: string) => readonly string[] | undefined, hasRows: (table: string) => boolean): string[];
+/**
+ * The tables that hold rows under both names, which {@link legacyStoreDriverRenames} leaves
+ * alone, as one line a start logs: until one is cleared, a directory dump carries both and a
+ * restore of it is refused. Undefined when there are none. Reachable only after a rollback to
+ * pre-rename code that wrote a release, rollout or hold, which no registered driver allowed yet.
+ */
+export declare function legacyStoreDriverConflict(tables: readonly string[], hasRows: (table: string) => boolean): string | undefined;
+/**
+ * A directory dump's tables with the pre-rename names mapped onto this code's (see
+ * {@link legacyStoreDriverRenames}), so a copy taken before the rename restores: the dump's rows
+ * go in by name, and a restore refuses a table it does not build. A dump that carries a table
+ * under both names keeps the one that holds rows, the way a start does; one where both hold rows
+ * is refused, since loading both would merge two histories.
+ */
+export declare function mapLegacyStoreDriverDump<T extends {
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly rows: readonly unknown[];
+}>(tables: readonly T[]): T[];
+/** A stored release: its bytes are kept elsewhere under `<driver>/<sha256>`. */
+export interface StoreDriverReleaseRecord {
+    readonly driver: string;
+    readonly sha256: string;
+    readonly sourceCommit: string;
+    readonly uploadedBy: string;
+    readonly uploadedAt: string;
+}
+export type StoreDriverRolloutAction = 'rollout' | 'rollback';
+/**
+ * `paused`: the request's batch ran out with verticals left to walk. Nothing failed; the fleet is
+ * part way, and posting the same rollout (or the same rollback) again continues it.
+ */
+export type StoreDriverRolloutState = 'rolling' | 'good' | 'failed' | 'diverged' | 'paused';
+export interface StoreDriverRolloutRecord {
+    readonly driver: string;
+    readonly seq: number;
+    readonly sha256: string;
+    readonly action: StoreDriverRolloutAction;
+    /** The current good release when the rollout began; null for a driver's first. */
+    readonly fromSha256: string | null;
+    /** Where a rollback from this release, once it is good, returns to; null when nowhere. */
+    readonly previousGoodSha256: string | null;
+    readonly state: StoreDriverRolloutState;
+    readonly actor: string;
+    readonly startedAt: string;
+    readonly endedAt: string | null;
+    readonly detail: string | null;
+}
+export interface StoreDriverState {
+    /** The release the last good rollout reached, and that rollout. Null before any. */
+    readonly current: {
+        readonly sha256: string;
+        readonly seq: number;
+        readonly previousGoodSha256: string | null;
+    } | null;
+    /** Every rollout, oldest first. */
+    readonly rollouts: StoreDriverRolloutRecord[];
+    /** Where a rollback goes now (see `storeDriverStateIn`); null when nowhere. */
+    readonly rollbackTarget: string | null;
+    /** The target of a rollback that paused or diverged part way, until it ends good. Unless it is the current release, it blocks rollouts. */
+    readonly unfinishedRollback: string | null;
+}
+export type StoreDriverHoldMode = 'shared' | 'exclusive';
+/** A stored release, or undefined. */
+export declare function storeDriverReleaseIn(db: SwitchSql, driver: string, sha256: string): StoreDriverReleaseRecord | undefined;
+/**
+ * Record that a release's bytes are stored. The same sha256 again is the same release, and the
+ * row already written is returned as it stands (`created: false`). The same sha256 from another
+ * commit is refused (`conflict`): one bundle has one source the reviewer reads.
+ */
+export declare function recordStoreDriverReleaseIn(db: SwitchSql, input: {
+    driver: string;
+    sha256: string;
+    sourceCommit: string;
+    actor: string;
+    at: string;
+}): {
+    record: StoreDriverReleaseRecord;
+    created: boolean;
+};
+/**
+ * The driver's current release, every rollout, and where a rollback goes now.
+ *
+ * With `nowMs`, a `rolling` row whose holder no longer holds the driver exclusively is reported as
+ * `diverged` (read-time only, nothing is written): its holder stopped, and its scripts may be on
+ * either release. The next rollout's begin writes that state.
+ *
+ * `rollbackTarget` is, in order:
+ * - the target of a rollback that is the newest attempt since the current release, a `failed` one
+ *   aside, and ended `paused` or `diverged` (`unfinishedRollback`): posting the rollback again
+ *   continues it, and never turns it around onto the release it is leaving. A `failed` request
+ *   changes nothing here: it moved nothing, or returned what its attempt moved, or (a later page's
+ *   canary) moved nothing in its own request while earlier pages' verticals stay on the new
+ *   release; those pages' `paused` rows are still since the current release, so the fleet still
+ *   reads as mixed below. No rollout may begin while a
+ *   rollback to an earlier release is unfinished, `paused` or `diverged` (`beginStoreDriverRolloutIn`):
+ *   it is finished first, by posting it again. A rollback onto the current release (undoing a
+ *   diverged rollout) does not block a rollout. A rollback to an earlier release cannot meet the
+ *   schema rule (the route refuses one below the current schema), but one onto the current release
+ *   can, and then it never finishes, so going forward must stay open;
+ * - the current release itself, when a rollout since it ended `diverged` or `paused` on ANOTHER
+ *   release: the fleet may be mixed, and undoing that rollout means converging every script back
+ *   on the release it was healthy on, never going past it. A row that moves scripts to the current
+ *   release itself (a re-post of it, paged over several requests, or a rollback onto it) leaves
+ *   every script on the current release whatever it ended, so it never makes the fleet mixed:
+ *   otherwise re-posting the current release past one request's walk would turn the rollback
+ *   onto the release being escaped (#2312);
+ * - otherwise the immediately previous good release.
+ * An unfinished attempt never changes what "previous good" means.
+ */
+export declare function storeDriverStateIn(db: SwitchSql, driver: string, nowMs?: number): StoreDriverState;
+/**
+ * Take, or renew, a hold on a driver. Answers false when another holder's live hold excludes it: an
+ * exclusive one for any request, or any one for an exclusive request. A lapsed hold is dropped
+ * first. Asking in the other mode than the one held is refused.
+ *
+ * `renew` only extends a hold the holder still holds: a holder whose lease lapsed gets false, even
+ * when nobody took the driver since, because a lapsed holder cannot know what happened meanwhile.
+ * With `rolloutSeq` it also answers false unless that rollout is still `rolling`, so a rollout
+ * whose row another holder ended stops instead of moving scripts the state no longer describes.
+ */
+export declare function holdStoreDriverIn(db: SwitchSql, input: {
+    driver: string;
+    holder: string;
+    mode: StoreDriverHoldMode;
+    nowMs: number;
+    ttlMs: number;
+    renew?: boolean;
+    rolloutSeq?: number;
+}): boolean;
+/** Drop a hold. Dropping one already gone is not an error. */
+export declare function releaseStoreDriverHoldIn(db: SwitchSql, input: {
+    driver: string;
+    holder: string;
+}): void;
+/**
+ * Begin a rollout or a rollback of a stored release, as the exclusive holder. A rollout left
+ * `rolling` by an earlier holder ends `diverged` here: its scripts may be on either release, and
+ * this rollout reaches all of them. A rollback must name the current release's previous good one.
+ */
+export declare function beginStoreDriverRolloutIn(db: SwitchSql, input: {
+    driver: string;
+    sha256: string;
+    action: StoreDriverRolloutAction;
+    holder: string;
+    actor: string;
+    at: string;
+    nowMs: number;
+}): StoreDriverRolloutRecord;
+/**
+ * End a rollout the caller began, as the exclusive holder. A good one makes its release current.
+ *
+ * `walked` is what this request walked, and only a `paused` end takes it (#2312): it joins the
+ * attempt's ledger in the transaction that writes the state, so a request that stops before its
+ * end leaves no ledger rows, and the next attempt walks those verticals again rather than skip
+ * them. What keeps a dead ledger unread is the attempt key (`attemptOf`); the deletes here keep the
+ * table to the one attempt a driver can continue: any end drops every other attempt's rows, and any
+ * end but `paused` this attempt's too.
+ */
+export declare function finishStoreDriverRolloutIn(db: SwitchSql, input: {
+    driver: string;
+    seq: number;
+    holder: string;
+    state: Exclude<StoreDriverRolloutState, 'rolling'>;
+    detail: string | null;
+    walked?: readonly StoreDriverRolloutTarget[];
+    at: string;
+    nowMs: number;
+}): StoreDriverRolloutRecord;
+/** One vertical (or the driver's canary) the fleet rebuild could not rebuild, and why. */
+export interface StoreDriverRebuildFailure {
+    readonly vertical: string;
+    readonly detail: string;
+}
+/** Where the platform's rebuild of every script of a driver stands (#2309). */
+export interface StoreDriverRebuildRecord {
+    readonly driver: string;
+    /** What the platform builds every script from, as the walk converges every script on it. */
+    readonly fingerprint: string;
+    /** When a walk towards this fingerprint first began: about when the control plane building from it was deployed. */
+    readonly fingerprintSince: string;
+    /** The last vertical the walk reached, in slug order; null before the first. */
+    readonly cursor: string | null;
+    /** The verticals walked and not rebuilt. Retried on every pass until each is, or no longer declares the driver. */
+    readonly failures: readonly StoreDriverRebuildFailure[];
+    /** `done`: every vertical was walked and none failed. */
+    readonly state: 'running' | 'done';
+    /** When this walk began from its first script. */
+    readonly startedAt: string;
+    /** The person who attested, when this walk began, that no control-plane deploy was rolling out. */
+    readonly attestedBy: string | null;
+    /** When a walk towards this fingerprint last proved every script current; null before any. */
+    readonly verifiedAt: string | null;
+    readonly updatedAt: string;
+    readonly finishedAt: string | null;
+}
+/** The driver's fleet rebuild, or undefined before its first. */
+export declare function storeDriverRebuildIn(db: SwitchSql, driver: string): StoreDriverRebuildRecord | undefined;
+/**
+ * Take the lease on a driver's fleet rebuild, towards `fingerprint`, for `ttlMs`. Answers the
+ * rebuild as it stands, or null while another holder's lease is live. A rebuild towards another
+ * fingerprint (or none yet) starts over: no vertical is walked and none has failed, because every
+ * script may have been built from something else than what the platform builds from now. With
+ * `restart`, a rebuild already `done` at this fingerprint starts over too (a re-verification: a
+ * script uploaded since by a control plane still building from older inputs is found and rebuilt).
+ * With `attestedBy` (a person attesting no control-plane deploy is rolling out), the rebuild starts
+ * over and the new walk carries the attestation, unless a walk this attestation (any person's, at
+ * this fingerprint) already started is under way: that walk is continued, so repeating an attested
+ * run finishes a fleet larger than one run. Any other start clears it.
+ */
+export declare function claimStoreDriverRebuildIn(db: SwitchSql, input: {
+    driver: string;
+    fingerprint: string;
+    holder: string;
+    nowMs: number;
+    ttlMs: number;
+    at: string;
+    restart?: boolean;
+    attestedBy?: string;
+}): StoreDriverRebuildRecord | null;
+/**
+ * Record how far the lease holder's walk got, renewing the lease for `ttlMs`, or with `release`
+ * dropping it. `done` ends the rebuild; it needs no failure left. Refused (`conflict`) unless the
+ * caller is still the row's holder, towards `fingerprint`: once another pass claimed the row (a
+ * lapsed lease) or restarted it (a new fingerprint), the old holder writes nothing. A holder whose
+ * lease lapsed while nobody claimed the row still records what it did, which is then true. With
+ * `verified` (only with `done`), the walk proved every script current, and `verifiedAt` is set.
+ */
+export declare function advanceStoreDriverRebuildIn(db: SwitchSql, input: {
+    driver: string;
+    fingerprint: string;
+    holder: string;
+    cursor: string | null;
+    failures: readonly StoreDriverRebuildFailure[];
+    done: boolean;
+    verified?: boolean;
+    nowMs: number;
+    ttlMs: number;
+    release?: boolean;
+    at: string;
+}): StoreDriverRebuildRecord;
+/**
+ * One vertical's bindings of a driver as a rollout walks them (#2312). `firstVersionId` is the
+ * version that first declared the binding: a vertical deleted and registered again under the
+ * same slug declares it anew, under another id, so the ledger never counts the new one walked.
+ */
+export interface StoreDriverRolloutTarget {
+    readonly vertical: string;
+    readonly stores: readonly {
+        readonly binding: string;
+        readonly firstVersionId: string;
+    }[];
+}
+/**
+ * What the next request of a rollout of `sha256` (or a rollback to it) walks (#2312): the first
+ * `limit` verticals, in (vertical, binding) order, with a declaration of the driver that the attempt
+ * it would continue has not walked, and how many verticals are pending in all. Asked before the
+ * request's row begins, as the exclusive holder will begin it: a request that continues no attempt
+ * walks every declaration. `walked` counts the verticals the continued attempt walked that still
+ * declare the driver. `unreadable` is `driverDeclarationsOf`'s: a caller that must reach every script
+ * refuses while it is not empty.
+ */
+export declare function storeDriverRolloutPendingIn(db: SwitchSql, input: {
+    driver: string;
+    sha256: string;
+    action: StoreDriverRolloutAction;
+    limit: number;
+}): {
+    verticals: StoreDriverRolloutTarget[];
+    pending: number;
+    walked: number;
+    unreadable: string[];
+};
+/**
+ * What the attempt of the rollout at `seq` walked in its EARLIER requests and still declares the
+ * driver, in (vertical, binding) order: the verticals a failure part way returns, besides the ones
+ * its own request reached (#2312). At most `limit`, and `walked` counts them all.
+ */
+export declare function storeDriverRolloutWalkedIn(db: SwitchSql, input: {
+    driver: string;
+    seq: number;
+    limit: number;
+}): {
+    verticals: StoreDriverRolloutTarget[];
+    walked: number;
+};
+//# sourceMappingURL=store-driver-releases.d.ts.map

package/dist/store-driver-releases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-driver-releases.d.ts","sourceRoot":"","sources":["../src/store-driver-releases.ts"],"names":[],"mappings":"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"}