@travetto/runtime 7.1.1 → 7.1.2

package/README.md

@@ -108,11 +108,6 @@ interface EnvData {
      * @default 2s
      */
     TRV_SHUTDOWN_WAIT: TimeSpan | number;
-    /** 
-     * The time to wait for stdout to drain during shutdown
-     * @default 0s
-     */
-    TRV_SHUTDOWN_STDOUT_WAIT: TimeSpan | number;
     /**
      * The desired runtime module 
      */
@@ -353,7 +348,7 @@ As a registered shutdown handler, you can do.
 import { ShutdownManager } from '@travetto/runtime';
 
 export function registerShutdownHandler() {
-  ShutdownManager.onGracefulShutdown(async () => {
+  ShutdownManager.signal.addEventListener('abort', () => {
     // Do important work, the framework will wait until all async
     //   operations are completed before finishing shutdown
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.1.1",
+  "version": "7.1.2",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,12 +26,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.1.0",
+    "@travetto/manifest": "^7.1.1",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.1.0"
+    "@travetto/transformer": "^7.1.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/shutdown.ts

@@ -1,99 +1,110 @@
+import type { ChildProcess } from 'node:child_process';
+
 import { Env } from './env.ts';
 import { Util } from './util.ts';
 import { TimeUtil } from './time.ts';
 
+const MAPPING = [['restart', 200], ['error', 1], ['quit', 0]] as const;
+export type ShutdownReason = typeof MAPPING[number][0];
+
+const REASON_TO_CODE = new Map<ShutdownReason, number>(MAPPING);
+const CODE_TO_REASON = new Map<number, ShutdownReason>(MAPPING.map(([k, v]) => [v, k]));
+
 type Handler = (event: Event) => unknown;
+type ShutdownSignal = 'SIGINT' | 'SIGTERM' | 'SIGUSR2' | string | undefined;
+type ShutdownEvent = { signal?: ShutdownSignal, reason?: ShutdownReason | number, exit?: boolean };
+
+const isShutdownEvent = (event: unknown): event is ShutdownEvent =>
+  typeof event === 'object' && event !== null && 'type' in event && event.type === 'shutdown';
+
+const wrapped = async (handler: Handler): Promise<void> => {
+  try {
+    await handler(new Event('abort'));
+  } catch (err) {
+    console.error('Error during shutdown handler', err);
+  }
+};
 
 /**
  * Shutdown manager, allowing for listening for graceful shutdowns
  */
 export class ShutdownManager {
-
   static #shouldIgnoreInterrupt = false;
-  static #registered = new Map<Handler, Handler>();
-  static #pending: Function[] = [];
+  static #registered = new Set<Handler>();
   static #controller = new AbortController();
-  static #startedAt: number = 0;
-  static #addListener = this.#controller.signal.addEventListener.bind(this.#controller.signal);
-  static #removeListener = this.#controller.signal.removeEventListener.bind(this.#controller.signal);
 
   static {
-    this.#controller.signal.addEventListener = (type: 'abort', listener: Handler): void => this.onGracefulShutdown(listener);
-    this.#controller.signal.removeEventListener = (type: 'abort', listener: Handler): void => {
-      this.#removeListener(type, this.#registered.get(listener) ?? listener);
-    };
+    this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => { this.#registered.add(listener); };
+    this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => { this.#registered.delete(listener); };
+    process
+      .on('message', event => { isShutdownEvent(event) && this.shutdown(event); })
+      .on('SIGINT', () => this.shutdown({ signal: 'SIGINT' }))
+      .on('SIGUSR2', () => this.shutdown({ signal: 'SIGUSR2' }))
+      .on('SIGTERM', () => this.shutdown({ signal: 'SIGTERM' }));
   }
 
   static get signal(): AbortSignal {
     return this.#controller.signal;
   }
 
-  static disableInterrupt(): void {
+  /** Disable SIGINT interrupt handling */
+  static disableInterrupt(): typeof ShutdownManager {
     this.#shouldIgnoreInterrupt = true;
+    return this;
   }
 
-  static onGracefulShutdown(listener: Handler): void {
-    if (!this.#registered.size) {
-      process
-        .on('SIGINT', () => this.shutdown('SIGINT')) // Ensure we get a newline on ctrl-c
-        .on('SIGUSR2', () => this.shutdown('SIGUSR2'))
-        .on('SIGTERM', () => this.shutdown('SIGTERM'));
-    }
+  /** Convert exit code to a reason string  */
+  static reasonForExitCode(code: number): ShutdownReason {
+    return CODE_TO_REASON.get(code) ?? 'error';
+  }
 
-    const wrappedListener: Handler = event => { this.#pending.push(() => listener(event)); };
-    this.#registered.set(listener, wrappedListener);
-    return this.#addListener('abort', wrappedListener);
+  /** Trigger a watch signal signal to a subprocess */
+  static async shutdownChild(subprocess: ChildProcess, config?: ShutdownEvent): Promise<void> {
+    subprocess?.send!({ type: 'shutdown', ...config });
   }
 
   /**
    * Shutdown the application gracefully
    */
-  static async shutdown(source?: string, code?: number): Promise<void> {
-    if (this.#shouldIgnoreInterrupt && source === 'SIGINT') {
+  static async shutdown(event?: ShutdownEvent): Promise<void> {
+    if ((event?.signal === 'SIGINT' && this.#shouldIgnoreInterrupt) || this.#controller.signal.aborted) {
       return;
     }
-    if (this.#controller.signal.aborted) {
-      if (this.#startedAt && (Date.now() - this.#startedAt) > 500) {
-        console.warn('Shutdown already in progress, exiting immediately', { source });
-        process.exit(0); // Quit immediately
-      } else {
-        return;
-      }
-    }
 
-    if (process.stdout.isTTY && source === 'SIGINT') {
+    process // Allow shutdown if anything is still listening
+      .removeAllListeners('message')
+      .removeAllListeners('SIGINT')
+      .removeAllListeners('SIGTERM')
+      .removeAllListeners('SIGUSR2');
+
+    if (event?.signal === 'SIGINT' && process.stdout.isTTY) {
       process.stdout.write('\n');
     }
 
-    process.removeAllListeners('message'); // Allow shutdown if anything is still listening
-
-    const context = source ? [{ source, pid: process.pid }] : [{ pid: process.pid }];
-    this.#startedAt = Date.now();
-    this.#controller.abort('Shutdown started');
-    await Util.queueMacroTask(); // Force the event loop to wait one cycle
-
-    console.debug('Shutdown started', ...context, { pending: this.#pending.length });
+    if (event?.reason !== undefined) {
+      const { reason } = event;
+      process.exitCode = (typeof reason === 'string' ? REASON_TO_CODE.get(reason) : reason);
+    }
 
     const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.value) ?? 2000;
-    const timeoutTasks = Util.nonBlockingTimeout(timeout).then(() => this);
-    const allPendingTasks = Promise.all(this.#pending.map(fn => Promise.resolve(fn()).catch(err => {
-      console.error('Error during shutdown task', err, ...context);
-    })));
+    const context = { ...event, pid: process.pid, timeout, pending: this.#registered.size };
 
-    const winner = await Promise.race([timeoutTasks, allPendingTasks]);
+    this.#controller.abort('Shutdown started');
+    console.debug('Shutdown started', context);
 
-    process.exitCode = code ?? process.exitCode ?? 0;
+    const winner = await Promise.race([
+      Util.nonBlockingTimeout(timeout).then(() => this),
+      Promise.all([...this.#registered].map(wrapped))
+    ]);
 
     if (winner !== this) {
-      console.debug('Shutdown completed', ...context);
+      console.debug('Shutdown completed', context);
     } else {
-      console.warn('Shutdown timed out', ...context);
-      process.exit(1); // Indicate error on timeout
+      console.warn('Shutdown timed out', context);
     }
 
-    if (Env.TRV_SHUTDOWN_STDOUT_WAIT.isSet) {
-      const stdoutDrain = TimeUtil.fromValue(Env.TRV_SHUTDOWN_STDOUT_WAIT.value)!;
-      await Util.blockingTimeout(stdoutDrain);
+    if (event?.exit) {
+      process.exit();
     }
   }
 }

package/src/trv.d.ts

@@ -31,11 +31,6 @@ declare module "@travetto/runtime" {
      * @default 2s
      */
     TRV_SHUTDOWN_WAIT: TimeSpan | number;
-    /** 
-     * The time to wait for stdout to drain during shutdown
-     * @default 0s
-     */
-    TRV_SHUTDOWN_STDOUT_WAIT: TimeSpan | number;
     /**
      * The desired runtime module 
      */

package/src/watch.ts

@@ -1,18 +1,16 @@
-import type { ChildProcess } from 'node:child_process';
-
 import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler';
 
 import { AppError } from './error.ts';
 import { Util } from './util.ts';
 import { RuntimeIndex } from './manifest-index.ts';
-import { ShutdownManager } from './shutdown.ts';
+import { ShutdownManager, type ShutdownReason } from './shutdown.ts';
 import { castTo } from './types.ts';
 
 type RetryRunState = {
   iteration: number;
   startTime: number;
   errorIterations: number;
-  result?: 'error' | 'restart' | 'stop';
+  result?: ShutdownReason;
 };
 
 type RetryRunConfig = {
@@ -27,34 +25,6 @@ type RetryRunConfig = {
  */
 export class WatchUtil {
 
-  static #RESTART_EXIT_CODE = 200;
-
-  /** Convert exit code to a result type  */
-  static exitCodeToResult(code: number): RetryRunState['result'] {
-    return code === this.#RESTART_EXIT_CODE ? 'restart' : (code !== null && code > 0) ? 'error' : 'stop';
-  }
-
-  /** Exit with a restart exit code */
-  static exitWithRestart(): void {
-    ShutdownManager.shutdown('SIGTERM', this.#RESTART_EXIT_CODE);
-  }
-
-  /** Listen for restart signals */
-  static listenForSignals(): void {
-    ShutdownManager.disableInterrupt();
-    process.on('message', event => {
-      switch (event) {
-        case 'WATCH_RESTART': this.exitWithRestart(); break;
-        case 'WATCH_SHUTDOWN': ShutdownManager.shutdown('SIGTERM', 0); break;
-      }
-    });
-  }
-
-  /** Trigger a watch signal signal to a subprocess */
-  static triggerSignal(subprocess: ChildProcess, signal: 'WATCH_RESTART' | 'WATCH_SHUTDOWN'): void {
-    subprocess.connected && subprocess.send?.(signal);
-  }
-
   /** Compute the delay before restarting */
   static computeRestartDelay(state: RetryRunState, config: RetryRunConfig): number {
     return state.result === 'error'
@@ -65,7 +35,7 @@ export class WatchUtil {
   /**
    * Run with restart capability
    */
-  static async runWithRetry(run: (state: RetryRunState & { signal: AbortSignal }) => Promise<RetryRunState['result']>, options?: Partial<RetryRunConfig>): Promise<void> {
+  static async runWithRetry(run: (state: RetryRunState & { signal: AbortSignal }) => Promise<ShutdownReason>, options?: Partial<RetryRunConfig>): Promise<void> {
     let retryExhausted = false;
 
     const state: RetryRunState = {
@@ -89,7 +59,7 @@ export class WatchUtil {
 
       state.result = await run({ ...state, signal: ShutdownManager.signal }).catch(() => 'error' as const);
       switch (state.result) {
-        case 'stop': break outer;
+        case 'quit': break outer;
         case 'error': state.errorIterations += 1; break;
         case 'restart': {
           state.startTime = Date.now();
@@ -114,7 +84,12 @@ export class WatchUtil {
     options?: Partial<RetryRunConfig>,
   ): Promise<void> {
     const { CompilerClient } = await import('@travetto/compiler/src/server/client.ts');
-    const client = new CompilerClient(RuntimeIndex.manifest, console);
+    const client = new CompilerClient(RuntimeIndex.manifest, {
+      debug: (...args: unknown[]): void => console.debug(...args),
+      info: (...args: unknown[]): void => console.info(...args),
+      warn: (...args: unknown[]): void => console.warn(...args),
+      error: (...args: unknown[]): void => console.error(...args),
+    });
 
     return this.runWithRetry(async ({ signal }) => {
       await client.waitForState(['compile-end', 'watch-start'], undefined, signal);