forked from mtusi2026/mtusi2026lab7
151 lines
4.6 KiB
TypeScript
151 lines
4.6 KiB
TypeScript
import { readFile, writeFile, mkdir } from "node:fs/promises";
|
|
import { resolve } from "node:path";
|
|
import { createHash } from "node:crypto";
|
|
import { root, run, requireThat, safeFailure } from "./runtime";
|
|
import { verifyBackendHandover } from "./preflight-build";
|
|
const copyRoot =
|
|
"/mnt/data/home/bench-saves/mtuci-vp-remaining-20261115/lab6/.local/oci-copy-21c9f273-7c3d-4235-9522-b2ade24db55c";
|
|
const declarations = [
|
|
{
|
|
name: "openobserve",
|
|
source: "mtuci-vp6-openobserve-cache:v1.1.2",
|
|
target: "mtuci-vp7-openobserve-cache:v1.1.2-26618f379c86",
|
|
digest:
|
|
"sha256:26618f379c86b253c0d91624c487dd14b71293699845ecbc8457c94dca14819f",
|
|
layers: 26,
|
|
},
|
|
{
|
|
name: "collector",
|
|
source: "mtuci-vp6-collector-cache:0.163.2",
|
|
target: "mtuci-vp7-collector-cache:0.163.2-a65df9129a5b",
|
|
digest:
|
|
"sha256:a65df9129a5b3f99ee4434c5e53aee1965ff0129eda6a2da75ea917165b7fa6b",
|
|
layers: 2,
|
|
},
|
|
];
|
|
async function inspect(image: string) {
|
|
return JSON.parse((await run(["docker", "image", "inspect", image])).out)[0];
|
|
}
|
|
export async function freezeCachedImages(apply: boolean) {
|
|
const lease = await verifyBackendHandover();
|
|
const receiptPaths = [
|
|
resolve(copyRoot, "COPY.json"),
|
|
resolve(copyRoot, "OPENOBSERVE-COMPLETE.json"),
|
|
resolve(
|
|
copyRoot,
|
|
"openobserve-import-8b8023dc-a86f-4d88-9eeb-e3d94ad755cf/IMPORT-READY.json",
|
|
),
|
|
];
|
|
const receipts = await Promise.all(
|
|
receiptPaths.map(async (path) => {
|
|
const bytes = await readFile(path);
|
|
return {
|
|
path,
|
|
sha256: createHash("sha256").update(bytes).digest("hex"),
|
|
data: JSON.parse(bytes.toString()),
|
|
};
|
|
}),
|
|
);
|
|
const copy = receipts[0].data,
|
|
complete = receipts[1].data,
|
|
ready = receipts[2].data;
|
|
requireThat(
|
|
copy.nodeStopped === true &&
|
|
copy.sourceMutated === false &&
|
|
copy.copied.length > 0 &&
|
|
copy.copied.every((d: any) => d.shaVerified === true),
|
|
"CACHE_SOURCE_COPY_NOT_VERIFIED",
|
|
);
|
|
requireThat(
|
|
complete.complete === true &&
|
|
complete.manifestDigest === declarations[0].digest &&
|
|
ready.completeRehashed === true &&
|
|
ready.manifestDigest === complete.manifestDigest &&
|
|
ready.configDigest === complete.configDigest,
|
|
"CACHE_OPENOBSERVE_HANDOVER_INVALID",
|
|
);
|
|
requireThat(
|
|
copy.complete.some(
|
|
(entry: any) =>
|
|
entry.id === "collector" &&
|
|
entry.manifestDigest === declarations[1].digest,
|
|
),
|
|
"CACHE_COLLECTOR_HANDOVER_INVALID",
|
|
);
|
|
const images = [];
|
|
for (const item of declarations) {
|
|
const source = await inspect(item.source);
|
|
requireThat(
|
|
source.Id === item.digest &&
|
|
source.Os === "linux" &&
|
|
source.Architecture === "amd64" &&
|
|
source.RootFS.Layers.length === item.layers &&
|
|
source.RepoDigests.some((d: string) => d.endsWith("@" + item.digest)),
|
|
"CACHE_IMAGE_IDENTITY_INVALID",
|
|
);
|
|
const existing = await run(["docker", "image", "inspect", item.target], {
|
|
allowFailure: true,
|
|
});
|
|
if (existing.code === 0)
|
|
requireThat(
|
|
JSON.parse(existing.out)[0].Id === item.digest,
|
|
"CACHE_OWN_ALIAS_CONFLICT",
|
|
);
|
|
else if (apply)
|
|
await run(["docker", "image", "tag", source.Id, item.target]);
|
|
if (apply)
|
|
requireThat(
|
|
(await inspect(item.target)).Id === item.digest,
|
|
"CACHE_OWN_ALIAS_POSTGUARD_FAILED",
|
|
);
|
|
images.push({
|
|
...item,
|
|
image_id: source.Id,
|
|
platform: "linux/amd64",
|
|
normalized_docker_identity: true,
|
|
upstream_config_digest_not_assumed: true,
|
|
});
|
|
}
|
|
requireThat(
|
|
(await verifyBackendHandover()).sha256 === lease.sha256,
|
|
"CACHE_BACKEND_GENERATION_CHANGED",
|
|
);
|
|
if (apply) {
|
|
const target = resolve(root, "evidence/openobserve/image-freeze.json");
|
|
await mkdir(resolve(target, ".."), { recursive: true });
|
|
const bytes =
|
|
JSON.stringify(
|
|
{
|
|
checkedAt: new Date().toISOString(),
|
|
source_receipts: receipts.map(({ path, sha256 }) => ({
|
|
path,
|
|
sha256,
|
|
})),
|
|
images,
|
|
no_network_pulls: true,
|
|
source_cache_mutated: false,
|
|
backend_handover_sha256: lease.sha256,
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n";
|
|
await writeFile(target, bytes, { flag: "wx", mode: 0o600 });
|
|
}
|
|
console.log(
|
|
apply
|
|
? "PASS_OWN_CACHED_ALIASES_FROZEN_NO_PULL"
|
|
: "PASS_READONLY_CACHE_LEASE_AND_PLATFORM",
|
|
);
|
|
}
|
|
if (import.meta.main) {
|
|
try {
|
|
requireThat(
|
|
["--check", "--apply"].includes(Bun.argv[2]),
|
|
"CACHE_ACTION_CHECK_OR_APPLY_REQUIRED",
|
|
);
|
|
await freezeCachedImages(Bun.argv[2] === "--apply");
|
|
} catch (error) {
|
|
safeFailure(error);
|
|
}
|
|
}
|