123 lines
7.5 KiB
TypeScript
123 lines
7.5 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { createHash } from "node:crypto"
|
|
import { lstat, mkdtemp, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises"
|
|
import os from "node:os"
|
|
import path from "node:path"
|
|
import test from "node:test"
|
|
import {
|
|
consumeRestoreCheckpointFile, publishSealedRestoreCheckpointFile, stagePendingRestoreCheckpointFile,
|
|
} from "./database-restore-checkpoint-operator.js"
|
|
import { parseDatabaseRestoreCheckpoint, restoreWriterHeadIsCurrent, type RestoreCheckpoint } from "./database-restore-checkpoint.js"
|
|
|
|
const checkpoint: Extract<RestoreCheckpoint, { status: "pending" }> = {
|
|
format: "database-restore-checkpoint-v1", status: "pending", head: null,
|
|
runtimeTargetSha256: "a".repeat(64), activationSha256: null,
|
|
operationId: "00000000-0000-0000-0000-000000000001", archiveSha256: "b".repeat(64), dataSha256: "c".repeat(64),
|
|
}
|
|
const claim = "d".repeat(64)
|
|
const refused = { code: "DATABASE_RESTORE_CHECKPOINT_REFUSED" }
|
|
|
|
test("checkpoint staging requires the exact sealed file and can succeed only once", async (t) => {
|
|
const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-"))
|
|
t.after(() => rm(directory, { recursive: true }))
|
|
const file = path.join(directory, "checkpoint.json")
|
|
const { operationId, archiveSha256, dataSha256, ...baseline } = checkpoint
|
|
const sealed = { ...baseline, status: "sealed" as const, head: { bytes: 50, sha256: claim } }
|
|
const permit = { operationId, archiveSha256, dataSha256 }
|
|
const bytes = JSON.stringify(sealed)
|
|
const sha256 = createHash("sha256").update(bytes).digest("hex")
|
|
await writeFile(file, bytes + "\n")
|
|
await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, permit, sha256), refused)
|
|
assert.equal(await readFile(file, "utf8"), bytes + "\n")
|
|
await writeFile(file, bytes)
|
|
await assert.rejects(stagePendingRestoreCheckpointFile(file, { ...sealed, head: null }, permit, sha256), refused)
|
|
await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, { ...permit, dataSha256: "invalid" }, sha256), refused)
|
|
|
|
const permits = [permit, { ...permit, operationId: "00000000-0000-0000-0000-000000000002" }]
|
|
const outcomes = await Promise.allSettled(permits.map((one) => stagePendingRestoreCheckpointFile(file, sealed, one, sha256)))
|
|
assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1)
|
|
const winner = permits[outcomes.findIndex((outcome) => outcome.status === "fulfilled")]
|
|
await assert.rejects(stagePendingRestoreCheckpointFile(file, sealed, permit, sha256), refused)
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), { ...sealed, status: "pending", ...winner })
|
|
assert.deepEqual(await readdir(directory), ["checkpoint.json"])
|
|
})
|
|
|
|
test("checkpoint consumption refuses evidence conflicts and can succeed only once", async (t) => {
|
|
const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-"))
|
|
t.after(() => rm(directory, { recursive: true }))
|
|
const file = path.join(directory, "checkpoint.json")
|
|
const original = JSON.stringify(checkpoint)
|
|
await writeFile(file, original, { mode: 0o640 })
|
|
const before = await lstat(file)
|
|
await assert.rejects(consumeRestoreCheckpointFile(file, { ...checkpoint, archiveSha256: "e".repeat(64) }, claim), refused)
|
|
|
|
for (const suffix of [".lock", ".pending"]) {
|
|
const residue = `${file}${suffix}`
|
|
await writeFile(residue, "prior attempt", { flag: "wx" })
|
|
await assert.rejects(consumeRestoreCheckpointFile(file, checkpoint, claim), refused)
|
|
assert.equal(await readFile(residue, "utf8"), "prior attempt")
|
|
assert.equal(await readFile(file, "utf8"), original)
|
|
await rm(residue)
|
|
}
|
|
|
|
const outcomes = await Promise.allSettled([claim, "f".repeat(64)].map((id) => consumeRestoreCheckpointFile(file, checkpoint, id)))
|
|
assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1)
|
|
const winner = outcomes[0].status === "fulfilled" ? claim : "f".repeat(64)
|
|
const consumed = { ...checkpoint, status: "consumed", claimId: winner }
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed)
|
|
if (process.platform !== "win32") {
|
|
const after = await lstat(file)
|
|
assert.equal(after.mode & 0o777, before.mode & 0o777)
|
|
assert.equal(after.uid, before.uid)
|
|
assert.equal(after.gid, before.gid)
|
|
}
|
|
await assert.rejects(consumeRestoreCheckpointFile(file, checkpoint, winner), refused)
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed)
|
|
assert.deepEqual(await readdir(directory), ["checkpoint.json"])
|
|
})
|
|
|
|
test("checkpoint sealing requires the exact consumed snapshot and one advancing journal head", async (t) => {
|
|
const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-"))
|
|
t.after(() => rm(directory, { recursive: true }))
|
|
const file = path.join(directory, "checkpoint.json")
|
|
const consumed = {
|
|
...checkpoint, status: "consumed" as const, claimId: claim, activationSha256: "e".repeat(64),
|
|
head: { bytes: 50, sha256: "f".repeat(64) },
|
|
}
|
|
const appliedHeads = [{ bytes: 100, sha256: "1".repeat(64) }, { bytes: 110, sha256: "2".repeat(64) }]
|
|
await writeFile(file, JSON.stringify(consumed))
|
|
await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, consumed.head), refused)
|
|
await assert.rejects(publishSealedRestoreCheckpointFile(file, { ...consumed, claimId: "a".repeat(64) }, appliedHeads[0]), refused)
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed)
|
|
|
|
const outcomes = await Promise.allSettled(appliedHeads.map((head) => publishSealedRestoreCheckpointFile(file, consumed, head)))
|
|
assert.equal(outcomes.filter((outcome) => outcome.status === "fulfilled").length, 1)
|
|
const sealed = {
|
|
format: consumed.format, status: "sealed", runtimeTargetSha256: consumed.runtimeTargetSha256,
|
|
activationSha256: consumed.activationSha256, head: appliedHeads[outcomes.findIndex((outcome) => outcome.status === "fulfilled")],
|
|
}
|
|
await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, appliedHeads[0]), refused)
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), sealed)
|
|
assert.deepEqual(await readdir(directory), ["checkpoint.json"])
|
|
})
|
|
|
|
test("protected checkpoint requires a newer writer epoch and rejects rollback after sealing", async (t) => {
|
|
const directory = await mkdtemp(path.join(await realpath(os.tmpdir()), "restore-checkpoint-"))
|
|
t.after(() => rm(directory, { recursive: true }))
|
|
const file = path.join(directory, "checkpoint.json")
|
|
const before = { epoch: "7", sha256: "1".repeat(64) }
|
|
const after = { epoch: "8", sha256: "2".repeat(64) }
|
|
const consumed = { ...checkpoint, status: "consumed" as const, claimId: claim, writerHead: before }
|
|
const applied = { bytes: 100, sha256: "3".repeat(64) }
|
|
await writeFile(file, JSON.stringify(consumed))
|
|
await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, applied), refused)
|
|
await assert.rejects(publishSealedRestoreCheckpointFile(file, consumed, applied, before), refused)
|
|
assert.deepEqual(parseDatabaseRestoreCheckpoint(await readFile(file)), consumed)
|
|
await publishSealedRestoreCheckpointFile(file, consumed, applied, after)
|
|
const sealed = parseDatabaseRestoreCheckpoint(await readFile(file))
|
|
assert.deepEqual(sealed.writerHead, after)
|
|
assert.ok(restoreWriterHeadIsCurrent(sealed.writerHead, after))
|
|
assert.ok(!restoreWriterHeadIsCurrent(sealed.writerHead, before))
|
|
assert.ok(!restoreWriterHeadIsCurrent(sealed.writerHead, { ...after, sha256: before.sha256 }))
|
|
})
|