clusterflux-public/scripts/cli-error-exit-smoke.js

#!/usr/bin/env node

const assert = require("assert");
const cp = require("child_process");
const fs = require("fs");
const http = require("http");
const os = require("os");
const path = require("path");

const repo = path.resolve(__dirname, "..");
const project = path.join(repo, "tests/fixtures/runtime-conformance");
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "clusterflux-cli-error-"));

function runClusterflux(args) {
  return new Promise((resolve) => {
    const child = cp.spawn(
      "cargo",
      ["run", "-q", "-p", "clusterflux-cli", "--bin", "clusterflux", "--", ...args],
      {
        cwd: repo,
        stdio: ["ignore", "pipe", "pipe"],
      }
    );
    let stdout = "";
    let stderr = "";
    child.stdout.setEncoding("utf8");
    child.stderr.setEncoding("utf8");
    child.stdout.on("data", (chunk) => {
      stdout += chunk;
    });
    child.stderr.on("data", (chunk) => {
      stderr += chunk;
    });
    child.on("close", (code, signal) => {
      resolve({ code, signal, stdout, stderr });
    });
  });
}

async function runWithOneCoordinatorResponse(buildArgs, response) {
  let request = "";
  const server = http.createServer((incoming, outgoing) => {
    incoming.setEncoding("utf8");
    incoming.on("data", (chunk) => {
      request += chunk;
    });
    incoming.on("end", () => {
      outgoing.writeHead(200, { "content-type": "application/json" });
      outgoing.end(JSON.stringify(response));
      server.close();
    });
  });

  const address = await new Promise((resolve) => {
    server.listen(0, "127.0.0.1", () => resolve(server.address()));
  });
  const coordinator = `http://${address.address}:${address.port}`;
  const result = await runClusterflux(buildArgs(coordinator));
  return { request, result };
}

async function main() {
  const environmentProject = path.join(tempRoot, "missing-env-project");
  fs.mkdirSync(path.join(environmentProject, "src"), { recursive: true });
  fs.writeFileSync(
    path.join(environmentProject, "Cargo.toml"),
    "[package]\nname = \"missing-env-project\"\nversion = \"0.1.0\"\nedition = \"2021\"\n"
  );
  fs.writeFileSync(
    path.join(environmentProject, "src", "main.rs"),
    "fn main() { let _target = env!(\"linux\"); }\n"
  );
  const environmentFailure = await runClusterflux([
    "build",
    "--project",
    environmentProject,
    "--json",
  ]);
  assert.strictEqual(environmentFailure.signal, null, environmentFailure.stderr);
  assert.strictEqual(environmentFailure.code, 26, environmentFailure.stderr);
  const environmentReport = JSON.parse(environmentFailure.stdout);
  assert.strictEqual(environmentReport.status, "blocked_before_schedule");
  assert.strictEqual(environmentReport.scheduled_work, false);
  assert.strictEqual(environmentReport.machine_error.category, "environment");
  assert.strictEqual(
    environmentReport.machine_error.process_exit_code_applied,
    true
  );
  assert(
    environmentReport.machine_error.next_actions.includes("clusterflux inspect")
  );
  assert.strictEqual(environmentReport.diagnostics[0].code, "missing_environment");

  const nonInteractive = await runClusterflux([
    "run",
    "build",
    "--project",
    project,
    "--non-interactive",
    "--json",
  ]);
  assert.strictEqual(nonInteractive.signal, null, nonInteractive.stderr);
  assert.strictEqual(nonInteractive.code, 20, nonInteractive.stderr);
  assert.doesNotMatch(nonInteractive.stderr, /Opening Clusterflux browser login/);
  const nonInteractiveReport = JSON.parse(nonInteractive.stdout);
  assert.strictEqual(nonInteractiveReport.status, "authentication_required");
  assert.strictEqual(nonInteractiveReport.non_interactive, true);
  assert.strictEqual(nonInteractiveReport.browser_opened, false);
  assert.strictEqual(nonInteractiveReport.machine_error.category, "authentication");
  assert.strictEqual(nonInteractiveReport.machine_error.stable_exit_code, 20);
  assert.strictEqual(
    nonInteractiveReport.machine_error.process_exit_code_applied,
    true
  );
  assert(
    nonInteractiveReport.machine_error.next_actions.includes(
      "pass --local to run against local services"
    )
  );

  let request = "";
  const server = http.createServer((incoming, outgoing) => {
    incoming.setEncoding("utf8");
    incoming.on("data", (chunk) => {
      request += chunk;
    });
    incoming.on("end", () => {
      outgoing.writeHead(200, { "content-type": "application/json" });
      outgoing.end(
        JSON.stringify({
          type: "error",
          message: "quota unavailable: resource limit exceeded for api_calls",
        })
      );
      server.close();
    });
  });

  const address = await new Promise((resolve) => {
    server.listen(0, "127.0.0.1", () => resolve(server.address()));
  });
  const coordinator = `http://${address.address}:${address.port}`;

  const result = await runClusterflux([
    "run",
    "build",
    "--project",
    project,
    "--coordinator",
    coordinator,
    "--json",
  ]);

  assert.strictEqual(result.signal, null, result.stderr);
  assert.strictEqual(result.code, 22, result.stderr);
  assert.match(request, /"type":"start_process"/);
  const report = JSON.parse(result.stdout);
  assert.strictEqual(report.status, "coordinator_rejected");
  assert.strictEqual(report.run_start.machine_error.category, "quota");
  assert.strictEqual(report.run_start.machine_error.resource_category, "api_calls");
  assert.strictEqual(report.run_start.machine_error.community_tier_language, true);
  assert.strictEqual(
    report.run_start.machine_error.community_tier_label,
    "community tier"
  );
  assert.doesNotMatch(result.stdout, new RegExp(["free", "tier"].join(" "), "i"));
  assert.strictEqual(
    report.run_start.machine_error.private_abuse_heuristics_exposed,
    false
  );
  assert.strictEqual(report.run_start.machine_error.stable_exit_code, 22);
  assert.strictEqual(
    report.run_start.machine_error.process_exit_code_applied,
    true
  );
  assert(
    report.run_start.machine_error.next_actions.includes("clusterflux quota status")
  );

  const capabilityFailure = await runWithOneCoordinatorResponse(
    (coordinator) => [
      "run",
      "build",
      "--project",
      project,
      "--coordinator",
      coordinator,
      "--json",
    ],
    {
      type: "error",
      message:
        "scheduler placement failed: no capable node for placement: missing capability Command",
    }
  );
  assert.strictEqual(capabilityFailure.result.signal, null, capabilityFailure.result.stderr);
  assert.strictEqual(capabilityFailure.result.code, 24, capabilityFailure.result.stderr);
  assert.match(capabilityFailure.request, /"type":"start_process"/);
  const capabilityReport = JSON.parse(capabilityFailure.result.stdout);
  assert.strictEqual(
    capabilityReport.run_start.machine_error.category,
    "capability"
  );
  assert.strictEqual(
    capabilityReport.run_start.machine_error.process_exit_code_applied,
    true
  );
  assert(
    capabilityReport.run_start.machine_error.next_actions.includes(
      "attach a node with the required capabilities"
    )
  );

  const nodePolicyFailure = await runWithOneCoordinatorResponse(
    (coordinator) => [
      "run",
      "build",
      "--project",
      project,
      "--coordinator",
      coordinator,
      "--json",
    ],
    {
      type: "error",
      message: "node policy denied native command execution",
    }
  );
  assert.strictEqual(nodePolicyFailure.result.signal, null, nodePolicyFailure.result.stderr);
  assert.strictEqual(nodePolicyFailure.result.code, 23, nodePolicyFailure.result.stderr);
  assert.match(nodePolicyFailure.request, /"type":"start_process"/);
  const nodePolicyReport = JSON.parse(nodePolicyFailure.result.stdout);
  assert.strictEqual(
    nodePolicyReport.run_start.machine_error.category,
    "policy"
  );
  assert.strictEqual(
    nodePolicyReport.run_start.machine_error.process_exit_code_applied,
    true
  );
  assert(
    nodePolicyReport.run_start.machine_error.next_actions.includes(
      "check coordinator policy for this action"
    )
  );

  const programFailure = await runWithOneCoordinatorResponse(
    (coordinator) => [
      "task",
      "list",
      "--coordinator",
      coordinator,
      "--json",
    ],
    {
      type: "task_events",
      events: [
        {
          process: "vp-current",
          task: "compile",
          terminal_state: "failed",
          environment: "linux",
          node: "node-linux",
          status_code: 1,
          stderr_tail: "task exited with status 1",
        },
      ],
    }
  );
  assert.strictEqual(programFailure.result.signal, null, programFailure.result.stderr);
  assert.strictEqual(programFailure.result.code, 0, programFailure.result.stderr);
  assert.match(programFailure.request, /"type":"list_task_events"/);
  const programReport = JSON.parse(programFailure.result.stdout);
  assert.strictEqual(programReport.tasks[0].machine_error.category, "program");
  assert.strictEqual(programReport.tasks[0].machine_error.stable_exit_code, 27);
  assert(
    programReport.tasks[0].machine_error.next_actions.includes("clusterflux logs")
  );

  const artifactDownload = await runWithOneCoordinatorResponse(
    (coordinator) => [
      "artifact",
      "download",
      "app.txt",
      "--coordinator",
      coordinator,
      "--json",
    ],
    {
      type: "artifact_download_denied",
      message: "artifact download unauthorized for project",
    }
  );
  assert.strictEqual(artifactDownload.result.signal, null, artifactDownload.result.stderr);
  assert.strictEqual(artifactDownload.result.code, 21, artifactDownload.result.stderr);
  assert.match(artifactDownload.request, /"type":"create_artifact_download_link"/);
  const artifactDownloadReport = JSON.parse(artifactDownload.result.stdout);
  assert.strictEqual(
    artifactDownloadReport.download_session.machine_error.category,
    "authorization"
  );
  assert.strictEqual(
    artifactDownloadReport.download_session.machine_error.process_exit_code_applied,
    true
  );

  const artifactExport = await runWithOneCoordinatorResponse(
    (coordinator) => [
      "artifact",
      "export",
      "app.txt",
      "--to",
      path.join(project, "target", "blocked-artifact.txt"),
      "--coordinator",
      coordinator,
      "--json",
    ],
    {
      type: "artifact_export_unavailable",
      message: "direct connectivity unavailable for artifact export",
    }
  );
  assert.strictEqual(artifactExport.result.signal, null, artifactExport.result.stderr);
  assert.strictEqual(artifactExport.result.code, 25, artifactExport.result.stderr);
  assert.match(artifactExport.request, /"type":"export_artifact_to_node"/);
  const artifactExportReport = JSON.parse(artifactExport.result.stdout);
  assert.strictEqual(
    artifactExportReport.export_plan.machine_error.category,
    "connectivity"
  );
  assert.strictEqual(
    artifactExportReport.export_plan.machine_error.process_exit_code_applied,
    true
  );

  const confirmation = await runClusterflux([
    "process",
    "cancel",
    "--coordinator",
    "127.0.0.1:9",
    "--json",
  ]);
  assert.strictEqual(confirmation.signal, null, confirmation.stderr);
  assert.strictEqual(confirmation.code, 23, confirmation.stderr);
  const confirmationReport = JSON.parse(confirmation.stdout);
  assert.strictEqual(confirmationReport.status, "confirmation_required");
  assert.strictEqual(confirmationReport.coordinator_request_sent, false);
  assert.strictEqual(confirmationReport.machine_error.category, "policy");
  assert.strictEqual(
    confirmationReport.machine_error.process_exit_code_applied,
    true
  );
  assert(
    confirmationReport.next_actions.some((action) => action.includes("--yes"))
  );
}

main()
  .then(() => {
    console.log("CLI error exit smoke passed");
  })
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });