@open-mercato/queue 0.4.6-main-be1825c150 → 0.4.6

package/dist/worker/runner.js

@@ -1,4 +1,45 @@
 import { createQueue } from "../factory.js";
+const managedQueues = /* @__PURE__ */ new Set();
+let shutdownHandlersRegistered = false;
+let shutdownInProgress = false;
+function unregisterShutdownHandlers(sigtermHandler, sigintHandler) {
+  process.off("SIGTERM", sigtermHandler);
+  process.off("SIGINT", sigintHandler);
+  shutdownHandlersRegistered = false;
+}
+function registerShutdownHandlers() {
+  if (shutdownHandlersRegistered) return;
+  const shutdown = async (signal) => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    console.log(`[worker] Received ${signal}, shutting down gracefully...`);
+    let hasError = false;
+    for (const queue of managedQueues) {
+      try {
+        await queue.close();
+      } catch (error) {
+        hasError = true;
+        console.error("[worker] Error during shutdown:", error);
+      }
+    }
+    managedQueues.clear();
+    unregisterShutdownHandlers(sigtermHandler, sigintHandler);
+    shutdownInProgress = false;
+    if (!hasError) {
+      console.log("[worker] Worker closed successfully");
+    }
+    process.exit(hasError ? 1 : 0);
+  };
+  const sigtermHandler = () => {
+    void shutdown("SIGTERM");
+  };
+  const sigintHandler = () => {
+    void shutdown("SIGINT");
+  };
+  process.on("SIGTERM", sigtermHandler);
+  process.on("SIGINT", sigintHandler);
+  shutdownHandlersRegistered = true;
+}
 async function runWorker(options) {
   const {
     queueName,
@@ -16,19 +57,8 @@ async function runWorker(options) {
     concurrency
   });
   if (gracefulShutdown) {
-    const shutdown = async (signal) => {
-      console.log(`[worker] Received ${signal}, shutting down gracefully...`);
-      try {
-        await queue.close();
-        console.log("[worker] Worker closed successfully");
-        process.exit(0);
-      } catch (error) {
-        console.error("[worker] Error during shutdown:", error);
-        process.exit(1);
-      }
-    };
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-    process.on("SIGINT", () => shutdown("SIGINT"));
+    managedQueues.add(queue);
+    registerShutdownHandlers();
   }
   await queue.process(handler);
   console.log(`[worker] Worker running with concurrency ${concurrency}`);

package/dist/worker/runner.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/worker/runner.ts"],
-  "sourcesContent": ["import { createQueue } from '../factory'\nimport type { JobHandler, AsyncQueueOptions, QueueStrategyType } from '../types'\n\n/**\n * Options for running a queue worker.\n */\nexport type WorkerRunnerOptions<T = unknown> = {\n  /** Name of the queue to process */\n  queueName: string\n  /** Handler function to process each job */\n  handler: JobHandler<T>\n  /** Redis connection options (only used for async strategy) */\n  connection?: AsyncQueueOptions['connection']\n  /** Number of concurrent jobs to process */\n  concurrency?: number\n  /** Whether to set up graceful shutdown handlers */\n  gracefulShutdown?: boolean\n  /** If true, don't block - return immediately after starting processing (for multi-queue mode) */\n  background?: boolean\n  /** Queue strategy to use. Defaults to QUEUE_STRATEGY env var or 'local' */\n  strategy?: QueueStrategyType\n}\n\n/**\n * Runs a queue worker that processes jobs continuously.\n *\n * This function:\n * 1. Creates an async queue instance\n * 2. Starts a BullMQ worker\n * 3. Sets up graceful shutdown on SIGTERM/SIGINT\n * 4. Keeps the process running until shutdown\n *\n * @template T - The job payload type\n * @param options - Worker configuration\n *\n * @example\n * ```typescript\n * import { runWorker } from '@open-mercato/queue/worker'\n *\n * await runWorker({\n *   queueName: 'events',\n *   handler: async (job, ctx) => {\n *     console.log(`Processing ${ctx.jobId}:`, job.payload)\n *   },\n *   connection: { url: process.env.REDIS_URL },\n *   concurrency: 5,\n * })\n * ```\n */\nexport async function runWorker<T = unknown>(\n  options: WorkerRunnerOptions<T>\n): Promise<void> {\n  const {\n    queueName,\n    handler,\n    connection,\n    concurrency = 1,\n    gracefulShutdown = true,\n    background = false,\n    strategy: strategyOption,\n  } = options\n\n  // Determine queue strategy from option, env var, or default to 'local'\n  const strategy: QueueStrategyType = strategyOption\n    ?? (process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local')\n\n  console.log(`[worker] Starting worker for queue \"${queueName}\" (strategy: ${strategy})...`)\n\n  const queue = createQueue<T>(queueName, strategy, {\n    connection,\n    concurrency,\n  })\n\n  // Set up graceful shutdown\n  if (gracefulShutdown) {\n    const shutdown = async (signal: string) => {\n      console.log(`[worker] Received ${signal}, shutting down gracefully...`)\n      try {\n        await queue.close()\n        console.log('[worker] Worker closed successfully')\n        process.exit(0)\n      } catch (error) {\n        console.error('[worker] Error during shutdown:', error)\n        process.exit(1)\n      }\n    }\n\n    process.on('SIGTERM', () => shutdown('SIGTERM'))\n    process.on('SIGINT', () => shutdown('SIGINT'))\n  }\n\n  // Start processing\n  await queue.process(handler)\n\n  console.log(`[worker] Worker running with concurrency ${concurrency}`)\n\n  if (background) {\n    // Return immediately for multi-queue mode\n    return\n  }\n\n  console.log('[worker] Press Ctrl+C to stop')\n\n  // Keep the process alive (single-queue mode)\n  await new Promise(() => {\n    // This promise never resolves, keeping the worker running\n  })\n}\n\n/**\n * Creates a worker handler that routes jobs to specific handlers based on job type.\n *\n * @template T - Base job payload type (must include a 'type' field)\n * @param handlers - Map of job types to their handlers\n *\n * @example\n * ```typescript\n * const handler = createRoutedHandler({\n *   'user.created': async (job) => { ... },\n *   'order.placed': async (job) => { ... },\n * })\n *\n * await runWorker({ queueName: 'events', handler })\n * ```\n */\nexport function createRoutedHandler<T extends { type: string }>(\n  handlers: Record<string, JobHandler<T>>\n): JobHandler<T> {\n  return async (job, ctx) => {\n    const type = job.payload.type\n    const handler = handlers[type]\n\n    if (!handler) {\n      console.warn(`[worker] No handler registered for job type \"${type}\"`)\n      return\n    }\n\n    await handler(job, ctx)\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,mBAAmB;AAiD5B,eAAsB,UACpB,SACe;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,mBAAmB;AAAA,IACnB,aAAa;AAAA,IACb,UAAU;AAAA,EACZ,IAAI;AAGJ,QAAM,WAA8B,mBAC9B,QAAQ,IAAI,mBAAmB,UAAU,UAAU;AAEzD,UAAQ,IAAI,uCAAuC,SAAS,gBAAgB,QAAQ,MAAM;AAE1F,QAAM,QAAQ,YAAe,WAAW,UAAU;AAAA,IAChD;AAAA,IACA;AAAA,EACF,CAAC;AAGD,MAAI,kBAAkB;AACpB,UAAM,WAAW,OAAO,WAAmB;AACzC,cAAQ,IAAI,qBAAqB,MAAM,+BAA+B;AACtE,UAAI;AACF,cAAM,MAAM,MAAM;AAClB,gBAAQ,IAAI,qCAAqC;AACjD,gBAAQ,KAAK,CAAC;AAAA,MAChB,SAAS,OAAO;AACd,gBAAQ,MAAM,mCAAmC,KAAK;AACtD,gBAAQ,KAAK,CAAC;AAAA,MAChB;AAAA,IACF;AAEA,YAAQ,GAAG,WAAW,MAAM,SAAS,SAAS,CAAC;AAC/C,YAAQ,GAAG,UAAU,MAAM,SAAS,QAAQ,CAAC;AAAA,EAC/C;AAGA,QAAM,MAAM,QAAQ,OAAO;AAE3B,UAAQ,IAAI,4CAA4C,WAAW,EAAE;AAErE,MAAI,YAAY;AAEd;AAAA,EACF;AAEA,UAAQ,IAAI,+BAA+B;AAG3C,QAAM,IAAI,QAAQ,MAAM;AAAA,EAExB,CAAC;AACH;AAkBO,SAAS,oBACd,UACe;AACf,SAAO,OAAO,KAAK,QAAQ;AACzB,UAAM,OAAO,IAAI,QAAQ;AACzB,UAAM,UAAU,SAAS,IAAI;AAE7B,QAAI,CAAC,SAAS;AACZ,cAAQ,KAAK,gDAAgD,IAAI,GAAG;AACpE;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG;AAAA,EACxB;AACF;",
+  "sourcesContent": ["import { createQueue } from '../factory'\nimport type { Queue, JobHandler, AsyncQueueOptions, QueueStrategyType } from '../types'\n\n/**\n * Options for running a queue worker.\n */\nexport type WorkerRunnerOptions<T = unknown> = {\n  /** Name of the queue to process */\n  queueName: string\n  /** Handler function to process each job */\n  handler: JobHandler<T>\n  /** Redis connection options (only used for async strategy) */\n  connection?: AsyncQueueOptions['connection']\n  /** Number of concurrent jobs to process */\n  concurrency?: number\n  /** Whether to set up graceful shutdown handlers */\n  gracefulShutdown?: boolean\n  /** If true, don't block - return immediately after starting processing (for multi-queue mode) */\n  background?: boolean\n  /** Queue strategy to use. Defaults to QUEUE_STRATEGY env var or 'local' */\n  strategy?: QueueStrategyType\n}\n\nconst managedQueues = new Set<Queue<unknown>>()\nlet shutdownHandlersRegistered = false\nlet shutdownInProgress = false\n\nfunction unregisterShutdownHandlers(sigtermHandler: () => void, sigintHandler: () => void): void {\n  process.off('SIGTERM', sigtermHandler)\n  process.off('SIGINT', sigintHandler)\n  shutdownHandlersRegistered = false\n}\n\nfunction registerShutdownHandlers(): void {\n  if (shutdownHandlersRegistered) return\n\n  const shutdown = async (signal: string) => {\n    if (shutdownInProgress) return\n    shutdownInProgress = true\n\n    console.log(`[worker] Received ${signal}, shutting down gracefully...`)\n\n    let hasError = false\n    for (const queue of managedQueues) {\n      try {\n        await queue.close()\n      } catch (error) {\n        hasError = true\n        console.error('[worker] Error during shutdown:', error)\n      }\n    }\n\n    managedQueues.clear()\n    unregisterShutdownHandlers(sigtermHandler, sigintHandler)\n    shutdownInProgress = false\n\n    if (!hasError) {\n      console.log('[worker] Worker closed successfully')\n    }\n\n    process.exit(hasError ? 1 : 0)\n  }\n\n  const sigtermHandler = () => {\n    void shutdown('SIGTERM')\n  }\n\n  const sigintHandler = () => {\n    void shutdown('SIGINT')\n  }\n\n  process.on('SIGTERM', sigtermHandler)\n  process.on('SIGINT', sigintHandler)\n  shutdownHandlersRegistered = true\n}\n\n/**\n * Runs a queue worker that processes jobs continuously.\n *\n * This function:\n * 1. Creates an async queue instance\n * 2. Starts a BullMQ worker\n * 3. Sets up graceful shutdown on SIGTERM/SIGINT\n * 4. Keeps the process running until shutdown\n *\n * @template T - The job payload type\n * @param options - Worker configuration\n *\n * @example\n * ```typescript\n * import { runWorker } from '@open-mercato/queue/worker'\n *\n * await runWorker({\n *   queueName: 'events',\n *   handler: async (job, ctx) => {\n *     console.log(`Processing ${ctx.jobId}:`, job.payload)\n *   },\n *   connection: { url: process.env.REDIS_URL },\n *   concurrency: 5,\n * })\n * ```\n */\nexport async function runWorker<T = unknown>(\n  options: WorkerRunnerOptions<T>\n): Promise<void> {\n  const {\n    queueName,\n    handler,\n    connection,\n    concurrency = 1,\n    gracefulShutdown = true,\n    background = false,\n    strategy: strategyOption,\n  } = options\n\n  // Determine queue strategy from option, env var, or default to 'local'\n  const strategy: QueueStrategyType = strategyOption\n    ?? (process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local')\n\n  console.log(`[worker] Starting worker for queue \"${queueName}\" (strategy: ${strategy})...`)\n\n  const queue = createQueue<T>(queueName, strategy, {\n    connection,\n    concurrency,\n  })\n\n  // Set up graceful shutdown\n  if (gracefulShutdown) {\n    managedQueues.add(queue as Queue<unknown>)\n    registerShutdownHandlers()\n  }\n\n  // Start processing\n  await queue.process(handler)\n\n  console.log(`[worker] Worker running with concurrency ${concurrency}`)\n\n  if (background) {\n    // Return immediately for multi-queue mode\n    return\n  }\n\n  console.log('[worker] Press Ctrl+C to stop')\n\n  // Keep the process alive (single-queue mode)\n  await new Promise(() => {\n    // This promise never resolves, keeping the worker running\n  })\n}\n\n/**\n * Creates a worker handler that routes jobs to specific handlers based on job type.\n *\n * @template T - Base job payload type (must include a 'type' field)\n * @param handlers - Map of job types to their handlers\n *\n * @example\n * ```typescript\n * const handler = createRoutedHandler({\n *   'user.created': async (job) => { ... },\n *   'order.placed': async (job) => { ... },\n * })\n *\n * await runWorker({ queueName: 'events', handler })\n * ```\n */\nexport function createRoutedHandler<T extends { type: string }>(\n  handlers: Record<string, JobHandler<T>>\n): JobHandler<T> {\n  return async (job, ctx) => {\n    const type = job.payload.type\n    const handler = handlers[type]\n\n    if (!handler) {\n      console.warn(`[worker] No handler registered for job type \"${type}\"`)\n      return\n    }\n\n    await handler(job, ctx)\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAuB5B,MAAM,gBAAgB,oBAAI,IAAoB;AAC9C,IAAI,6BAA6B;AACjC,IAAI,qBAAqB;AAEzB,SAAS,2BAA2B,gBAA4B,eAAiC;AAC/F,UAAQ,IAAI,WAAW,cAAc;AACrC,UAAQ,IAAI,UAAU,aAAa;AACnC,+BAA6B;AAC/B;AAEA,SAAS,2BAAiC;AACxC,MAAI,2BAA4B;AAEhC,QAAM,WAAW,OAAO,WAAmB;AACzC,QAAI,mBAAoB;AACxB,yBAAqB;AAErB,YAAQ,IAAI,qBAAqB,MAAM,+BAA+B;AAEtE,QAAI,WAAW;AACf,eAAW,SAAS,eAAe;AACjC,UAAI;AACF,cAAM,MAAM,MAAM;AAAA,MACpB,SAAS,OAAO;AACd,mBAAW;AACX,gBAAQ,MAAM,mCAAmC,KAAK;AAAA,MACxD;AAAA,IACF;AAEA,kBAAc,MAAM;AACpB,+BAA2B,gBAAgB,aAAa;AACxD,yBAAqB;AAErB,QAAI,CAAC,UAAU;AACb,cAAQ,IAAI,qCAAqC;AAAA,IACnD;AAEA,YAAQ,KAAK,WAAW,IAAI,CAAC;AAAA,EAC/B;AAEA,QAAM,iBAAiB,MAAM;AAC3B,SAAK,SAAS,SAAS;AAAA,EACzB;AAEA,QAAM,gBAAgB,MAAM;AAC1B,SAAK,SAAS,QAAQ;AAAA,EACxB;AAEA,UAAQ,GAAG,WAAW,cAAc;AACpC,UAAQ,GAAG,UAAU,aAAa;AAClC,+BAA6B;AAC/B;AA4BA,eAAsB,UACpB,SACe;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,mBAAmB;AAAA,IACnB,aAAa;AAAA,IACb,UAAU;AAAA,EACZ,IAAI;AAGJ,QAAM,WAA8B,mBAC9B,QAAQ,IAAI,mBAAmB,UAAU,UAAU;AAEzD,UAAQ,IAAI,uCAAuC,SAAS,gBAAgB,QAAQ,MAAM;AAE1F,QAAM,QAAQ,YAAe,WAAW,UAAU;AAAA,IAChD;AAAA,IACA;AAAA,EACF,CAAC;AAGD,MAAI,kBAAkB;AACpB,kBAAc,IAAI,KAAuB;AACzC,6BAAyB;AAAA,EAC3B;AAGA,QAAM,MAAM,QAAQ,OAAO;AAE3B,UAAQ,IAAI,4CAA4C,WAAW,EAAE;AAErE,MAAI,YAAY;AAEd;AAAA,EACF;AAEA,UAAQ,IAAI,+BAA+B;AAG3C,QAAM,IAAI,QAAQ,MAAM;AAAA,EAExB,CAAC;AACH;AAkBO,SAAS,oBACd,UACe;AACf,SAAO,OAAO,KAAK,QAAQ;AACzB,UAAM,OAAO,IAAI,QAAQ;AACzB,UAAM,UAAU,SAAS,IAAI;AAE7B,QAAI,CAAC,SAAS;AACZ,cAAQ,KAAK,gDAAgD,IAAI,GAAG;AACpE;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG;AAAA,EACxB;AACF;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/queue",
-  "version": "0.4.6-main-be1825c150",
+  "version": "0.4.6",
   "description": "Multi-strategy job queue with local and BullMQ support",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,6 +48,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "stableVersion": "0.4.5"
+  }
 }

package/src/worker/__tests__/runner.test.ts

@@ -0,0 +1,83 @@
+import { createQueue } from '../../factory'
+import type { Queue } from '../../types'
+import { runWorker } from '../runner'
+
+jest.mock('../../factory', () => ({
+  createQueue: jest.fn(),
+}))
+
+function buildFakeQueue(name: string): Queue<unknown> {
+  return {
+    name,
+    strategy: 'local',
+    enqueue: jest.fn(async () => 'job-id'),
+    process: jest.fn(async () => ({ processed: -1, failed: -1, lastJobId: undefined })),
+    clear: jest.fn(async () => ({ removed: 0 })),
+    close: jest.fn(async () => {}),
+    getJobCounts: jest.fn(async () => ({ waiting: 0, active: 0, completed: 0, failed: 0 })),
+  }
+}
+
+describe('runWorker', () => {
+  const createQueueMock = createQueue as jest.MockedFunction<typeof createQueue>
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('registers SIGINT/SIGTERM shutdown handlers only once and closes all queues', async () => {
+    const queueA = buildFakeQueue('queue-a')
+    const queueB = buildFakeQueue('queue-b')
+    createQueueMock.mockReturnValueOnce(queueA).mockReturnValueOnce(queueB)
+
+    const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => undefined) as never)
+    const initialSigtermListeners = process.listenerCount('SIGTERM')
+    const initialSigintListeners = process.listenerCount('SIGINT')
+
+    await runWorker({
+      queueName: 'queue-a',
+      handler: async () => {},
+      background: true,
+      gracefulShutdown: true,
+    })
+
+    await runWorker({
+      queueName: 'queue-b',
+      handler: async () => {},
+      background: true,
+      gracefulShutdown: true,
+    })
+
+    expect(process.listenerCount('SIGTERM')).toBe(initialSigtermListeners + 1)
+    expect(process.listenerCount('SIGINT')).toBe(initialSigintListeners + 1)
+
+    const sigtermHandler = process.listeners('SIGTERM')[initialSigtermListeners] as (() => void) | undefined
+    sigtermHandler?.()
+    await new Promise<void>((resolve) => setImmediate(resolve))
+
+    expect(queueA.close).toHaveBeenCalledTimes(1)
+    expect(queueB.close).toHaveBeenCalledTimes(1)
+    expect(exitSpy).toHaveBeenCalledWith(0)
+    expect(process.listenerCount('SIGTERM')).toBe(initialSigtermListeners)
+    expect(process.listenerCount('SIGINT')).toBe(initialSigintListeners)
+
+    exitSpy.mockRestore()
+  })
+
+  it('does not register shutdown handlers when gracefulShutdown is disabled', async () => {
+    createQueueMock.mockReturnValueOnce(buildFakeQueue('queue-c'))
+
+    const initialSigtermListeners = process.listenerCount('SIGTERM')
+    const initialSigintListeners = process.listenerCount('SIGINT')
+
+    await runWorker({
+      queueName: 'queue-c',
+      handler: async () => {},
+      background: true,
+      gracefulShutdown: false,
+    })
+
+    expect(process.listenerCount('SIGTERM')).toBe(initialSigtermListeners)
+    expect(process.listenerCount('SIGINT')).toBe(initialSigintListeners)
+  })
+})

package/src/worker/runner.ts

@@ -1,5 +1,5 @@
 import { createQueue } from '../factory'
-import type { JobHandler, AsyncQueueOptions, QueueStrategyType } from '../types'
+import type { Queue, JobHandler, AsyncQueueOptions, QueueStrategyType } from '../types'
 
 /**
  * Options for running a queue worker.
@@ -21,6 +21,59 @@ export type WorkerRunnerOptions<T = unknown> = {
   strategy?: QueueStrategyType
 }
 
+const managedQueues = new Set<Queue<unknown>>()
+let shutdownHandlersRegistered = false
+let shutdownInProgress = false
+
+function unregisterShutdownHandlers(sigtermHandler: () => void, sigintHandler: () => void): void {
+  process.off('SIGTERM', sigtermHandler)
+  process.off('SIGINT', sigintHandler)
+  shutdownHandlersRegistered = false
+}
+
+function registerShutdownHandlers(): void {
+  if (shutdownHandlersRegistered) return
+
+  const shutdown = async (signal: string) => {
+    if (shutdownInProgress) return
+    shutdownInProgress = true
+
+    console.log(`[worker] Received ${signal}, shutting down gracefully...`)
+
+    let hasError = false
+    for (const queue of managedQueues) {
+      try {
+        await queue.close()
+      } catch (error) {
+        hasError = true
+        console.error('[worker] Error during shutdown:', error)
+      }
+    }
+
+    managedQueues.clear()
+    unregisterShutdownHandlers(sigtermHandler, sigintHandler)
+    shutdownInProgress = false
+
+    if (!hasError) {
+      console.log('[worker] Worker closed successfully')
+    }
+
+    process.exit(hasError ? 1 : 0)
+  }
+
+  const sigtermHandler = () => {
+    void shutdown('SIGTERM')
+  }
+
+  const sigintHandler = () => {
+    void shutdown('SIGINT')
+  }
+
+  process.on('SIGTERM', sigtermHandler)
+  process.on('SIGINT', sigintHandler)
+  shutdownHandlersRegistered = true
+}
+
 /**
  * Runs a queue worker that processes jobs continuously.
  *
@@ -73,20 +126,8 @@ export async function runWorker<T = unknown>(
 
   // Set up graceful shutdown
   if (gracefulShutdown) {
-    const shutdown = async (signal: string) => {
-      console.log(`[worker] Received ${signal}, shutting down gracefully...`)
-      try {
-        await queue.close()
-        console.log('[worker] Worker closed successfully')
-        process.exit(0)
-      } catch (error) {
-        console.error('[worker] Error during shutdown:', error)
-        process.exit(1)
-      }
-    }
-
-    process.on('SIGTERM', () => shutdown('SIGTERM'))
-    process.on('SIGINT', () => shutdown('SIGINT'))
+    managedQueues.add(queue as Queue<unknown>)
+    registerShutdownHandlers()
   }
 
   // Start processing