forked from mtusi2026/mtusi2026lab7
128 lines
4.4 KiB
TypeScript
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");
|
|
};
|
|
}
|