Merge pull request #7752 from sagemathinc/api-exec-await-project

extract project/backend aspects of api-exec-await

Author: williamstein

src/packages/backend/execute-code.test.ts

@@ -4,6 +4,8 @@
  */
 
 process.env.COCALC_PROJECT_MONITOR_INTERVAL_S = "1";
+// default is much lower, might fail if you have more procs than the default
+process.env.COCALC_PROJECT_INFO_PROC_LIMIT = "10000";
 
 import { executeCode } from "./execute-code";
 
@@ -300,6 +302,147 @@ describe("async", () => {
   );
 });
 
+// the await case is essentially like the async case above, but it will block for a bit
+describe("await", () => {
+  const check = (s) => {
+    expect(s.type).toEqual("async");
+    if (s.type !== "async") return;
+    expect(s.status).toEqual("completed");
+    expect(s.elapsed_s).toBeGreaterThan(1);
+    expect(s.elapsed_s).toBeLessThan(3);
+    expect(s.exit_code).toBe(0);
+    expect(s.pid).toBeGreaterThan(1);
+    expect(s.stdout).toEqual("foo\n");
+    expect(s.stderr).toEqual("");
+  };
+
+  it("returns when a job finishes", async () => {
+    const c = await executeCode({
+      command: "sleep 2; echo 'foo'",
+      bash: true,
+      err_on_exit: false,
+      async_call: true,
+    });
+    expect(c.type).toEqual("async");
+    if (c.type !== "async") return;
+    const { status, job_id, pid } = c;
+    expect(status).toEqual("running");
+    expect(pid).toBeGreaterThan(1);
+    const t0 = Date.now();
+    const s = await executeCode({
+      async_await: true,
+      async_get: job_id,
+      async_stats: true,
+    });
+    const t1 = Date.now();
+    // This is the main test: it really waited for at least a second until the job completed
+    expect((t1 - t0) / 1000).toBeGreaterThan(1);
+    check(s);
+    if (s.type !== "async") return;
+    expect(Array.isArray(s.stats)).toBeTruthy();
+  });
+
+  it("returns immediately if already done", async () => {
+    const c = await executeCode({
+      command: "sleep 1.1; echo 'foo'",
+      bash: true,
+      err_on_exit: false,
+      async_call: true,
+    });
+    expect(c.type).toEqual("async");
+    if (c.type !== "async") return;
+    const { status, job_id, pid } = c;
+    expect(status).toEqual("running");
+    expect(pid).toBeGreaterThan(1);
+    await new Promise((done) => setTimeout(done, 2000));
+    const s = await executeCode({
+      async_await: true,
+      async_get: job_id,
+      async_stats: true,
+    });
+    check(s);
+    if (s.type !== "async") return;
+    expect(s.elapsed_s).toBeLessThan(1.5);
+  });
+
+  it("deal with unknown executables", async () => {
+    const c = await executeCode({
+      command: "random123unknown99",
+      err_on_exit: false,
+      async_call: true,
+    });
+    expect(c.type).toEqual("async");
+    if (c.type !== "async") return;
+    const { job_id, pid } = c;
+    expect(pid).toBeUndefined();
+    const s = await executeCode({
+      async_await: true,
+      async_get: job_id,
+      async_stats: true,
+    });
+    expect(s.type).toEqual("async");
+    if (s.type !== "async") return;
+    expect(s.exit_code).toBe(1);
+    expect(s.stderr).toContain("ENOENT");
+    expect(s.status).toBe("error");
+  });
+
+  it("returns an error", async () => {
+    const c = await executeCode({
+      command: "sleep .1; >&2 echo baz; exit 3",
+      bash: true,
+      err_on_exit: false,
+      async_call: true,
+    });
+    expect(c.type).toEqual("async");
+    if (c.type !== "async") return;
+    const { status, job_id, pid } = c;
+    expect(status).toEqual("running");
+    expect(pid).toBeGreaterThan(1);
+    const t0 = Date.now();
+    const s = await executeCode({
+      async_await: true,
+      async_get: job_id,
+      async_stats: true,
+    });
+    expect((Date.now() - t0) / 1000).toBeGreaterThan(0.05);
+    expect(s.type).toEqual("async");
+    if (s.type !== "async") return;
+    expect(s.stderr).toEqual("baz\n");
+    expect(s.exit_code).toEqual(3);
+    expect(s.status).toEqual("completed");
+  });
+
+  it("react to a killed process", async () => {
+    const c = await executeCode({
+      command: "sh",
+      args: ["-c", `echo foo; sleep 1; echo bar;`],
+      bash: false,
+      err_on_exit: false,
+      async_call: true,
+    });
+    expect(c.type).toEqual("async");
+    if (c.type !== "async") return;
+    const { job_id, pid } = c;
+    await new Promise((done) => setTimeout(done, 100));
+    await executeCode({
+      command: `kill -9 -${pid}`,
+      bash: true,
+    });
+    const s = await executeCode({
+      async_await: true,
+      async_get: job_id,
+      async_stats: true,
+    });
+    expect(s.type).toEqual("async");
+    if (s.type !== "async") return;
+    expect(s.stderr).toEqual("");
+    expect(s.stdout).toEqual("foo\n");
+    expect(s.exit_code).toEqual(0);
+    expect(s.status).toEqual("completed");
+  });
+});
+
 // we burn a bit of CPU to get the cpu_pct and cpu_secs up
 const CPU_PY = `
 from time import time