@vercel/container 22.0.2 → 23.0.0

package/dist/buildah-store-command.js

@@ -0,0 +1,418 @@
+"use strict";
+
+// src/buildah-store-cache/command/operations.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+
+// src/util.ts
+var import_build_utils = require("@vercel/build-utils");
+var import_node_child_process = require("child_process");
+var import_promises = require("fs/promises");
+var DEBUG = Boolean((0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG"));
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(cmd, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: [opts.input !== void 0 ? "pipe" : "ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (!opts.quiet) {
+        process.stderr.write(text);
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (!opts.quiet) {
+        process.stderr.write(text);
+      }
+    });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        reject(
+          new Error(
+            `Command not found: \`${cmd}\`. Ensure \`${cmd}\` is installed and on your PATH.`
+          )
+        );
+        return;
+      }
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        const detail = stderr.trim().split("\n").slice(-5).join("\n");
+        const error = new Error(
+          `\`${cmd} ${args.join(" ")}\` exited with code ${code}` + (detail ? `
+${detail}` : "")
+        );
+        error.exitCode = code ?? void 0;
+        reject(error);
+      }
+    });
+    if (opts.input !== void 0) {
+      child.stdin?.end(opts.input);
+    }
+  });
+}
+async function lstatIfPresent(path) {
+  try {
+    return await (0, import_promises.lstat)(path);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+
+// src/buildah-store-cache/lock.ts
+var FileLock = class {
+  constructor(path) {
+    this.path = path;
+  }
+  shared(command) {
+    return this.wrap("--shared", command);
+  }
+  exclusive(command) {
+    return this.wrap("--exclusive", command);
+  }
+  wrap(mode, command) {
+    return ["flock", mode, "--close", this.path, ...command];
+  }
+};
+
+// src/buildah-store-cache/state.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var CLEANUP_CONTAINER_RE = /^vercel-cnb-[a-zA-Z0-9_.-]+$/;
+async function listStateRecords(directory, suffix) {
+  return (await (0, import_promises2.readdir)(directory)).filter((name) => !name.startsWith(".") && name.endsWith(suffix)).sort().map((name) => (0, import_node_path.join)(directory, name));
+}
+
+// src/buildah-store-cache/command/index.ts
+var import_node_path2 = require("path");
+var STORE_COMMAND_SCRIPT = (0, import_node_path2.join)(__dirname, "buildah-store-command.js");
+function storeCommand(request, script = STORE_COMMAND_SCRIPT) {
+  return [process.execPath, script, JSON.stringify(request)];
+}
+async function runStoreCommand(request, lock) {
+  const [command, ...args] = lock.exclusive(storeCommand(request));
+  const { stdout } = await run(command, args, { quiet: true });
+  return JSON.parse(stdout);
+}
+
+// src/buildah-store-cache/command/operations.ts
+var STAGED_BLOB_INFO_CACHE = ".vercel-blob-info-cache.sqlite";
+var RETAINED_REPOSITORY = "localhost/vercel-buildah-store";
+var StoreOperations = class {
+  async restore(options) {
+    if (await lstatIfPresent(options.marker)) {
+      await requireRegularFile(options.marker);
+      return { status: "skipped" };
+    }
+    await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(options.marker), { recursive: true });
+    await (0, import_promises3.writeFile)(options.marker, "", { flag: "wx", mode: 384 });
+    if (!await lstatIfPresent(options.archive)) {
+      return { status: "miss", reason: "no_compatible_snapshot" };
+    }
+    return runStoreCommand(
+      {
+        action: "extract",
+        options: {
+          graphRoot: options.graphRoot,
+          archive: options.archive,
+          blobInfoCache: options.blobInfoCache
+        }
+      },
+      new FileLock(options.storeLock)
+    );
+  }
+  async extract(options) {
+    const store = await lstatIfPresent(options.graphRoot);
+    if (store) {
+      await requireDirectory(options.graphRoot);
+      if ((await (0, import_promises3.readdir)(options.graphRoot)).length > 0) {
+        return { status: "warm" };
+      }
+    }
+    const archive = await requireRegularFile(options.archive);
+    await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(options.graphRoot), { recursive: true });
+    const staging = await (0, import_promises3.mkdtemp)(`${options.graphRoot}.restore.`);
+    try {
+      await run(
+        "tar",
+        [
+          "--extract",
+          "--zstd",
+          `--file=${options.archive}`,
+          `--directory=${staging}`,
+          "--numeric-owner",
+          "--same-owner",
+          "--same-permissions",
+          "--xattrs",
+          "--xattrs-include=*"
+        ],
+        { quiet: true }
+      );
+      if (store)
+        await (0, import_promises3.rmdir)(options.graphRoot);
+      await run("mv", ["-T", "--", staging, options.graphRoot], {
+        quiet: true
+      });
+      await this.restoreBlobInfoCache(
+        (0, import_node_path3.join)(options.graphRoot, STAGED_BLOB_INFO_CACHE),
+        options.blobInfoCache
+      );
+      return { status: "hit", bytes: archive.size };
+    } finally {
+      await (0, import_promises3.rm)(staging, { recursive: true, force: true });
+    }
+  }
+  async save(options) {
+    const result = (0, import_node_path3.join)(options.stateDirectory, "save-result");
+    if (await lstatIfPresent(result)) {
+      await requireRegularFile(result);
+      const previous = (await (0, import_promises3.readFile)(result, "utf8")).replace(/\n+$/, "") || "failed";
+      if (previous === "saved" || previous === "unused" || previous === "failed") {
+        return { status: "skipped", previous };
+      }
+      throw new Error("invalid Buildah store save result");
+    }
+    await (0, import_promises3.mkdir)(options.stateDirectory, { recursive: true });
+    await (0, import_promises3.writeFile)(result, "", { flag: "wx", mode: 384 });
+    const records = await listStateRecords(options.stateDirectory, ".images");
+    if (records.length === 0) {
+      await (0, import_promises3.writeFile)(result, "unused\n");
+      return { status: "unused" };
+    }
+    await this.finishPendingCleanup(options);
+    await requireDirectory(options.graphRoot);
+    await this.pruneImages(records, options.buildahArgs);
+    await this.stageBlobInfoCache(
+      options.blobInfoCache,
+      (0, import_node_path3.join)(options.graphRoot, STAGED_BLOB_INFO_CACHE)
+    );
+    await this.archiveStore(options);
+    await (0, import_promises3.writeFile)(result, "saved\n");
+    return { status: "saved" };
+  }
+  async cleanup(options) {
+    if (!await lstatIfPresent(options.record))
+      return;
+    await requireRegularFile(options.record);
+    await run("buildah", options.buildahArgs, { quiet: true });
+    await (0, import_promises3.unlink)(options.record);
+  }
+  async finishPendingCleanup(options) {
+    for (const record of await listStateRecords(
+      options.stateDirectory,
+      ".cleanup"
+    )) {
+      await requireRegularFile(record);
+      const container = (await (0, import_promises3.readFile)(record, "utf8")).replace(/\n+$/, "");
+      if (!CLEANUP_CONTAINER_RE.test(container)) {
+        throw new Error("invalid Buildah cleanup record");
+      }
+      await run("buildah", [...options.buildahArgs, "rm", container], {
+        quiet: true
+      });
+      await (0, import_promises3.unlink)(record);
+    }
+  }
+  async pruneImages(records, buildahArgs) {
+    const containers = await run(
+      "buildah",
+      [...buildahArgs, "containers", "--quiet"],
+      {
+        quiet: true
+      }
+    );
+    if (containers.stdout.replace(/\n+$/, "") !== "") {
+      throw new Error("Buildah containers are still active");
+    }
+    const listing = await run(
+      "buildah",
+      [...buildahArgs, "images", "--all", "--no-trunc", "--json"],
+      { quiet: true }
+    );
+    const images = JSON.parse(listing.stdout);
+    const names = /* @__PURE__ */ new Map();
+    for (const image of images) {
+      const id = image.id.replace(/^sha256:/, "");
+      if (!/^[a-f0-9]{64}$/.test(id)) {
+        throw new Error(`invalid Buildah image ID: ${id}`);
+      }
+      names.set(id, image.names ?? []);
+    }
+    const keep = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      await requireRegularFile(record);
+      const references = (await (0, import_promises3.readFile)(record, "utf8")).split("\n");
+      if (references.at(-1) === "")
+        references.pop();
+      if (references.length === 0) {
+        throw new Error("Buildah image usage is incomplete");
+      }
+      for (const line of references) {
+        const reference = line.trim();
+        if (!/^[a-f0-9]{12,64}$/.test(reference)) {
+          throw new Error("Buildah image usage is incomplete");
+        }
+        for (const id of names.keys()) {
+          if (id.startsWith(reference))
+            keep.add(id);
+        }
+      }
+    }
+    if (keep.size === 0)
+      throw new Error("no Buildah images retained");
+    const untag = [];
+    const obsolete = [];
+    for (const [id, references] of names) {
+      if (keep.has(id)) {
+        const tag = `${RETAINED_REPOSITORY}:${id}`;
+        await run("buildah", [...buildahArgs, "tag", id, tag], { quiet: true });
+        for (const name of references) {
+          if (!name.includes("@") && name !== tag)
+            untag.push(name);
+        }
+      } else {
+        obsolete.push(id);
+      }
+    }
+    if (untag.length > 0) {
+      await run("buildah", [...buildahArgs, "rmi", ...untag], { quiet: true });
+    }
+    if (obsolete.length > 0) {
+      await run("buildah", [...buildahArgs, "rmi", "--force", ...obsolete], {
+        quiet: true
+      });
+    }
+  }
+  async archiveStore(options) {
+    const temporary = `${options.archive}.${(0, import_node_crypto.randomUUID)()}`;
+    await (0, import_promises3.writeFile)(temporary, "", { flag: "wx", mode: 384 });
+    try {
+      await run(
+        "tar",
+        [
+          "--create",
+          `--use-compress-program=zstd -q -1 -T${options.threads}`,
+          `--file=${temporary}`,
+          `--directory=${options.graphRoot}`,
+          "--one-file-system",
+          "--sparse",
+          "--numeric-owner",
+          "--xattrs",
+          "--xattrs-include=*",
+          "--anchored",
+          "--no-wildcards-match-slash",
+          "--exclude=./overlay/*/merged",
+          "--exclude=./overlay/*/work/*",
+          "."
+        ],
+        { quiet: true }
+      );
+      await run("mv", ["-fT", "--", temporary, options.archive], {
+        quiet: true
+      });
+    } finally {
+      await (0, import_promises3.rm)(temporary, { force: true });
+    }
+  }
+  async restoreBlobInfoCache(staged, destination) {
+    try {
+      if (!(await lstatIfPresent(staged))?.isFile())
+        return;
+      if (await lstatIfPresent(destination))
+        return;
+    } catch {
+      return;
+    }
+    try {
+      await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(destination), { recursive: true });
+      await (0, import_promises3.copyFile)(staged, destination, import_node_fs.constants.COPYFILE_EXCL);
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        await (0, import_promises3.rm)(destination, { force: true }).catch(() => {
+        });
+      }
+    }
+  }
+  async stageBlobInfoCache(source, staged) {
+    try {
+      await (0, import_promises3.rm)(staged, { force: true });
+    } catch {
+      return;
+    }
+    try {
+      if (!(await lstatIfPresent(source))?.isFile())
+        return;
+      if (await (0, import_promises3.stat)(`${source}-journal`).catch(() => void 0))
+        return;
+      await (0, import_promises3.copyFile)(source, staged);
+    } catch {
+      await (0, import_promises3.rm)(staged, { force: true }).catch(() => {
+      });
+    }
+  }
+};
+async function requireRegularFile(path) {
+  const stats = await lstatIfPresent(path);
+  if (stats?.isSymbolicLink()) {
+    throw new Error(`file must not be a symlink: ${path}`);
+  }
+  if (!stats?.isFile())
+    throw new Error(`expected a regular file: ${path}`);
+  return stats;
+}
+async function requireDirectory(path) {
+  const stats = await lstatIfPresent(path);
+  if (stats?.isSymbolicLink()) {
+    throw new Error(`directory must not be a symlink: ${path}`);
+  }
+  if (!stats?.isDirectory())
+    throw new Error(`expected a directory: ${path}`);
+}
+
+// src/buildah-store-cache/command/main.ts
+async function main() {
+  const request = JSON.parse(process.argv[2]);
+  const operations = new StoreOperations();
+  let result;
+  switch (request.action) {
+    case "restore":
+      result = await operations.restore(request.options);
+      break;
+    case "extract":
+      result = await operations.extract(request.options);
+      break;
+    case "save":
+      result = await operations.save(request.options);
+      break;
+    case "cleanup":
+      await operations.cleanup(request.options);
+      result = null;
+      break;
+    default:
+      throw new Error("unknown Buildah store command");
+  }
+  process.stdout.write(`${JSON.stringify(result)}
+`);
+}
+void main().catch((error) => {
+  process.stderr.write(
+    `${error instanceof Error ? error.message : String(error)}
+`
+  );
+  const exitCode = error?.exitCode;
+  process.exitCode = typeof exitCode === "number" && Number.isInteger(exitCode) && exitCode >= 1 && exitCode <= 255 ? exitCode : 1;
+});