convert process to resource

Author: cowboyd

process/src/exec/posix.ts

@@ -4,6 +4,7 @@ import {
   createSignal,
   Err,
   Ok,
+  resource,
   type Result,
   spawn,
   withResolvers,
@@ -16,78 +17,107 @@ import { ExecError } from "./error.ts";
 
 type ProcessResultValue = [number?, string?];
 
-export const createPosixProcess: CreateOSProcess = function* createPosixProcess(
+export const createPosixProcess: CreateOSProcess = (
   command,
   options,
-) {
-  let processResult = withResolvers<Result<ProcessResultValue>>();
+) => {
+  return resource(function* (provide) {
+    let processResult = withResolvers<Result<ProcessResultValue>>();
 
-  // Killing all child processes started by this command is surprisingly
-  // tricky. If a process spawns another processes and we kill the parent,
-  // then the child process is NOT automatically killed. Instead we're using
-  // the `detached` option to force the child into its own process group,
-  // which all of its children in turn will inherit. By sending the signal to
-  // `-pid` rather than `pid`, we are sending it to the entire process group
-  // instead. This will send the signal to all processes started by the child
-  // process.
-  //
-  // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
-  let childProcess = spawnProcess(command, options.arguments || [], {
-    detached: true,
-    shell: options.shell,
-    env: options.env,
-    cwd: options.cwd,
-    stdio: "pipe",
-  });
+    // Killing all child processes started by this command is surprisingly
+    // tricky. If a process spawns another processes and we kill the parent,
+    // then the child process is NOT automatically killed. Instead we're using
+    // the `detached` option to force the child into its own process group,
+    // which all of its children in turn will inherit. By sending the signal to
+    // `-pid` rather than `pid`, we are sending it to the entire process group
+    // instead. This will send the signal to all processes started by the child
+    // process.
+    //
+    // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
+    let childProcess = spawnProcess(command, options.arguments || [], {
+      detached: true,
+      shell: options.shell,
+      env: options.env,
+      cwd: options.cwd,
+      stdio: "pipe",
+    });
 
-  let { pid } = childProcess;
+    let { pid } = childProcess;
 
-  let io = {
-    stdout: yield* useReadable(childProcess.stdout),
-    stderr: yield* useReadable(childProcess.stderr),
-    stdoutDone: withResolvers<void>(),
-    stderrDone: withResolvers<void>(),
-  };
+    let io = {
+      stdout: yield* useReadable(childProcess.stdout),
+      stderr: yield* useReadable(childProcess.stderr),
+      stdoutDone: withResolvers<void>(),
+      stderrDone: withResolvers<void>(),
+    };
 
-  let stdout = createSignal<Uint8Array, void>();
-  let stderr = createSignal<Uint8Array, void>();
+    let stdout = createSignal<Uint8Array, void>();
+    let stderr = createSignal<Uint8Array, void>();
 
-  yield* spawn(function* () {
-    let next = yield* io.stdout.next();
-    while (!next.done) {
-      stdout.send(next.value);
-      next = yield* io.stdout.next();
-    }
-    stdout.close();
-    io.stdoutDone.resolve();
-  });
+    yield* spawn(function* () {
+      let next = yield* io.stdout.next();
+      while (!next.done) {
+        stdout.send(next.value);
+        next = yield* io.stdout.next();
+      }
+      stdout.close();
+      io.stdoutDone.resolve();
+    });
 
-  yield* spawn(function* () {
-    let next = yield* io.stderr.next();
-    while (!next.done) {
-      stderr.send(next.value);
-      next = yield* io.stderr.next();
-    }
-    stderr.close();
-    io.stderrDone.resolve();
-  });
+    yield* spawn(function* () {
+      let next = yield* io.stderr.next();
+      while (!next.done) {
+        stderr.send(next.value);
+        next = yield* io.stderr.next();
+      }
+      stderr.close();
+      io.stderrDone.resolve();
+    });
 
-  yield* spawn(function* trapError() {
-    let [error] = yield* once<[Error]>(childProcess, "error");
-    processResult.resolve(Err(error));
-  });
+    let stdin: Writable<string> = {
+      send(data: string) {
+        childProcess.stdin.write(data);
+      },
+    };
 
-  let stdin: Writable<string> = {
-    send(data: string) {
-      childProcess.stdin.write(data);
-    },
-  };
+    yield* spawn(function* trapError() {
+      let [error] = yield* once<[Error]>(childProcess, "error");
+      processResult.resolve(Err(error));
+    });
 
-  yield* spawn(function* () {
-    try {
+    yield* spawn(function* () {
       let value = yield* once<ProcessResultValue>(childProcess, "close");
-      // yield* all([io.stdoutDone.operation, io.stderrDone.operation]);
       processResult.resolve(Ok(value));
+    });
+
+    function* join() {
+      let result = yield* processResult.operation;
+      if (result.ok) {
+        let [code, signal] = result.value;
+        return { command, options, code, signal } as ExitStatus;
+      } else {
+        throw result.error;
+      }
+    }
+
+    function* expect() {
+      let status: ExitStatus = yield* join();
+      if (status.code != 0) {
+        throw new ExecError(status, command, options);
+      } else {
+        return status;
+      }
+    }
+
+    try {
+      yield* provide({
+        pid: pid as number,
+        stdin,
+        stdout,
+        stderr,
+        join,
+        expect,
+      });
     } finally {
       try {
         if (typeof childProcess.pid === "undefined") {
@@ -101,33 +131,4 @@ export const createPosixProcess: CreateOSProcess = function* createPosixProcess(
       }
     }
   });
-
-  function* join() {
-    let result = yield* processResult.operation;
-    if (result.ok) {
-      let [code, signal] = result.value;
-      return { command, options, code, signal } as ExitStatus;
-    } else {
-      throw result.error;
-    }
-  }
-
-  function* expect() {
-    let status: ExitStatus = yield* join();
-    if (status.code != 0) {
-      throw new ExecError(status, command, options);
-    } else {
-      return status;
-    }
-  }
-
-  // FYI: this function starts a process and returns without blocking
-  return {
-    pid: pid as number,
-    stdin,
-    stdout,
-    stderr,
-    join,
-    expect,
-  };
 };