Merge pull request #1032 from thefrontside/tm/no-sigterm-windows-v4

Author: taras

.gitattributes

@@ -0,0 +1,20 @@
+# Set default line ending behavior
+* text=auto
+
+# Explicitly set line endings for text files
+*.ts text eol=lf
+*.mjs text eol=lf
+*.js text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+
+# Binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.woff binary
+*.woff2 binary

.github/workflows/verify.yaml

@@ -10,8 +10,11 @@ permissions:
   contents: read
 
 jobs:
-  test-deno:
-    runs-on: ubuntu-latest
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
 
     steps:
       - name: checkout
@@ -28,7 +31,13 @@ jobs:
       - name: lint
         run: deno lint
 
-      - name: test
+      - name: test (Windows)
+        if: runner.os == 'Windows'
+        run: deno task test
+        shell: cmd
+
+      - name: test (Unix)
+        if: runner.os != 'Windows'
         run: deno task test
 
   test-node:

Changelog.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 4.0.0-alpha.9
+
+- Do not bind SIGTERM in Windows for v4
+  https://github.com/thefrontside/effection/pull/1032
+
 ## 4.0.0-alpha.8
 
 - Add `until()` operation for turning promises into operations

deno.json

@@ -5,15 +5,15 @@
   "publish": { "include": ["lib", "mod.ts", "README.md"] },
   "lock": false,
   "tasks": {
-    "test": "deno test --allow-run=deno --allow-read --allow-env",
+    "test": "deno test --allow-run --allow-read --allow-env --allow-ffi",
     "test:node": "deno run -A tasks/built-test.ts",
     "build:npm": "deno run -A tasks/build-npm.ts",
     "bench": "deno run -A tasks/bench.ts",
     "build:jsr": "deno run -A tasks/build-jsr.ts"
   },
   "lint": {
     "rules": { "exclude": ["prefer-const", "require-yield"] },
-    "exclude": ["build", "www"]
+    "exclude": ["build", "www", "docs", "tasks"]
   },
   "fmt": { "exclude": ["build", "www", "CODE_OF_CONDUCT.md", "README.md"] },
   "test": { "exclude": ["build"] },
@@ -22,7 +22,8 @@
     "@std/testing": "jsr:@std/testing@1",
     "ts-expect": "npm:[email protected]",
     "@std/expect": "jsr:@std/expect@1",
-    "tinyexec": "npm:[email protected]"
+    "ctrlc-windows": "npm:[email protected]",
+    "tinyexec": "npm:[email protected]"
   },
-  "version": "4.0.0-alpha.8"
+  "version": "4.0.0-alpha.9"
 }

lib/main.ts

@@ -88,11 +88,18 @@ export async function main(
             hardexit = (status) => Deno.exit(status);
             try {
               Deno.addSignalListener("SIGINT", interrupt.SIGINT);
-              Deno.addSignalListener("SIGTERM", interrupt.SIGTERM);
+              /**
+               * Windows only supports ctrl-c (SIGINT), ctrl-break (SIGBREAK), and ctrl-close (SIGUP)
+               */
+              if (Deno.build.os !== "windows") {
+                Deno.addSignalListener("SIGTERM", interrupt.SIGTERM);
+              }
               yield* body(Deno.args.slice());
             } finally {
               Deno.removeSignalListener("SIGINT", interrupt.SIGINT);
-              Deno.removeSignalListener("SIGTERM", interrupt.SIGTERM);
+              if (Deno.build.os !== "windows") {
+                Deno.removeSignalListener("SIGTERM", interrupt.SIGTERM);
+              }
             }
           },
           *node() {
@@ -104,11 +111,15 @@ export async function main(
             hardexit = (status) => process.exit(status);
             try {
               process.on("SIGINT", interrupt.SIGINT);
-              process.on("SIGTERM", interrupt.SIGTERM);
+              if (process.platform !== "win32") {
+                process.on("SIGTERM", interrupt.SIGTERM);
+              }
               yield* body(process.argv.slice(2));
             } finally {
               process.off("SIGINT", interrupt.SIGINT);
-              process.off("SIGTERM", interrupt.SIGINT);
+              if (process.platform !== "win32") {
+                process.off("SIGTERM", interrupt.SIGINT);
+              }
             }
           },
           *browser() {

tasks/built-test.ts

@@ -7,19 +7,17 @@ await emptyDir(outDir);
 const entryPoints = [
   "./lib/mod.ts",
 ];
-for await (const entry of Deno.readDir("test")) {
-  if (entry.isFile) {
-    entryPoints.push(`./test/${entry.name}`);
-  }
-}
 
 await build({
   entryPoints,
   outDir,
   shims: {
     deno: true,
   },
+  test: true,
   typeCheck: false,
+  scriptModule: false,
+  esModule: true,
   compilerOptions: {
     lib: ["ESNext", "DOM"],
     target: "ES2020",

test/main.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, x } from "./suite.ts";
 import { each, run, type Stream } from "../mod.ts";
 
-function* until(stream: Stream<string, void>, text: string) {
+function* detect(stream: Stream<string, void>, text: string) {
   for (const line of yield* each(stream)) {
     if (line.includes(text)) {
       return;
@@ -15,7 +15,7 @@ describe("main", () => {
     await run(function* () {
       let proc = yield* x("deno", ["run", "test/main/ok.daemon.ts"]);
 
-      yield* until(proc.lines, "started");
+      yield* detect(proc.lines, "started");
 
       const { exitCode, stdout } = yield* proc.kill("SIGINT");
 
@@ -25,34 +25,36 @@ describe("main", () => {
     });
   });
 
-  it("gracefully shuts down on SIGTERM", async () => {
-    await run(function* () {
-      let proc = yield* x("deno", ["run", "test/main/ok.daemon.ts"]);
+  if (Deno.build.os !== "windows") {
+    it("gracefully shuts down on SIGTERM", async () => {
+      await run(function* () {
+        let proc = yield* x("deno", ["run", "test/main/ok.daemon.ts"]);
 
-      yield* until(proc.lines, "started");
+        yield* detect(proc.lines, "started");
 
-      const { exitCode, stdout } = yield* proc.kill("SIGTERM");
+        const { exitCode, stdout } = yield* proc.kill("SIGTERM");
 
-      expect(stdout).toContain("gracefully stopped");
+        expect(stdout).toContain("gracefully stopped");
 
-      expect(exitCode).toBe(143);
+        expect(exitCode).toBe(143);
+      });
     });
-  });
+  }
 
   it("exits gracefully on explicit exit()", async () => {
     await run(function* () {
       let proc = yield* x("deno", ["run", "test/main/ok.exit.ts"]);
 
-      yield* until(proc.lines, "goodbye.");
-      yield* until(proc.lines, "Ok, computer.");
+      yield* detect(proc.lines, "goodbye.");
+      yield* detect(proc.lines, "Ok, computer.");
     });
   });
 
   it("exits gracefully with 0 on implicit exit", async () => {
     await run(function* () {
       let proc = yield* x("deno", ["run", "test/main/ok.implicit.ts"]);
 
-      yield* until(proc.lines, "goodbye.");
+      yield* detect(proc.lines, "goodbye.");
 
       const { exitCode } = yield* proc;
 
@@ -88,7 +90,7 @@ describe("main", () => {
     await run(function* () {
       let proc = yield* x("deno", ["run", "test/main/just.suspend.ts"]);
 
-      yield* until(proc.lines, "started");
+      yield* detect(proc.lines, "started");
 
       const { exitCode, stdout } = yield* proc.kill("SIGINT");
 

test/suite.ts

@@ -1,10 +1,12 @@
-export { expect } from "@std/expect";
+import { expect } from "@std/expect";
+import { ctrlc } from "ctrlc-windows";
+import { type KillSignal, type Options, type Output, x as $x } from "tinyexec";
 export { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
 export { expectType } from "ts-expect";
-import { type KillSignal, type Options, type Output, x as $x } from "tinyexec";
+export { expect };
 
 import type { Operation, Stream } from "../lib/types.ts";
-import { call, resource, sleep, spawn, stream } from "../mod.ts";
+import { resource, sleep, spawn, stream, until } from "../mod.ts";
 
 export function* createNumber(value: number): Operation<number> {
   yield* sleep(1);
@@ -54,6 +56,21 @@ export function* syncResolve(value: string): Operation<string> {
 export function* syncReject(value: string): Operation<string> {
   throw new Error(`boom: ${value}`);
 }
+export interface TinyProcess extends Operation<Output> {
+  /**
+   * A stream of lines coming from both stdin and stdout. The stream
+   * will terminate when stdout and stderr are closed which usually
+   * corresponds to the process ending.
+   */
+  lines: Stream<string, void>;
+
+  /**
+   * Send `signal` to this process
+   * @param signal - the OS signal to send to the process
+   * @returns void
+   */
+  kill(signal?: KillSignal): Operation<Output>;
+}
 
 export interface TinyProcess extends Operation<Output> {
   /**
@@ -81,7 +98,7 @@ export function x(
 
     let promise: Promise<Output> = tinyexec as unknown as Promise<Output>;
 
-    let output = call(() => promise);
+    let output = until(promise);
 
     let tinyproc: TinyProcess = {
       *[Symbol.iterator]() {
@@ -90,6 +107,11 @@ export function x(
       lines: stream(tinyexec),
       *kill(signal) {
         tinyexec.kill(signal);
+        if (
+          Deno.build.os === "windows" && signal === "SIGINT" && tinyexec.pid
+        ) {
+          ctrlc(tinyexec.pid);
+        }
         return yield* output;
       },
     };