Files
mtusi2026lab7/scripts/sealed-shutdown.ts

128 lines
4.4 KiB
TypeScript

export const sealedServices = ["api1", "api2", "worker"] as const;
export type SealedService = (typeof sealedServices)[number];
export type ProcessState = { id: string; running: boolean; restarts: number };
export type CauseEvent = { event: string; milliseconds: number };
export type SealedBaseline = {
baseline: Record<SealedService, ProcessState>;
freshness: Record<SealedService, number>;
started: number;
};
export type SealedPorts = {
inspect: (
service: SealedService,
expectedId: string | null,
) => Promise<ProcessState>;
readFreshness: (service: SealedService) => Promise<string>;
readEvents: (id: string, since: number) => Promise<CauseEvent[]>;
retainBaseline: (value: SealedBaseline) => Promise<void>;
seal: () => Promise<void>;
now: () => number;
sleep: (milliseconds: number) => Promise<void>;
};
export type SealLimits = {
maxAgeMilliseconds: number;
deadlineMilliseconds: number;
pollMilliseconds: number;
};
export function createSealedShutdown(ports: SealedPorts, limits: SealLimits) {
for (const key of [
"inspect",
"readFreshness",
"readEvents",
"retainBaseline",
"seal",
"now",
"sleep",
] as const)
if (typeof ports?.[key] !== "function")
throw Error("SEALED_PORTS_REQUIRED");
if (
!Object.values(limits).every((x) => Number.isSafeInteger(x) && x > 0) ||
limits.pollMilliseconds > limits.deadlineMilliseconds
)
throw Error("SEALED_LIMITS_INVALID");
return async () => {
const baseline = {} as Record<SealedService, ProcessState>,
freshness = {} as Record<SealedService, number>;
const now = () => {
const value = ports.now();
if (!Number.isFinite(value) || value < 0)
throw Error("SEALED_CLOCK_INVALID");
return value;
};
for (const service of sealedServices) {
const state = await ports.inspect(service, null);
if (!state.running) throw Error("SEALED_BASELINE_NOT_RUNNING");
if (
!/^[a-f0-9]{12,64}$/.test(state.id) ||
!Number.isSafeInteger(state.restarts) ||
state.restarts < 0
)
throw Error("SEALED_BASELINE_INVALID");
baseline[service] = state;
freshness[service] = Date.parse(
(await ports.readFreshness(service)).trim(),
);
}
const started = now();
for (const service of sealedServices) {
const age = started - freshness[service];
if (!Number.isFinite(age) || age < 0 || age > limits.maxAgeMilliseconds)
throw Error("SEALED_BASELINE_NOT_FRESH");
}
await ports.retainBaseline({ baseline, freshness, started });
const dispatch = now();
for (const service of sealedServices) {
const age = dispatch - freshness[service];
if (!Number.isFinite(age) || age < 0 || age > limits.maxAgeMilliseconds)
throw Error("SEALED_BASELINE_NOT_FRESH");
}
await ports.seal();
const sealedAt = now();
const observed: Partial<
Record<
SealedService,
{
id: string;
event: string;
seconds: number;
running: boolean;
restarts: number;
cause_milliseconds: number;
}
>
> = {};
while (now() - started < limits.deadlineMilliseconds) {
for (const service of sealedServices) {
if (observed[service]) continue;
const base = baseline[service],
state = await ports.inspect(service, base.id);
if (state.id !== base.id) throw Error("SEALED_CONTAINER_CHANGED");
const at = now();
if (at < sealedAt) throw Error("SEALED_CLOCK_INVALID");
const events = await ports.readEvents(base.id, sealedAt),
cause = events.find(
(e) =>
e.event === "secret_freshness_failed" &&
Number.isFinite(e.milliseconds) &&
e.milliseconds >= sealedAt &&
e.milliseconds <= at,
);
if (cause && (!state.running || state.restarts > base.restarts))
observed[service] = {
id: base.id,
event: "secret_freshness_failed",
seconds: (at - started) / 1000,
running: state.running,
restarts: state.restarts,
cause_milliseconds: cause.milliseconds,
};
}
if (sealedServices.every((s) => observed[s]))
return { started, sealedAt, baseline, freshness, observed };
await ports.sleep(limits.pollMilliseconds);
}
throw Error("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");
};
}