372 lines
14 KiB
TypeScript
372 lines
14 KiB
TypeScript
import { putFileBlob, blobContent } from '../db/file-blobs.js';
|
|
import type { ArtifactKind } from '../config.js';
|
|
import { db } from '../db/index.js';
|
|
import { emit } from '../pipeline/bus.js';
|
|
import { getVersion } from './scripts.js';
|
|
import {
|
|
cancelStagedFiles,
|
|
isFileApplied,
|
|
queueFileChange,
|
|
stagedFileChanges
|
|
} from './staged-files.js';
|
|
|
|
// Roll a promoted deployment back to whatever versions were current before
|
|
// the promote landed. Reads deployment_scripts as the source of truth for
|
|
// which scripts were involved (and their prior versions); falls back to the
|
|
// deprecated deployments.script_id/version_id/prior_version_id columns for
|
|
// pre-multi-script legacy rows.
|
|
|
|
export class RollbackError extends Error {
|
|
constructor(
|
|
message: string,
|
|
public readonly kind:
|
|
| 'history-expired'
|
|
| 'no-such-deployment'
|
|
| 'not-promote'
|
|
| 'already-rolled-back'
|
|
| 'snapshot-pending'
|
|
) {
|
|
super(message);
|
|
}
|
|
}
|
|
|
|
interface DeploymentRow {
|
|
id: string;
|
|
action: string;
|
|
script_id: number | null;
|
|
script_version_id: number | null;
|
|
prior_version_id: number | null;
|
|
rolled_back_by: string | null;
|
|
beta_id: number | null;
|
|
}
|
|
|
|
interface DepScriptRow {
|
|
deployment_id: string;
|
|
script_id: number;
|
|
script_version_id: number;
|
|
prior_version_id: number | null;
|
|
kind: ArtifactKind;
|
|
}
|
|
|
|
interface FileRow {
|
|
id: number;
|
|
server: string;
|
|
verb: 'added' | 'updated' | 'removed';
|
|
rel_path: string;
|
|
sha256_before: string | null;
|
|
sha256_after: string | null;
|
|
content_before: Buffer | null;
|
|
content_after: Buffer | null;
|
|
snapshot_pending: number;
|
|
}
|
|
|
|
interface ScriptTargetRow {
|
|
id: number;
|
|
target_rel_path: string;
|
|
kind: ArtifactKind;
|
|
}
|
|
|
|
function nowIso(): string {
|
|
return new Date().toISOString();
|
|
}
|
|
|
|
function rollbackDeploymentId(promoteId: string): string {
|
|
const stamp = new Date()
|
|
.toISOString()
|
|
.replace(/[-:]/g, '')
|
|
.replace(/\.\d+Z$/, 'Z');
|
|
return `dep-${stamp}-rollback-${promoteId}`;
|
|
}
|
|
|
|
export interface RollbackDeploymentResult {
|
|
deploymentId: string; // the new rollback deployment
|
|
reverses: string; // the promote deployment id
|
|
scriptIds: number[]; // scripts whose current_version_id got reverted
|
|
affectedServers: string[];
|
|
}
|
|
|
|
export async function rollbackPromoteDeployment(
|
|
promoteId: string
|
|
): Promise<RollbackDeploymentResult> {
|
|
const dep = db()
|
|
.prepare(
|
|
`SELECT id, action, script_id, script_version_id, prior_version_id, rolled_back_by, beta_id
|
|
FROM deployments WHERE id = ?`
|
|
)
|
|
.get(promoteId) as DeploymentRow | undefined;
|
|
if (!dep) throw new RollbackError(`no such deployment ${promoteId}`, 'no-such-deployment');
|
|
if (
|
|
db()
|
|
.prepare(
|
|
"SELECT 1 FROM retention_expirations WHERE category='file-content' AND record_id=?"
|
|
)
|
|
.get(promoteId)
|
|
) {
|
|
throw new RollbackError(
|
|
'Rollback file contents have expired under the retention policy.',
|
|
'history-expired'
|
|
);
|
|
}
|
|
if (dep.action !== 'promote') {
|
|
throw new RollbackError(
|
|
`deployment ${promoteId} is action='${dep.action}', not 'promote'`,
|
|
'not-promote'
|
|
);
|
|
}
|
|
if (dep.rolled_back_by) {
|
|
throw new RollbackError(
|
|
`deployment ${promoteId} already rolled back by ${dep.rolled_back_by}`,
|
|
'already-rolled-back'
|
|
);
|
|
}
|
|
|
|
// Source of truth for which scripts (and prior versions) this promote
|
|
// touched. Prefer deployment_scripts; fall back to the deprecated
|
|
// singular columns for legacy single-script deployments.
|
|
let scripts = db()
|
|
.prepare(`SELECT * FROM deployment_scripts WHERE deployment_id = ? ORDER BY script_id`)
|
|
.all(promoteId) as DepScriptRow[];
|
|
if (scripts.length === 0 && dep.script_id !== null && dep.script_version_id !== null) {
|
|
scripts = [
|
|
{
|
|
deployment_id: promoteId,
|
|
script_id: dep.script_id,
|
|
script_version_id: dep.script_version_id,
|
|
prior_version_id: dep.prior_version_id,
|
|
kind: 'script'
|
|
}
|
|
];
|
|
}
|
|
|
|
const fileRows = db()
|
|
.prepare(
|
|
`SELECT f.id, f.server, f.verb, f.rel_path, f.sha256_before, f.sha256_after, ${blobContent('f.content_before_hash')} AS content_before, ${blobContent('f.content_after_hash')} AS content_after, f.snapshot_pending
|
|
FROM deployment_files f JOIN deployment_servers ds ON ds.deployment_id = f.deployment_id AND ds.server = f.server
|
|
JOIN servers s ON s.name = f.server
|
|
WHERE f.deployment_id = ? AND ds.server_deleted_at IS NULL AND s.destroyed_at IS NULL ORDER BY f.server, f.rel_path`
|
|
)
|
|
.all(promoteId) as FileRow[];
|
|
|
|
// Different games may promote distinct scripts with the same target path.
|
|
// Retain all candidates and resolve ownership from the per-server history.
|
|
const scriptsByTarget = new Map<string, DepScriptRow[]>();
|
|
const kindByScriptId = new Map<number, ArtifactKind>();
|
|
if (scripts.length > 0) {
|
|
const placeholders = scripts.map(() => '?').join(',');
|
|
const targetRows = db()
|
|
.prepare(`SELECT id, target_rel_path, kind FROM scripts WHERE id IN (${placeholders})`)
|
|
.all(...scripts.map((s) => s.script_id)) as ScriptTargetRow[];
|
|
const targetById = new Map<number, string>();
|
|
for (const t of targetRows) {
|
|
targetById.set(t.id, t.target_rel_path);
|
|
kindByScriptId.set(t.id, t.kind);
|
|
}
|
|
for (const s of scripts) {
|
|
const t = targetById.get(s.script_id);
|
|
if (t) scriptsByTarget.set(t, [...(scriptsByTarget.get(t) ?? []), s]);
|
|
}
|
|
}
|
|
const staged = stagedFileChanges('campaign', promoteId);
|
|
const scriptForFile = (file: FileRow): DepScriptRow | undefined => {
|
|
const candidates = scriptsByTarget.get(file.rel_path) ?? [];
|
|
const versionId = staged.find(
|
|
(row) => row.deployment_file_id === file.id
|
|
)?.script_version_id;
|
|
if (versionId) return candidates.find((script) => script.script_version_id === versionId);
|
|
if (dep.beta_id) {
|
|
const participant = candidates.find((script) =>
|
|
db()
|
|
.prepare(
|
|
`SELECT 1 FROM beta_server_scripts
|
|
WHERE beta_id = ? AND server = ? AND script_id = ?`
|
|
)
|
|
.get(dep.beta_id, file.server, script.script_id)
|
|
);
|
|
if (participant) return participant;
|
|
}
|
|
return (
|
|
candidates.find(
|
|
(script) => getVersion(script.script_version_id)?.sha256 === file.sha256_after
|
|
) ?? candidates[0]
|
|
);
|
|
};
|
|
const kindForFile = (file: FileRow): ArtifactKind => {
|
|
const stagedKind = staged.find((row) => row.deployment_file_id === file.id)?.kind;
|
|
if (stagedKind) return stagedKind;
|
|
const owner = scriptForFile(file);
|
|
if (owner) return owner.kind ?? kindByScriptId.get(owner.script_id) ?? 'script';
|
|
// Config/baseline aggregate rows have no per-artifact target_rel_path
|
|
// mapping — the deployment_files row is keyed on the shared cfg name.
|
|
// Any script/baseline in this deployment tagged as config/baseline
|
|
// means the rollback for that path lives under the config destination.
|
|
for (const s of scripts) if (s.kind === 'config' || s.kind === 'baseline') return 'config';
|
|
return 'script';
|
|
};
|
|
|
|
const newDepId = rollbackDeploymentId(promoteId);
|
|
const startedAt = nowIso();
|
|
|
|
// Group files by server so each server gets exactly one deployment_servers row.
|
|
const perServer = new Map<string, FileRow[]>();
|
|
for (const f of fileRows) {
|
|
// A promotion can still be waiting for empty servers. Withdrawing it
|
|
// must not restore or remove files that it never installed. Rows from
|
|
// older releases have no staging record and retain their audit meaning.
|
|
const kind = kindForFile(f);
|
|
const preservesBetaSnapshot = staged.some(
|
|
(row) =>
|
|
row.server === f.server &&
|
|
row.kind === kind &&
|
|
row.rel_path === f.rel_path &&
|
|
row.preserve_before_image
|
|
);
|
|
if (
|
|
!preservesBetaSnapshot &&
|
|
isFileApplied('campaign', promoteId, f.server, kind, f.rel_path) === false
|
|
)
|
|
continue;
|
|
if (f.snapshot_pending) {
|
|
throw new RollbackError(
|
|
`${f.server}: rollback snapshot for ${f.rel_path} is awaiting activation confirmation. Reconcile the provisioning operation before rolling back.`,
|
|
'snapshot-pending'
|
|
);
|
|
}
|
|
const arr = perServer.get(f.server);
|
|
if (arr) arr.push(f);
|
|
else perServer.set(f.server, [f]);
|
|
}
|
|
|
|
const affectedServers: string[] = [];
|
|
const active = (server: string) =>
|
|
!!db()
|
|
.prepare(
|
|
`SELECT 1 FROM deployment_servers ds JOIN servers s ON s.name = ds.server
|
|
WHERE ds.deployment_id = ? AND ds.server = ? AND ds.server_deleted_at IS NULL AND s.destroyed_at IS NULL`
|
|
)
|
|
.get(promoteId, server);
|
|
|
|
// Write the new rollback deployment + mark the original.
|
|
const insertDep = db().prepare(
|
|
`INSERT INTO deployments
|
|
(id, action, started_at, triggered_by, script_id, script_version_id, prior_version_id, beta_id)
|
|
VALUES (?, 'rollback', ?, 'ui', NULL, NULL, NULL, NULL)`
|
|
);
|
|
const insertDepScript = db().prepare(
|
|
`INSERT INTO deployment_scripts (deployment_id, script_id, script_version_id, prior_version_id, kind)
|
|
VALUES (?, ?, ?, ?, ?)`
|
|
);
|
|
const insertDepServer = db().prepare(
|
|
`INSERT INTO deployment_servers
|
|
(deployment_id, server, files_changed, restart_state, players, checked_at, restarted_at, attempts, error)
|
|
VALUES (?, ?, ?, ?, NULL, NULL, NULL, 0, ?)`
|
|
);
|
|
const insertDepFile = db().prepare(
|
|
`INSERT INTO deployment_files
|
|
(deployment_id, server, verb, rel_path, sha256_before, sha256_after, content_before_hash, content_after_hash)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
|
|
);
|
|
|
|
db().transaction(() => {
|
|
cancelStagedFiles('campaign', promoteId);
|
|
// Withdrawing this source leaves a shared restart available to other
|
|
// campaigns. Provisioning cancels an operation with no eligible sources.
|
|
db()
|
|
.prepare(
|
|
`UPDATE deployment_servers SET restart_state = 'skipped', error = NULL
|
|
WHERE deployment_id = ? AND server_deleted_at IS NULL AND restart_state IN ('pending','failed','held','manual')`
|
|
)
|
|
.run(promoteId);
|
|
insertDep.run(newDepId, startedAt);
|
|
// Mirror the promote's script list — swapped: the "current" version
|
|
// after rollback is the promote's prior; the "prior" of the rollback
|
|
// is what was current up until this call (i.e. the promote's version).
|
|
for (const s of scripts) {
|
|
insertDepScript.run(
|
|
newDepId,
|
|
s.script_id,
|
|
s.prior_version_id ?? s.script_version_id,
|
|
s.script_version_id,
|
|
s.kind ?? 'script'
|
|
);
|
|
}
|
|
for (const [server, files] of perServer) {
|
|
if (!active(server)) continue;
|
|
if (files.some((file) => file.verb !== 'added' && file.content_before === null)) {
|
|
insertDepServer.run(
|
|
newDepId,
|
|
server,
|
|
0,
|
|
'failed',
|
|
'Original file snapshot is missing; cannot restore safely'
|
|
);
|
|
continue;
|
|
}
|
|
insertDepServer.run(newDepId, server, files.length, 'pending', null);
|
|
for (const f of files) {
|
|
const invertedVerb =
|
|
f.verb === 'added' ? 'removed' : f.verb === 'removed' ? 'added' : 'updated';
|
|
const inserted = insertDepFile.run(
|
|
newDepId,
|
|
server,
|
|
invertedVerb,
|
|
f.rel_path,
|
|
f.sha256_after,
|
|
f.sha256_before,
|
|
putFileBlob(f.content_after),
|
|
putFileBlob(f.content_before)
|
|
);
|
|
const owningScript = scriptForFile(f);
|
|
const betaPrior =
|
|
dep.beta_id && owningScript
|
|
? (db()
|
|
.prepare(
|
|
`SELECT prior_version_id FROM beta_server_scripts
|
|
WHERE beta_id = ? AND server = ? AND script_id = ?`
|
|
)
|
|
.get(dep.beta_id, server, owningScript.script_id) as
|
|
{ prior_version_id: number | null } | undefined)
|
|
: undefined;
|
|
const priorVersionId = betaPrior
|
|
? betaPrior.prior_version_id
|
|
: owningScript?.prior_version_id;
|
|
const priorVersion = priorVersionId ? getVersion(priorVersionId) : null;
|
|
queueFileChange({
|
|
sourceKind: 'campaign',
|
|
sourceId: newDepId,
|
|
server,
|
|
kind: kindForFile(f),
|
|
relPath: f.rel_path,
|
|
content: f.verb === 'added' ? null : f.content_before,
|
|
scriptVersionId: f.verb === 'updated' ? (priorVersion?.id ?? null) : null,
|
|
inventorySource: `rollback:${newDepId}`,
|
|
deploymentFileId: Number(inserted.lastInsertRowid)
|
|
});
|
|
}
|
|
affectedServers.push(server);
|
|
}
|
|
db()
|
|
.prepare(`UPDATE deployments SET rolled_back_by = ? WHERE id = ?`)
|
|
.run(newDepId, promoteId);
|
|
// Restore each affected script's current_version_id.
|
|
for (const s of scripts) {
|
|
db()
|
|
.prepare(`UPDATE scripts SET current_version_id = ? WHERE id = ?`)
|
|
.run(s.prior_version_id, s.script_id);
|
|
}
|
|
})();
|
|
|
|
emit({
|
|
type: 'deployment-opened',
|
|
deploymentId: newDepId,
|
|
action: 'rollback',
|
|
servers: affectedServers
|
|
});
|
|
|
|
return {
|
|
deploymentId: newDepId,
|
|
reverses: promoteId,
|
|
scriptIds: scripts.map((s) => s.script_id),
|
|
affectedServers
|
|
};
|
|
}
|