Sync public tree to 17dcc0b

scripts/cli-error-exit-smoke.js

@@ -2,11 +2,14 @@
 
 const assert = require("assert");
 const cp = require("child_process");
+const fs = require("fs");
 const net = require("net");
+const os = require("os");
 const path = require("path");
 
 const repo = path.resolve(__dirname, "..");
 const project = path.join(repo, "examples/launch-build-demo");
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "disasmer-cli-error-"));
 
 function runDisasmer(args) {
   return new Promise((resolve) => {
@@ -56,6 +59,37 @@ async function runWithOneCoordinatorResponse(buildArgs, response) {
 }
 
 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 runDisasmer([
+    "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("disasmer inspect")
+  );
+  assert.strictEqual(environmentReport.diagnostics[0].code, "missing_environment");
+
   const nonInteractive = await runDisasmer([
     "run",
     "build",
@@ -141,6 +175,106 @@ async function main() {
     report.run_start.machine_error.next_actions.includes("disasmer 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("disasmer logs")
+  );
+
   const artifactDownload = await runWithOneCoordinatorResponse(
     (coordinator) => [
       "artifact",