isotropic-cluster 0.3.0 → 0.5.0

package/README.md

@@ -1,6 +1,684 @@
 # isotropic-cluster
-A reusable and extendable platform to manage local process clusters.
 
+[![npm version](https://img.shields.io/npm/v/isotropic-cluster.svg)](https://www.npmjs.com/package/isotropic-cluster)
+[![License](https://img.shields.io/npm/l/isotropic-cluster.svg)](https://github.com/ibi-group/isotropic-cluster/blob/main/LICENSE)
 ![](https://img.shields.io/badge/tests-passing-brightgreen.svg)
 ![](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)
-![](https://img.shields.io/badge/license-BSD--3-blue.svg)
+
+A reusable and extendable platform to manage local Node.js process clusters with a clean API for primary/worker communication and lifecycle management.
+
+## Why Use This?
+
+- **Simple API for Cluster Management**: Manage worker processes with an intuitive, event-driven API
+- **Reliable Worker Lifecycle**: Automatic worker initialization and ready state management
+- **Robust Communication**: Structured, promise-based message passing between primary and workers
+- **Load Balancing**: Built-in round-robin worker selection with support for task-specific distribution
+- **Error Handling**: Comprehensive error propagation and worker replacement on failure
+- **Event Lifecycle**: Observable events for all worker lifecycle stages
+- **Type-based Routing**: Route messages to specific handler methods based on message type
+
+## Installation
+
+```bash
+npm install isotropic-cluster
+```
+
+## Basic Usage
+
+### Primary Process
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+import _later from 'isotropic-later';
+
+{
+    // Create a cluster primary
+    const primary = _ClusterPrimary();
+
+    // Listen for messages from workers
+    primary.on('workerMessage', ({
+        data: {
+            message,
+            worker
+        }
+    }) => {
+        console.log(`Received from worker ${worker.id}:`, message);
+    });
+
+    // Listen for worker lifecycle events
+    primary.on('workerReady', ({
+        data: {
+            worker
+        }
+    }) => {
+        console.log(`Worker ${worker.id} is ready to handle requests`);
+
+        // Send a message to the worker
+        primary.send({
+            message: {
+                name: 'User',
+                type: 'greet'
+            },
+            to: worker
+        });
+    });
+
+    // Start some workers
+    primary.fork({
+        workerCount: 4
+    });
+
+    // Later, shutdown the cluster
+    _later_(60000, () => {
+        primary.shutDown();
+    });
+}
+```
+
+### Worker Process
+
+```javascript
+import _ClusterWorker from 'isotropic-cluster/lib/cluster-worker.js';
+
+{
+    // Create a cluster worker
+    const worker = _ClusterWorker();
+
+    // Handle messages from primary
+    worker.on('primaryMessage', ({
+        data: {
+            message
+        }
+    }) => {
+        if (message.type === 'greet') {
+            console.log(`Hello, ${message.name}!`);
+
+            // Send a response back to primary
+            worker.send({
+                message: {
+                    content: `Greeted ${message.name}`,
+                    type: 'response'
+                }
+            });
+        }
+    });
+
+    // Handle primary disconnection
+    worker.on('primaryDisconnect', () => {
+        console.log('Primary disconnected, cleaning up...');
+        // Perform cleanup operations
+    });
+}
+```
+
+## Core Concepts
+
+### Cluster Architecture
+
+Node.js clusters consist of a primary process that manages multiple worker processes. The primary process:
+
+- Forks and monitors worker processes
+- Distributes work among workers
+- Handles worker failures and restarts
+
+Workers are separate processes that:
+- Handle specific tasks (like serving HTTP requests)
+- Report their status to the primary
+- Perform work assigned by the primary
+
+### Initialization Lifecycle
+
+1. **Creation**: Primary and worker objects are created
+2. **Initialization**: Internal setup occurs
+3. **Worker Readiness**: Workers signal readiness to the primary
+4. **Operation**: Normal operation with message passing
+5. **Shutdown**: Clean termination of worker processes
+
+### Event-Based Communication
+
+Both `ClusterPrimary` and `ClusterWorker` extend `isotropic-pubsub`, providing a complete event system:
+
+- Subscribe to events with `on()`, `before()`, and `after()`
+- Publish events with observable lifecycle phases
+- Type-based message routing for organized handlers
+
+## Examples
+
+### HTTP Server with Worker Processes
+
+```javascript
+// primary.js
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+import _os from 'node:os';
+import _process from 'node:process';
+
+{
+    const primary = _ClusterPrimary({
+        workerScript: 'worker.js'
+    });
+
+    // Log worker activity
+    primary.on({
+        workerExit: ({
+            data: {
+                code,
+                signal,
+                worker
+            }
+        }) => {
+            console.log(`Worker ${worker.id} exited with code ${code} and signal ${signal}`);
+        },
+        workerReady: ({
+            data: {
+                worker
+            }
+        }) => {
+            console.log(`Worker ${worker.id} is ready to handle connections`);
+        }
+    });
+
+    {
+        // Start workers based on CPU count
+        const cpuCount = _os.cpus().length;
+
+        console.log(`Starting ${cpuCount} workers`);
+
+        primary.fork({
+            workerCount: cpuCount
+        });
+    }
+
+    // Handle graceful shutdown
+    _process.on('SIGTERM', () => {
+        console.log('Shutting down server');
+
+        primary.shutDown();
+    });
+}
+
+// worker.js
+import _ClusterWorker from 'isotropic-cluster/lib/cluster-worker.js';
+import _http from 'node:http';
+
+{
+    const worker = _ClusterWorker();
+
+    // Create HTTP server
+    const server = _http.createServer((request, response) => {
+        ressponse.writeHead(200);
+        response.end(`Hello from worker ${_ClusterWorker.workerId}`);
+    });
+
+    // Start listening on port 3000
+    server.listen(3000, () => {
+        console.log(`Worker ${ClusterWorker.workerId} listening on port 3000`);
+    });
+
+    // Handle shutdown
+    worker.on('primaryDisconnect', () => {
+        console.log('Primary asked worker to disconnect, closing server');
+        server.close(() => {
+            process.exit(0);
+        });
+    });
+}
+```
+
+### Task Distribution with Round-Robin
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+
+{
+    const primary = _ClusterPrimary(),
+
+        // Queue of tasks to process
+        tasks = [{
+            data: '...',
+            id: 1
+        }, {
+            data: '...',
+            id: 2
+        }, {
+            data: '...',
+            id: 3
+        }, {
+            // ... more tasks
+        }],
+
+        processQueue = () => {
+            if (tasks.length) {
+                const task = tasks.shift(), // Get the next task
+                    worker = primary.roundRobin(); // Select a worker using round-robin
+
+                // Send the task to the worker
+                primary.send({
+                    message: {
+                        task,
+                        type: 'processTask'
+                    },
+                    to: worker
+                }).then(() => {
+                    console.log(`Task ${task.id} sent to worker ${worker.id}`);
+                }).catch(error => {
+                    console.error(`Failed to send task ${task.id}:`, error);
+
+                    // Put task back in queue
+                    tasks.unshift(task);
+                });
+            }
+        };
+
+    // Listen for worker readiness
+    primary.on('workerReady', () => {
+        // Start processing tasks when at least one worker is ready
+        processQueue();
+    });
+
+    // Handle task completion
+    primary.on('workerMessage', ({
+        data: {
+            message
+        }
+    }) => {
+        if (message.type === 'taskComplete') {
+            console.log(`Task ${message.taskId} completed with result:`, message.result);
+
+            // Process next task
+            processQueue();
+        }
+    });
+
+    // Start workers
+    primary.fork({
+        workerCount: 4
+    });
+}
+```
+
+### Specialized Task Distribution
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+
+{
+    const primary = _ClusterPrimary(),
+
+    // Different types of tasks
+        tasksByType = {
+            compute: [{
+                data: '...',
+                id: 'c1'
+            }, {
+                data: '...',
+                id: 'c2'
+            }],
+            io: [{
+                data: '...',
+                id: 'i1'
+            }, {
+                data: '...',
+                id: 'i2'
+            }],
+            lightweight: [{
+                data: '...',
+                id: 'l1'
+            }, {
+                data: '...',
+                id: 'l2'
+            }],
+
+        processQueue = queueType => {
+            const tasks = tasksByType[queueType];
+
+            if (tasks.length) {
+                const task = tasks.shift(), // Get the next task
+                    worker = primary.roundRobin({ // Select a worker using queue-specific round-robin
+                        tag: queueType
+                    });
+
+                // Send the task to the worker
+                primary.send({
+                    message: {
+                        task,
+                        type: 'processTask'
+                    },
+                    to: worker
+                }).then(() => {
+                    console.log(`Task ${task.id} sent to worker ${worker.id}`);
+                }).catch(error => {
+                    console.error(`Failed to send task ${task.id}:`, error);
+
+                    // Put task back in queue
+                    tasks.unshift(task);
+                });
+            }
+        };
+    };
+
+    // Listen for worker readiness
+    primary.on('workerReady', () => {
+        // Start processing tasks when at least one worker is ready
+        processQueue('compute');
+        processQueue('io');
+        processQueue('lightweight');
+    });
+
+    // Handle task completion
+    primary.on('workerMessage', ({
+        data: {
+            message
+        }
+    }) => {
+        if (message.type === 'taskComplete') {
+            console.log(`Task ${message.taskId} completed with result:`, message.result);
+
+            // Process next task
+            processQueue();
+        }
+    });
+
+    // Start workers
+    primary.fork({
+        workerCount: 6
+    });
+}
+```
+
+### Type-Based Message Routing
+
+Message passing between the primary process and a worker process is very common. When messages are coming from multiple places with different payloads and different contexts, it can be difficult to process with a single message event handler function. There is a built-in shortcut for handling messages of different types. It requires the message to be an object with a string property named `type`. When the ClusterPrimary instance receives a message from a worker with a type property, it will execute a method with the name `_eventWorkerMessage_${type}`. You don't have to subscribe to the `message` event. The ClusterPrimary instance just needs to have the correct methods defined. This can be done easily with `isotropic-make`.
+
+When a ClusterWorker instance receives a message from the primary with a type property, it will execute a method with the name `_eventPrimaryMessage_${type}`.
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+import _make from 'isotropic-make';
+
+// Extend ClusterPrimary with custom message handler methods
+const _AdvancedPrimary = _make(_ClusterPrimary, {
+    _eventWorkerMessage_log ({
+        data: {
+            message,
+            worker
+        }
+    }) {
+        // Handler for messages with type: 'log'
+        console.log(`[Worker ${worker.id} LOG] ${message.level}: ${message.text}`);
+    },
+    _eventWorkerMessage_metric({
+        data: {
+            message
+    } }) {
+        // Handler for messages with type: 'metric'
+        console.log(`METRIC: ${message.name} = ${message.value}`);
+
+        // Store in database, etc.
+        this._storeMetric({
+            name: message.name,
+            value: message.value
+        });
+    },
+    _eventWorkerMessage_requestHelp({
+        data: {
+            message,
+            worker
+        }
+    }) {
+        // Handler for messages with type: 'requestHelp'
+        console.log(`Worker ${worker.id} needs help with: ${message.problem}`);
+
+        // Send help back to the worker
+        this.send({
+            message: {
+                solution: this._getSolution(message.problem),
+                type: 'helpResponse'
+            },
+            to: worker
+        });
+    },
+    // Supporting methods
+    _getSolution (problem) {
+        // Return solution based on problem
+        return `Solution for ${problem}`;
+    },
+    _storeMetric ({
+        name,
+        value
+    }) {
+        // Store metric in database
+    }
+});
+
+{
+    const primary = _AdvancedPrimary();
+
+    primary.fork({
+        workerCount: 2
+    });
+}
+```
+
+## API Reference
+
+### ClusterPrimary
+
+#### Constructor
+
+```javascript
+const primary = _ClusterPrimary(options);
+```
+
+Options:
+- `workerArgs`: Array of arguments to pass to worker processes
+- `workerScript`: Path to worker script (defaults to current script)
+- `workerSilent`: Whether to suppress worker stdout/stderr
+- `workerStdio`: Configuration for worker stdio
+- `initialize`: Whether to automatically initialize (defaults to true)
+
+#### Methods
+
+- **destroy()**: Clean up and destroy the primary instance
+- **fork({ workerCount })**: Start new worker processes. `workerCount` is optional and defaults to `1`.
+- **roundRobin({ tag })**: Select a worker using round-robin distribution. The `tag` is optional. It returns the worker object that has been least recently selected for the given tag.
+- **send({ message, to })**: Send a message to one or more workers. `to` can be a worker object or a worker id. It can also be an array of either. Returns a promise.
+- **shutDown()**: Gracefully shut down all workers
+
+#### Properties
+
+- **workerById**: Object mapping worker ids to worker objects
+- **workers**: Array of all active worker objects
+
+#### Events
+
+- **destroy**: When destroy begins
+- **destroyComplete** When destroy completes
+- **initialize**: When initialization begins
+- **initializeComplete**: When initialization completes successfully
+- **initializeError**: When initialization fails
+- **shutDown**: When the cluster is shutting down
+- **shutDownComplete**: When all workers have been shut down
+- **workerDisconnect**: When a worker disconnects
+- **workerError**: When a worker encounters an error
+- **workerExit**: When a worker exits
+- **workerFork**: When a new worker is forked
+- **workerListening**: When a worker sets up a server and is listening
+- **workerMessage**: When a message is received from a worker
+- **workerOnline**: When a worker is online
+- **workerReady**: When a worker is ready to receive work
+
+### ClusterWorker
+
+#### Constructor
+
+```javascript
+const worker = _ClusterWorker(options);
+```
+
+Options:
+- `initialize`: Whether to automatically initialize (defaults to true)
+
+#### Methods
+
+- **destroy()**: Clean up and destroy the worker instance
+- **send({ message })**: Send a message to the primary process
+
+#### Static Properties
+
+- **worker**: Reference to the Node.js cluster worker object
+- **workerId**: Id of the current worker
+
+#### Events
+
+- **destroy**: When destroy begins
+- **destroyComplete** When destroy completes
+- **initialize**: When initialization begins
+- **initializeComplete**: When initialization completes successfully
+- **initializeError**: When initialization fails
+- **primaryDisconnect**: When the primary disconnects
+- **primaryMessage**: When a message is received from the primary
+
+## Advanced Usage
+
+### Custom Worker Initialization
+
+```javascript
+import _ClusterWorker from 'isotropic-cluster/lib/cluster-worker.js';
+import _make from 'isotropic-make';
+import _mongoose from 'mongoose';
+
+// Custom worker with database connection
+const _DbWorker = _make(_ClusterWorker, {
+    get db () {
+        return this._db;
+    },
+    // Custom initialization
+    async _initialize() {
+        // Connect to database
+        console.log(`Worker ${_ClusterWorker.workerId} connecting to database...`);
+
+        this._db = await _mongoose.connect('mongodb://localhost/myapp');
+
+        // Perform other initialization
+        this._setupModels();
+        await this._loadInitialData();
+    },
+    _initializeComplete () {
+        console.log(`Worker ${_ClusterWorker.workerId} database initialized`);
+    },
+    // Clean up resources on destroy
+    _destroy (...args) {
+        // Close database connection
+        if (this._db) {
+            console.log(`Worker ${_ClusterWorker.workerId} closing database connection`);
+            this._db.disconnect();
+            this._db = void null;
+        }
+
+        // Call parent destroy
+        return Reflect.apply(_ClusterWorker.prototype._destroy, this, args);
+    },
+    // Helper methods
+    async _loadInitialData () {
+        // Load any required initial data
+    },
+    _setupModels () {
+        // Define mongoose models
+    }
+});
+
+{
+    // Create the worker
+    const worker = _DbWorker();
+}
+```
+
+### Auto-Restart on Worker Failure
+
+The `ClusterPrimary` automatically restarts workers that die unexpectedly. This means workers are automatically replaced if they crash, ensuring application resilience.
+
+### Health Monitoring
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+import _later from 'isotropic-later';
+
+{
+    const primary = _ClusterPrimary(),
+        workerHealth = {},
+
+        sendHealthChecks = () => {
+            // Send regular health checks to workers
+            for (const worker of primary.workers) {
+                primary.send({
+                    message: {
+                        timestamp: Date.now(),
+                        type: 'healthCheck'
+                    },
+                    to: worker
+                }).catch(error => {
+                    console.error(`Failed to send health check to worker ${worker.id}:`, error);
+                });
+            }
+
+            _later(30000, sendHealthChecks);
+        };
+
+    // Process health responses
+    primary.on('workerMessage', ({
+        data: {
+            message,
+            worker
+        }
+    }) => {
+        if (message.type === 'healthStatus') {
+            workerHealth[worker.id] = {
+                activeRequests: message.activeRequests,
+                lastResponse: Date.now(),
+                memoryUsage: message.memoryUsage,
+                uptime: message.uptime
+            };
+
+            // Check for memory leaks or other issues
+            if (message.memoryUsage.heapUsed > 1.5 * 1024 * 1024 * 1024) { // 1.5GB
+                console.warn(`Worker ${worker.id} using excessive memory, scheduling restart`);
+
+                // Gracefully restart the worker
+                primary.send({
+                    message: {
+                        type: 'prepareForRestart'
+                    },
+                    to: worker
+                }).then(() => {
+                    // Worker will finish current tasks and exit
+                });
+            }
+        }
+    });
+
+    // Start workers
+    primary.fork({
+        workerCount: 4
+    });
+
+    sendHealthChecks();
+}
+```
+
+## Integration with Other isotropic Modules
+
+isotropic-cluster works seamlessly with other modules in the isotropic ecosystem:
+
+- **isotropic-error**: Nested error reporting
+- **isotropic-initializable**: Parent-to-child initialization sequence
+- **isotropic-logger**: Structured logging
+- **isotropic-make**: Create constructor functions with inheritance and mixins
+- **isotropic-pubsub**: Event system for the lifecycle events
+
+## Contributing
+
+Please refer to [CONTRIBUTING.md](https://github.com/ibi-group/isotropic-cluster/blob/main/CONTRIBUTING.md) for contribution guidelines.
+
+## Issues
+
+If you encounter any issues, please file them at https://github.com/ibi-group/isotropic-cluster/issues

package/lib/cluster-primary.js

@@ -1,2 +1,2 @@
-import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename))},!0);export default _make(_Initializable,{fork({workerCount:a=1}={}){return this._active?this._publish("fork",{workerCount:a}):this},roundRobin({tag:a=""}={}){let b,c=1/0,d=this._workerTimeByWorkerWeakMapByTag[a];d||(d=new WeakMap,this._workerTimeByWorkerWeakMapByTag[a]=d);for(const e of this._workers){const a=d.get(e);if(a)a<c&&(b=e,c=a);else{b=e;break}}return d.set(b,Date.now()),b},send({message:a,to:b=this._workers}){return Array.isArray(b)||(b=[b]),Promise.all(b.map(b=>new Promise((c,d)=>{const e="number"==typeof b?this._workerById[b]:b;e&&e.send?e.send(a,b=>{b?d(_Error({details:{message:a,workerId:e.id},error:b,message:"Error sending message to worker"})):c()}):d(_Error({details:{message:a,to:b},message:"Invalid message destination"}))})))},shutDown(){return this._publish("shutDown")},get workerById(){return this._workerById},get workers(){return this._workers},_addWorker({worker:a}){return this._publish("addWorker",{worker:a})},_destroy(...a){return this._active?(this._onceAfter("shutDownComplete","_destroy"),void this.shutDown()):void(this._active=void 0,Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.removeListener(a,this._clusterListenerByEventName[a])}),this._clusterListenerByEventName=void 0,this._workerTimeByWorkerWeakMapByTag=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a))},_eventAddWorker({data:{worker:a}}){this._workerById[a.id]=a,this._workers=Object.values(this._workerById)},_eventFork({data:{workerCount:a}}){for(;0<a;)_moduleLogger.info("Starting a new worker"),_cluster.fork(),a-=1},_eventRemoveWorker({data:{worker:a}}){delete this._workerById[a.id],this._workers=Object.values(this._workerById)},_eventShutDown(){return _moduleLogger.info("Shutting down workers"),this._active=!1,_cluster.disconnect(()=>{this._publish("shutDownComplete")}),this},_eventShutDownComplete(){_moduleLogger.info("Worker shut down complete")},_eventWorkerDisconnect({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker disconnected"),this._removeWorker({worker:a})},_eventWorkerError({data:{error:a,worker:b}}){_moduleLogger.fatal({error:_Error({details:{workerId:b.id},error:a,message:"Worker error"}),workerId:b.id},"Worker error"),this._removeWorker({worker:b})},_eventWorkerExit({data:{code:a,signal:b,worker:c}}){c.exitedAfterDisconnect?_moduleLogger.info({code:a,signal:b,workerId:c.id},"Worker exited voluntarily"):a?_moduleLogger.fatal({code:a,signal:b,workerId:c.id},"Worker died unexpectedly"):_moduleLogger.error({code:a,signal:b,workerId:c.id},"Worker died"),this._removeWorker({worker:c}),this._active&&(_moduleLogger.info("Replacing dead worker"),this.fork())},_eventWorkerFork({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Starting new worker"),a.on("error",b=>{this._publish("workerError",{error:_Error({details:{worker:a},error:b,message:"Error in worker"}),worker:a})})},_eventWorkerListening({data:{address:a,worker:b}}){_moduleLogger.info({address:a.address,port:a.port,workerId:b.id},"Worker is listening")},_eventWorkerMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventWorkerMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_eventWorkerOnline({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is now online");const b=c=>{"ready"===c&&(a.removeListener("message",b),this._publish("workerReady",{worker:a}))};a.on("message",b)},_eventWorkerReady({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is ready to work"),this._addWorker({worker:a})},_init(...a){return this._active=!0,this._clusterListenerByEventName={disconnect:a=>{this._publish("workerDisconnect",{worker:a})},exit:(a,b,c)=>{this._publish("workerExit",{code:b,signal:c,worker:a})},fork:a=>{this._publish("workerFork",{worker:a})},listening:(a,b)=>{this._publish("workerListening",{address:b,worker:a})},message:(a,b,c)=>{this._publish("workerMessage",{handle:c,message:b,worker:a})},online:a=>{this._publish("workerOnline",{worker:a})}},this._workerById=Object.create(null),this._workers=[],this._workerTimeByWorkerWeakMapByTag=Object.create(null),Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(...a){_moduleLogger.info("Initializing primary");const[{workerArgs:b,workerScript:c,workerSilent:d,workerStdio:e}={}]=a;_cluster.setupPrimary({args:"undefined"==typeof b?_process.argv.slice(2):b,exec:"undefined"==typeof c?_process.argv[1]:c,silent:"undefined"!=typeof d&&d,stdio:e}),Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.on(a,this._clusterListenerByEventName[a])})},_removeWorker({worker:a}){return a.id in this._workerById&&this._publish("removeWorker",{worker:a}),this}},{_pubsub:{addWorker:{allowPublicPublish:!1,defaultFunction:"_eventAddWorker"},fork:{allowPublicPublish:!1,defaultFunction:"_eventFork"},removeWorker:{allowPublicPublish:!1,defaultFunction:"_eventRemoveWorker"},shutDown:{allowPublicPublish:!1,completeOnce:!0,defaultFunction:"_eventShutDown"},shutDownComplete:{allowPublicPublish:!1,defaultFunction:"_eventShutDownComplete",publishOnce:!0},workerDisconnect:{allowPublicPublish:!1,defaultFunction:"_eventWorkerDisconnect"},workerError:{allowPublicPublish:!1,defaultFunction:"_eventWorkerError"},workerExit:{allowPublicPublish:!1,defaultFunction:"_eventWorkerExit"},workerFork:{allowPublicPublish:!1,defaultFunction:"_eventWorkerFork"},workerListening:{allowPublicPublish:!1,defaultFunction:"_eventWorkerListening"},workerMessage:{allowPublicPublish:!1,defaultFunction:"_eventWorkerMessage"},workerOnline:{allowPublicPublish:!1,defaultFunction:"_eventWorkerOnline"},workerReady:{allowPublicPublish:!1,defaultFunction:"_eventWorkerReady"}}});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_logger","_make","_path","_process","_moduleLogger","child","module","basename","import","meta","filename","extname","fork","workerCount","_active","_publish","roundRobin","tag","oldestWorker","oldestWorkerTime","workerTimeByWorkerWeakMap","_workerTimeByWorkerWeakMapByTag","WeakMap","worker","_workers","workerTime","get","set","Date","now","send","message","to","Array","isArray","Promise","all","map","resolve","reject","_workerById","error","details","workerId","id","shutDown","workerById","workers","_addWorker","_destroy","args","_onceAfter","Object","keys","_clusterListenerByEventName","forEach","eventName","removeListener","Reflect","apply","prototype","_eventAddWorker","data","values","_eventFork","info","_eventRemoveWorker","_eventShutDown","disconnect","_eventShutDownComplete","_eventWorkerDisconnect","_removeWorker","_eventWorkerError","fatal","_eventWorkerExit","code","signal","exitedAfterDisconnect","_eventWorkerFork","on","_eventWorkerListening","address","port","_eventWorkerMessage","event","type","method","_eventWorkerOnline","listener","_eventWorkerReady","_init","exit","listening","handle","online","create","_initialize","workerArgs","workerScript","workerSilent","workerStdio","setupPrimary","argv","slice","exec","silent","stdio","_pubsub","addWorker","allowPublicPublish","defaultFunction","removeWorker","completeOnce","shutDownComplete","publishOnce","workerDisconnect","workerError","workerExit","workerFork","workerListening","workerMessage","workerOnline","workerReady"],"sources":["../js/cluster-primary.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _moduleLogger = _logger.child({\n    module: _path.basename(import.meta.filename, _path.extname(import.meta.filename))\n}, true);\n\nexport default _make(_Initializable, {\n    fork ({\n        workerCount = 1\n    } = {}) {\n        return this._active ?\n            this._publish('fork', {\n                workerCount\n            }) :\n            this;\n    },\n    roundRobin ({\n        tag = ''\n    } = {}) {\n        let oldestWorker,\n            oldestWorkerTime = Infinity,\n            workerTimeByWorkerWeakMap = this._workerTimeByWorkerWeakMapByTag[tag];\n\n        if (!workerTimeByWorkerWeakMap) {\n            workerTimeByWorkerWeakMap = new WeakMap();\n            this._workerTimeByWorkerWeakMapByTag[tag] = workerTimeByWorkerWeakMap;\n        }\n\n        for (const worker of this._workers) {\n            const workerTime = workerTimeByWorkerWeakMap.get(worker);\n\n            if (workerTime) {\n                if (workerTime < oldestWorkerTime) {\n                    oldestWorker = worker;\n                    oldestWorkerTime = workerTime;\n                }\n            } else {\n                oldestWorker = worker;\n                break;\n            }\n        }\n\n        workerTimeByWorkerWeakMap.set(oldestWorker, Date.now());\n        return oldestWorker;\n    },\n    send ({\n        message,\n        to = this._workers\n    }) {\n        if (!Array.isArray(to)) {\n            to = [\n                to\n            ];\n        }\n\n        return Promise.all(to.map(to => new Promise((resolve, reject) => {\n            const worker = typeof to === 'number' ?\n                this._workerById[to] :\n                to;\n\n            if (worker && worker.send) {\n                worker.send(message, error => {\n                    if (error) {\n                        reject(_Error({\n                            details: {\n                                message,\n                                workerId: worker.id\n                            },\n                            error,\n                            message: 'Error sending message to worker'\n                        }));\n                    } else {\n                        resolve();\n                    }\n                });\n            } else {\n                reject(_Error({\n                    details: {\n                        message,\n                        to\n                    },\n                    message: 'Invalid message destination'\n                }));\n            }\n        })));\n    },\n    shutDown () {\n        return this._publish('shutDown');\n    },\n    get workerById () {\n        return this._workerById;\n    },\n    get workers () {\n        return this._workers;\n    },\n    _addWorker ({\n        worker\n    }) {\n        return this._publish('addWorker', {\n            worker\n        });\n    },\n    _destroy (...args) {\n        if (this._active) {\n            this._onceAfter('shutDownComplete', '_destroy');\n            this.shutDown();\n            return;\n        }\n\n        this._active = void null;\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.removeListener(eventName, this._clusterListenerByEventName[eventName]);\n        });\n\n        this._clusterListenerByEventName = void null;\n\n        this._workerTimeByWorkerWeakMapByTag = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _eventAddWorker ({\n        data: {\n            worker\n        }\n    }) {\n        this._workerById[worker.id] = worker;\n        this._workers = Object.values(this._workerById);\n    },\n    _eventFork ({\n        data: {\n            workerCount\n        }\n    }) {\n        while (workerCount > 0) {\n            _moduleLogger.info('Starting a new worker');\n\n            _cluster.fork();\n            workerCount -= 1;\n        }\n    },\n    _eventRemoveWorker ({\n        data: {\n            worker\n        }\n    }) {\n        delete this._workerById[worker.id];\n        this._workers = Object.values(this._workerById);\n    },\n    _eventShutDown () {\n        _moduleLogger.info('Shutting down workers');\n\n        this._active = false;\n\n        _cluster.disconnect(() => {\n            this._publish('shutDownComplete');\n        });\n\n        return this;\n    },\n    _eventShutDownComplete () {\n        _moduleLogger.info('Worker shut down complete');\n    },\n    _eventWorkerDisconnect ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker disconnected');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerError ({\n        data: {\n            error,\n            worker\n        }\n    }) {\n        _moduleLogger.fatal({\n            error: _Error({\n                details: {\n                    workerId: worker.id\n                },\n                error,\n                message: 'Worker error'\n            }),\n            workerId: worker.id\n        }, 'Worker error');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerExit ({\n        data: {\n            code,\n            signal,\n            worker\n        }\n    }) {\n        if (worker.exitedAfterDisconnect) {\n            _moduleLogger.info({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker exited voluntarily');\n        } else if (code) {\n            _moduleLogger.fatal({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died unexpectedly');\n        } else {\n            _moduleLogger.error({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died');\n        }\n\n        this._removeWorker({\n            worker\n        });\n\n        if (this._active) {\n            _moduleLogger.info('Replacing dead worker');\n\n            this.fork();\n        }\n    },\n    _eventWorkerFork ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Starting new worker');\n\n        worker.on('error', error => {\n            this._publish('workerError', {\n                error: _Error({\n                    details: {\n                        worker\n                    },\n                    error,\n                    message: 'Error in worker'\n                }),\n                worker\n            });\n        });\n    },\n    _eventWorkerListening ({\n        data: {\n            address,\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            address: address.address,\n            port: address.port,\n            workerId: worker.id\n        }, 'Worker is listening');\n    },\n    _eventWorkerMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventWorkerMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _eventWorkerOnline ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is now online');\n\n        const listener = message => {\n            if (message === 'ready') {\n                worker.removeListener('message', listener);\n\n                this._publish('workerReady', {\n                    worker\n                });\n            }\n        };\n\n        worker.on('message', listener);\n    },\n    _eventWorkerReady ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is ready to work');\n\n        this._addWorker({\n            worker\n        });\n    },\n    _init (...args) {\n        this._active = true;\n\n        this._clusterListenerByEventName = {\n            disconnect: worker => {\n                this._publish('workerDisconnect', {\n                    worker\n                });\n            },\n            exit: (worker, code, signal) => {\n                this._publish('workerExit', {\n                    code,\n                    signal,\n                    worker\n                });\n            },\n            fork: worker => {\n                this._publish('workerFork', {\n                    worker\n                });\n            },\n            listening: (worker, address) => {\n                this._publish('workerListening', {\n                    address,\n                    worker\n                });\n            },\n            message: (worker, message, handle) => {\n                this._publish('workerMessage', {\n                    handle,\n                    message,\n                    worker\n                });\n            },\n            online: worker => {\n                this._publish('workerOnline', {\n                    worker\n                });\n            }\n        };\n\n        this._workerById = Object.create(null);\n\n        this._workers = [];\n\n        this._workerTimeByWorkerWeakMapByTag = Object.create(null);\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize (...args) {\n        _moduleLogger.info('Initializing primary');\n\n        const [{\n            workerArgs,\n            workerScript,\n            workerSilent,\n            workerStdio\n        } = {}] = args;\n\n        _cluster.setupPrimary({\n            args: typeof workerArgs === 'undefined' ?\n                _process.argv.slice(2) :\n                workerArgs,\n            exec: typeof workerScript === 'undefined' ?\n                _process.argv[1] :\n                workerScript,\n            silent: typeof workerSilent === 'undefined' ?\n                false :\n                workerSilent,\n            stdio: workerStdio\n        });\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.on(eventName, this._clusterListenerByEventName[eventName]);\n        });\n    },\n    _removeWorker ({\n        worker\n    }) {\n        if (worker.id in this._workerById) {\n            this._publish('removeWorker', {\n                worker\n            });\n        }\n\n        return this;\n    }\n}, {\n    _pubsub: {\n        addWorker: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventAddWorker'\n        },\n        fork: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventFork'\n        },\n        removeWorker: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventRemoveWorker'\n        },\n        shutDown: {\n            allowPublicPublish: false,\n            completeOnce: true,\n            defaultFunction: '_eventShutDown'\n        },\n        shutDownComplete: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventShutDownComplete',\n            publishOnce: true\n        },\n        workerDisconnect: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerDisconnect'\n        },\n        workerError: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerError'\n        },\n        workerExit: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerExit'\n        },\n        workerFork: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerFork'\n        },\n        workerListening: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerListening'\n        },\n        workerMessage: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerMessage'\n        },\n        workerOnline: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerOnline'\n        },\n        workerReady: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventWorkerReady'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}
+import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename))},!0);export default _make(_Initializable,{fork({workerCount:a=1}={}){return this._active?this._publish("fork",{workerCount:a}):this},roundRobin({tag:a=""}={}){let b,c=1/0,d=this._workerTimeByWorkerWeakMapByTag[a];d||(d=new WeakMap,this._workerTimeByWorkerWeakMapByTag[a]=d);for(const e of this._workers){const a=d.get(e);if(a)a<c&&(b=e,c=a);else{b=e;break}}return d.set(b,Date.now()),b},send({message:a,to:b=this._workers}){return Array.isArray(b)||(b=[b]),Promise.all(b.map(b=>new Promise((c,d)=>{const e="number"==typeof b?this._workerById[b]:b;e&&e.send?e.send(a,b=>{b?d(_Error({details:{message:a,workerId:e.id},error:b,message:"Error sending message to worker"})):c()}):d(_Error({details:{message:a,to:b},message:"Invalid message destination"}))})))},shutDown(){return this._publish("shutDown")},get workerById(){return this._workerById},get workers(){return this._workers},_addWorker({worker:a}){return this._publish("addWorker",{worker:a})},_destroy(...a){return this._active?(this._onceAfter("shutDownComplete","_destroy"),void this.shutDown()):void(this._active=void 0,Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.removeListener(a,this._clusterListenerByEventName[a])}),this._clusterListenerByEventName=void 0,this._workerTimeByWorkerWeakMapByTag=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a))},_eventAddWorker({data:{worker:a}}){this._workerById[a.id]=a,this._workers=Object.values(this._workerById)},_eventFork({data:{workerCount:a}}){for(;0<a;)_moduleLogger.info("Starting a new worker"),_cluster.fork(),a-=1},_eventRemoveWorker({data:{worker:a}}){delete this._workerById[a.id],this._workers=Object.values(this._workerById)},_eventShutDown(){return _moduleLogger.info("Shutting down workers"),this._active=!1,_cluster.disconnect(()=>{this._publish("shutDownComplete")}),this},_eventShutDownComplete(){_moduleLogger.info("Worker shut down complete")},_eventWorkerDisconnect({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker disconnected"),this._removeWorker({worker:a})},_eventWorkerError({data:{error:a,worker:b}}){_moduleLogger.fatal({error:_Error({details:{workerId:b.id},error:a,message:"Worker error"}),workerId:b.id},"Worker error"),this._removeWorker({worker:b})},_eventWorkerExit({data:{code:a,signal:b,worker:c}}){c.exitedAfterDisconnect?_moduleLogger.info({code:a,signal:b,workerId:c.id},"Worker exited voluntarily"):a?_moduleLogger.fatal({code:a,signal:b,workerId:c.id},"Worker died unexpectedly"):_moduleLogger.error({code:a,signal:b,workerId:c.id},"Worker died"),this._removeWorker({worker:c}),this._active&&(_moduleLogger.info("Replacing dead worker"),this.fork())},_eventWorkerFork({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Starting new worker"),a.on("error",b=>{this._publish("workerError",{error:_Error({details:{worker:a},error:b,message:"Error in worker"}),worker:a})})},_eventWorkerListening({data:{address:a,worker:b}}){_moduleLogger.info({address:a.address,port:a.port,workerId:b.id},"Worker is listening")},_eventWorkerMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventWorkerMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_eventWorkerOnline({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is now online");const b=c=>{"ready"===c&&(a.removeListener("message",b),this._publish("workerReady",{worker:a}))};a.on("message",b)},_eventWorkerReady({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is ready to work"),this._addWorker({worker:a})},_init(...a){return this._active=!0,this._clusterListenerByEventName={disconnect:a=>{this._publish("workerDisconnect",{worker:a})},exit:(a,b,c)=>{this._publish("workerExit",{code:b,signal:c,worker:a})},fork:a=>{this._publish("workerFork",{worker:a})},listening:(a,b)=>{this._publish("workerListening",{address:b,worker:a})},message:(a,b,c)=>{this._publish("workerMessage",{handle:c,message:b,worker:a})},online:a=>{this._publish("workerOnline",{worker:a})}},this._workerById=Object.create(null),this._workers=[],this._workerTimeByWorkerWeakMapByTag=Object.create(null),Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(...a){_moduleLogger.info("Initializing primary");const[{workerArgs:b,workerScript:c,workerSilent:d,workerStdio:e}={}]=a;_cluster.setupPrimary({args:"undefined"==typeof b?_process.argv.slice(2):b,exec:"undefined"==typeof c?_process.argv[1]:c,silent:"undefined"!=typeof d&&d,stdio:e}),Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.on(a,this._clusterListenerByEventName[a])})},_removeWorker({worker:a}){return a.id in this._workerById&&this._publish("removeWorker",{worker:a}),this}},{_pubsub:{addWorker:{completeFunction:"_eventAddWorker"},fork:{completeFunction:"_eventFork"},removeWorker:{completeFunction:"_eventRemoveWorker"},shutDown:{completeFunction:"_eventShutDown",completeOnce:!0},shutDownComplete:{completeFunction:"_eventShutDownComplete",publishOnce:!0},workerDisconnect:{completeFunction:"_eventWorkerDisconnect"},workerError:{completeFunction:"_eventWorkerError"},workerExit:{completeFunction:"_eventWorkerExit"},workerFork:{completeFunction:"_eventWorkerFork"},workerListening:{completeFunction:"_eventWorkerListening"},workerMessage:{completeFunction:"_eventWorkerMessage"},workerOnline:{completeFunction:"_eventWorkerOnline"},workerReady:{completeFunction:"_eventWorkerReady"}}});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_logger","_make","_path","_process","_moduleLogger","child","module","basename","import","meta","filename","extname","fork","workerCount","_active","_publish","roundRobin","tag","oldestWorker","oldestWorkerTime","workerTimeByWorkerWeakMap","_workerTimeByWorkerWeakMapByTag","WeakMap","worker","_workers","workerTime","get","set","Date","now","send","message","to","Array","isArray","Promise","all","map","resolve","reject","_workerById","error","details","workerId","id","shutDown","workerById","workers","_addWorker","_destroy","args","_onceAfter","Object","keys","_clusterListenerByEventName","forEach","eventName","removeListener","Reflect","apply","prototype","_eventAddWorker","data","values","_eventFork","info","_eventRemoveWorker","_eventShutDown","disconnect","_eventShutDownComplete","_eventWorkerDisconnect","_removeWorker","_eventWorkerError","fatal","_eventWorkerExit","code","signal","exitedAfterDisconnect","_eventWorkerFork","on","_eventWorkerListening","address","port","_eventWorkerMessage","event","type","method","_eventWorkerOnline","listener","_eventWorkerReady","_init","exit","listening","handle","online","create","_initialize","workerArgs","workerScript","workerSilent","workerStdio","setupPrimary","argv","slice","exec","silent","stdio","_pubsub","addWorker","completeFunction","removeWorker","completeOnce","shutDownComplete","publishOnce","workerDisconnect","workerError","workerExit","workerFork","workerListening","workerMessage","workerOnline","workerReady"],"sources":["../js/cluster-primary.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _moduleLogger = _logger.child({\n    module: _path.basename(import.meta.filename, _path.extname(import.meta.filename))\n}, true);\n\nexport default _make(_Initializable, {\n    fork ({\n        workerCount = 1\n    } = {}) {\n        return this._active ?\n            this._publish('fork', {\n                workerCount\n            }) :\n            this;\n    },\n    roundRobin ({\n        tag = ''\n    } = {}) {\n        let oldestWorker,\n            oldestWorkerTime = Infinity,\n            workerTimeByWorkerWeakMap = this._workerTimeByWorkerWeakMapByTag[tag];\n\n        if (!workerTimeByWorkerWeakMap) {\n            workerTimeByWorkerWeakMap = new WeakMap();\n            this._workerTimeByWorkerWeakMapByTag[tag] = workerTimeByWorkerWeakMap;\n        }\n\n        for (const worker of this._workers) {\n            const workerTime = workerTimeByWorkerWeakMap.get(worker);\n\n            if (workerTime) {\n                if (workerTime < oldestWorkerTime) {\n                    oldestWorker = worker;\n                    oldestWorkerTime = workerTime;\n                }\n            } else {\n                oldestWorker = worker;\n                break;\n            }\n        }\n\n        workerTimeByWorkerWeakMap.set(oldestWorker, Date.now());\n        return oldestWorker;\n    },\n    send ({\n        message,\n        to = this._workers\n    }) {\n        if (!Array.isArray(to)) {\n            to = [\n                to\n            ];\n        }\n\n        return Promise.all(to.map(to => new Promise((resolve, reject) => {\n            const worker = typeof to === 'number' ?\n                this._workerById[to] :\n                to;\n\n            if (worker && worker.send) {\n                worker.send(message, error => {\n                    if (error) {\n                        reject(_Error({\n                            details: {\n                                message,\n                                workerId: worker.id\n                            },\n                            error,\n                            message: 'Error sending message to worker'\n                        }));\n                    } else {\n                        resolve();\n                    }\n                });\n            } else {\n                reject(_Error({\n                    details: {\n                        message,\n                        to\n                    },\n                    message: 'Invalid message destination'\n                }));\n            }\n        })));\n    },\n    shutDown () {\n        return this._publish('shutDown');\n    },\n    get workerById () {\n        return this._workerById;\n    },\n    get workers () {\n        return this._workers;\n    },\n    _addWorker ({\n        worker\n    }) {\n        return this._publish('addWorker', {\n            worker\n        });\n    },\n    _destroy (...args) {\n        if (this._active) {\n            this._onceAfter('shutDownComplete', '_destroy');\n            this.shutDown();\n            return;\n        }\n\n        this._active = void null;\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.removeListener(eventName, this._clusterListenerByEventName[eventName]);\n        });\n\n        this._clusterListenerByEventName = void null;\n\n        this._workerTimeByWorkerWeakMapByTag = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _eventAddWorker ({\n        data: {\n            worker\n        }\n    }) {\n        this._workerById[worker.id] = worker;\n        this._workers = Object.values(this._workerById);\n    },\n    _eventFork ({\n        data: {\n            workerCount\n        }\n    }) {\n        while (workerCount > 0) {\n            _moduleLogger.info('Starting a new worker');\n\n            _cluster.fork();\n            workerCount -= 1;\n        }\n    },\n    _eventRemoveWorker ({\n        data: {\n            worker\n        }\n    }) {\n        delete this._workerById[worker.id];\n        this._workers = Object.values(this._workerById);\n    },\n    _eventShutDown () {\n        _moduleLogger.info('Shutting down workers');\n\n        this._active = false;\n\n        _cluster.disconnect(() => {\n            this._publish('shutDownComplete');\n        });\n\n        return this;\n    },\n    _eventShutDownComplete () {\n        _moduleLogger.info('Worker shut down complete');\n    },\n    _eventWorkerDisconnect ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker disconnected');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerError ({\n        data: {\n            error,\n            worker\n        }\n    }) {\n        _moduleLogger.fatal({\n            error: _Error({\n                details: {\n                    workerId: worker.id\n                },\n                error,\n                message: 'Worker error'\n            }),\n            workerId: worker.id\n        }, 'Worker error');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerExit ({\n        data: {\n            code,\n            signal,\n            worker\n        }\n    }) {\n        if (worker.exitedAfterDisconnect) {\n            _moduleLogger.info({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker exited voluntarily');\n        } else if (code) {\n            _moduleLogger.fatal({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died unexpectedly');\n        } else {\n            _moduleLogger.error({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died');\n        }\n\n        this._removeWorker({\n            worker\n        });\n\n        if (this._active) {\n            _moduleLogger.info('Replacing dead worker');\n\n            this.fork();\n        }\n    },\n    _eventWorkerFork ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Starting new worker');\n\n        worker.on('error', error => {\n            this._publish('workerError', {\n                error: _Error({\n                    details: {\n                        worker\n                    },\n                    error,\n                    message: 'Error in worker'\n                }),\n                worker\n            });\n        });\n    },\n    _eventWorkerListening ({\n        data: {\n            address,\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            address: address.address,\n            port: address.port,\n            workerId: worker.id\n        }, 'Worker is listening');\n    },\n    _eventWorkerMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventWorkerMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _eventWorkerOnline ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is now online');\n\n        const listener = message => {\n            if (message === 'ready') {\n                worker.removeListener('message', listener);\n\n                this._publish('workerReady', {\n                    worker\n                });\n            }\n        };\n\n        worker.on('message', listener);\n    },\n    _eventWorkerReady ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is ready to work');\n\n        this._addWorker({\n            worker\n        });\n    },\n    _init (...args) {\n        this._active = true;\n\n        this._clusterListenerByEventName = {\n            disconnect: worker => {\n                this._publish('workerDisconnect', {\n                    worker\n                });\n            },\n            exit: (worker, code, signal) => {\n                this._publish('workerExit', {\n                    code,\n                    signal,\n                    worker\n                });\n            },\n            fork: worker => {\n                this._publish('workerFork', {\n                    worker\n                });\n            },\n            listening: (worker, address) => {\n                this._publish('workerListening', {\n                    address,\n                    worker\n                });\n            },\n            message: (worker, message, handle) => {\n                this._publish('workerMessage', {\n                    handle,\n                    message,\n                    worker\n                });\n            },\n            online: worker => {\n                this._publish('workerOnline', {\n                    worker\n                });\n            }\n        };\n\n        this._workerById = Object.create(null);\n\n        this._workers = [];\n\n        this._workerTimeByWorkerWeakMapByTag = Object.create(null);\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize (...args) {\n        _moduleLogger.info('Initializing primary');\n\n        const [{\n            workerArgs,\n            workerScript,\n            workerSilent,\n            workerStdio\n        } = {}] = args;\n\n        _cluster.setupPrimary({\n            args: typeof workerArgs === 'undefined' ?\n                _process.argv.slice(2) :\n                workerArgs,\n            exec: typeof workerScript === 'undefined' ?\n                _process.argv[1] :\n                workerScript,\n            silent: typeof workerSilent === 'undefined' ?\n                false :\n                workerSilent,\n            stdio: workerStdio\n        });\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.on(eventName, this._clusterListenerByEventName[eventName]);\n        });\n    },\n    _removeWorker ({\n        worker\n    }) {\n        if (worker.id in this._workerById) {\n            this._publish('removeWorker', {\n                worker\n            });\n        }\n\n        return this;\n    }\n}, {\n    _pubsub: {\n        addWorker: {\n            completeFunction: '_eventAddWorker'\n        },\n        fork: {\n            completeFunction: '_eventFork'\n        },\n        removeWorker: {\n            completeFunction: '_eventRemoveWorker'\n        },\n        shutDown: {\n            completeFunction: '_eventShutDown',\n            completeOnce: true\n        },\n        shutDownComplete: {\n            completeFunction: '_eventShutDownComplete',\n            publishOnce: true\n        },\n        workerDisconnect: {\n            completeFunction: '_eventWorkerDisconnect'\n        },\n        workerError: {\n            completeFunction: '_eventWorkerError'\n        },\n        workerExit: {\n            completeFunction: '_eventWorkerExit'\n        },\n        workerFork: {\n            completeFunction: '_eventWorkerFork'\n        },\n        workerListening: {\n            completeFunction: '_eventWorkerListening'\n        },\n        workerMessage: {\n            completeFunction: '_eventWorkerMessage'\n        },\n        workerOnline: {\n            completeFunction: '_eventWorkerOnline'\n        },\n        workerReady: {\n            completeFunction: '_eventWorkerReady'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/cluster-worker.js

@@ -1,2 +1,2 @@
-import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _later from"isotropic-later";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _workerId=_cluster.worker&&_cluster.worker.id,_moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename)),workerId:_workerId});export default _make(_Initializable,{send({message:a}){return new Promise((b,c)=>{_process.send(a,d=>{d?c(_Error({details:{message:a},error:d,message:"Error sending message to primary"})):b()})})},_destroy(...a){Object.keys(this._processEvents).forEach(a=>{_process.removeListener(a,this._processEvents[a])}),this._processEvents=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a)},_destroyComplete({timeout:a=6765}={}){_cluster.worker&&(_cluster.worker.disconnect(),_later(a,()=>{_cluster.worker.kill()}))},_eventPrimaryDisconnect(){_moduleLogger.info("Primary disconnected")},_eventPrimaryMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventPrimaryMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_init(...a){return this._processEvents={disconnect:()=>{this._publish("primaryDisconnect")},message:(a,b)=>{this._publish("primaryMessage",{handle:b,message:a})}},Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(){if(_cluster.isWorker)_moduleLogger.info("Initializing worker"),Object.keys(this._processEvents).forEach(a=>{_process.on(a,this._processEvents[a])});else throw _Error({message:"Cluster worker can not initialize in non-worker process"})},_initializeComplete(){_process.send("ready")}},{get worker(){return _cluster.worker},get workerId(){return _workerId},_pubsub:{primaryDisconnect:{allowPublicPublish:!1,defaultFunction:"_eventPrimaryDisconnect"},primaryMessage:{allowPublicPublish:!1,defaultFunction:"_eventPrimaryMessage"}}});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_later","_logger","_make","_path","_process","_workerId","worker","id","_moduleLogger","child","module","basename","import","meta","filename","extname","workerId","send","message","Promise","resolve","reject","error","details","_destroy","args","Object","keys","_processEvents","forEach","eventName","removeListener","Reflect","apply","prototype","_destroyComplete","timeout","disconnect","kill","_eventPrimaryDisconnect","info","_eventPrimaryMessage","event","data","type","method","_init","_publish","handle","_initialize","isWorker","on","_initializeComplete","_pubsub","primaryDisconnect","allowPublicPublish","defaultFunction","primaryMessage"],"sources":["../js/cluster-worker.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _later from 'isotropic-later';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _workerId = _cluster.worker && _cluster.worker.id,\n\n    _moduleLogger = _logger.child({\n        module: _path.basename(import.meta.filename, _path.extname(import.meta.filename)),\n        workerId: _workerId\n    });\n\nexport default _make(_Initializable, {\n    send ({\n        message\n    }) {\n        return new Promise((resolve, reject) => {\n            _process.send(message, error => {\n                if (error) {\n                    reject(_Error({\n                        details: {\n                            message\n                        },\n                        error,\n                        message: 'Error sending message to primary'\n                    }));\n                } else {\n                    resolve();\n                }\n            });\n        });\n    },\n    _destroy (...args) {\n        Object.keys(this._processEvents).forEach(eventName => {\n            _process.removeListener(eventName, this._processEvents[eventName]);\n        });\n\n        this._processEvents = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _destroyComplete ({\n        timeout = 6765\n    } = {}) {\n        if (_cluster.worker) {\n            _cluster.worker.disconnect();\n\n            _later(timeout, () => {\n                _cluster.worker.kill();\n            });\n        }\n    },\n    _eventPrimaryDisconnect () {\n        _moduleLogger.info('Primary disconnected');\n    },\n    _eventPrimaryMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventPrimaryMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _init (...args) {\n        this._processEvents = {\n            disconnect: () => {\n                this._publish('primaryDisconnect');\n            },\n            message: (message, handle) => {\n                this._publish('primaryMessage', {\n                    handle,\n                    message\n                });\n            }\n        };\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize () {\n        if (_cluster.isWorker) {\n            _moduleLogger.info('Initializing worker');\n\n            Object.keys(this._processEvents).forEach(eventName => {\n                _process.on(eventName, this._processEvents[eventName]);\n            });\n        } else {\n            throw _Error({\n                message: 'Cluster worker can not initialize in non-worker process'\n            });\n        }\n    },\n    _initializeComplete () {\n        _process.send('ready');\n    }\n}, {\n    get worker () {\n        return _cluster.worker;\n    },\n    get workerId () {\n        return _workerId;\n    },\n    _pubsub: {\n        primaryDisconnect: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventPrimaryDisconnect'\n        },\n        primaryMessage: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventPrimaryMessage'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}
+import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _later from"isotropic-later";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _workerId=_cluster.worker&&_cluster.worker.id,_moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename)),workerId:_workerId});export default _make(_Initializable,{send({message:a}){return new Promise((b,c)=>{_process.send(a,d=>{d?c(_Error({details:{message:a},error:d,message:"Error sending message to primary"})):b()})})},_destroy(...a){Object.keys(this._processEvents).forEach(a=>{_process.removeListener(a,this._processEvents[a])}),this._processEvents=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a)},_destroyComplete({timeout:a=6765}={}){_cluster.worker&&(_cluster.worker.disconnect(),_later(a,()=>{_cluster.worker.kill()}))},_eventPrimaryDisconnect(){_moduleLogger.info("Primary disconnected")},_eventPrimaryMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventPrimaryMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_init(...a){return this._processEvents={disconnect:()=>{this._publish("primaryDisconnect")},message:(a,b)=>{this._publish("primaryMessage",{handle:b,message:a})}},Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(){if(_cluster.isWorker)_moduleLogger.info("Initializing worker"),Object.keys(this._processEvents).forEach(a=>{_process.on(a,this._processEvents[a])});else throw _Error({message:"Cluster worker can not initialize in non-worker process"})},_initializeComplete(){_process.send("ready")}},{get worker(){return _cluster.worker},get workerId(){return _workerId},_pubsub:{primaryDisconnect:{completeFunction:"_eventPrimaryDisconnect"},primaryMessage:{completeFunction:"_eventPrimaryMessage"}}});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_later","_logger","_make","_path","_process","_workerId","worker","id","_moduleLogger","child","module","basename","import","meta","filename","extname","workerId","send","message","Promise","resolve","reject","error","details","_destroy","args","Object","keys","_processEvents","forEach","eventName","removeListener","Reflect","apply","prototype","_destroyComplete","timeout","disconnect","kill","_eventPrimaryDisconnect","info","_eventPrimaryMessage","event","data","type","method","_init","_publish","handle","_initialize","isWorker","on","_initializeComplete","_pubsub","primaryDisconnect","completeFunction","primaryMessage"],"sources":["../js/cluster-worker.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _later from 'isotropic-later';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _workerId = _cluster.worker && _cluster.worker.id,\n\n    _moduleLogger = _logger.child({\n        module: _path.basename(import.meta.filename, _path.extname(import.meta.filename)),\n        workerId: _workerId\n    });\n\nexport default _make(_Initializable, {\n    send ({\n        message\n    }) {\n        return new Promise((resolve, reject) => {\n            _process.send(message, error => {\n                if (error) {\n                    reject(_Error({\n                        details: {\n                            message\n                        },\n                        error,\n                        message: 'Error sending message to primary'\n                    }));\n                } else {\n                    resolve();\n                }\n            });\n        });\n    },\n    _destroy (...args) {\n        Object.keys(this._processEvents).forEach(eventName => {\n            _process.removeListener(eventName, this._processEvents[eventName]);\n        });\n\n        this._processEvents = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _destroyComplete ({\n        timeout = 6765\n    } = {}) {\n        if (_cluster.worker) {\n            _cluster.worker.disconnect();\n\n            _later(timeout, () => {\n                _cluster.worker.kill();\n            });\n        }\n    },\n    _eventPrimaryDisconnect () {\n        _moduleLogger.info('Primary disconnected');\n    },\n    _eventPrimaryMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventPrimaryMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _init (...args) {\n        this._processEvents = {\n            disconnect: () => {\n                this._publish('primaryDisconnect');\n            },\n            message: (message, handle) => {\n                this._publish('primaryMessage', {\n                    handle,\n                    message\n                });\n            }\n        };\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize () {\n        if (_cluster.isWorker) {\n            _moduleLogger.info('Initializing worker');\n\n            Object.keys(this._processEvents).forEach(eventName => {\n                _process.on(eventName, this._processEvents[eventName]);\n            });\n        } else {\n            throw _Error({\n                message: 'Cluster worker can not initialize in non-worker process'\n            });\n        }\n    },\n    _initializeComplete () {\n        _process.send('ready');\n    }\n}, {\n    get worker () {\n        return _cluster.worker;\n    },\n    get workerId () {\n        return _workerId;\n    },\n    _pubsub: {\n        primaryDisconnect: {\n            completeFunction: '_eventPrimaryDisconnect'\n        },\n        primaryMessage: {\n            completeFunction: '_eventPrimaryMessage'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}

package/package.json

@@ -2,16 +2,17 @@
     "author": "Steven Olmsted <steven.olmsted@ibigroup.com>",
     "bugs": "https://github.com/ibi-group/isotropic-cluster/issues",
     "dependencies": {
-        "isotropic-error": "~0.13.0",
-        "isotropic-initializable": "~0.10.0",
-        "isotropic-later": "~0.13.0",
-        "isotropic-logger": "~0.3.0",
-        "isotropic-make": "~0.13.0"
+        "isotropic-error": "~0.13.1",
+        "isotropic-initializable": "~0.12.0",
+        "isotropic-later": "~0.14.0",
+        "isotropic-logger": "~0.4.0",
+        "isotropic-make": "~0.13.1"
     },
     "description": "A reusable and extendable platform to manage local process clusters",
     "devDependencies": {
-        "bunyan-stream-isotropic": "~0.3.0",
-        "isotropic-dev-dependencies": "~0.3.0"
+        "bunyan-stream-isotropic": "~0.4.0",
+        "eslint": "~9.8.0",
+        "isotropic-dev-dependencies": "~0.3.1"
     },
     "engines": {
         "node": "^22.5.1",
@@ -38,5 +39,5 @@
         "test": "cross-env BABEL_ENV=test c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json mocha --import=isotropic-dev-dependencies/lib/register-babel-loader.js"
     },
     "type": "module",
-    "version": "0.3.0"
+    "version": "0.5.0"
 }