Files
mtusi2026lab7/scripts/openobserve-cache.ts

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);
}
}