isotropic-cluster 0.2.0 → 0.4.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

@@ -0,0 +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:{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 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _cluster2=_interopRequireDefault(require("cluster")),_isotropicError=_interopRequireDefault(require("isotropic-error")),_isotropicInitializable=_interopRequireDefault(require("isotropic-initializable")),_isotropicLater=_interopRequireDefault(require("isotropic-later")),_isotropicLogger=_interopRequireDefault(require("isotropic-logger")),_isotropicMake=_interopRequireDefault(require("isotropic-make")),_path2=_interopRequireDefault(require("path")),_process2=_interopRequireDefault(require("process"));function _interopRequireDefault(a){return a&&a.__esModule?a:{default:a}}const _workerId=_cluster2.default.worker&&_cluster2.default.worker.id,_moduleLogger=_isotropicLogger.default.child({module:_path2.default.basename(__filename,_path2.default.extname(__filename)),workerId:_workerId});var _default=(0,_isotropicMake.default)(_isotropicInitializable.default,{send({message:a}){return new Promise((b,c)=>{_process2.default.send(a,d=>{d?c((0,_isotropicError.default)({details:{message:a},error:d,message:"Error sending message to master"})):b()})})},_destroy(...a){Object.keys(this._processEvents).forEach(a=>{_process2.default.removeListener(a,this._processEvents[a])}),this._processEvents=void 0,Reflect.apply(_isotropicInitializable.default.prototype._destroy,this,a)},_destroyComplete({timeout:a=6765}={}){_cluster2.default.worker&&(_cluster2.default.worker.disconnect(),(0,_isotropicLater.default)(a,()=>{_cluster2.default.worker.kill()}))},_eventMasterDisconnect(){_moduleLogger.info("Master disconnected")},_eventMasterMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventMasterMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_init(...a){return this._processEvents={disconnect:()=>{this._publish("masterDisconnect")},message:(a,b)=>{this._publish("masterMessage",{handle:b,message:a})}},Reflect.apply(_isotropicInitializable.default.prototype._init,this,a)},_initialize(){if(_cluster2.default.isWorker)_moduleLogger.info("Initializing worker"),Object.keys(this._processEvents).forEach(a=>{_process2.default.on(a,this._processEvents[a])});else throw(0,_isotropicError.default)({message:"Cluster worker can not initialize in non-worker process"})},_initializeComplete(){_process2.default.send("ready")}},{get worker(){return _cluster2.default.worker},get workerId(){return _workerId},_events:{masterDisconnect:{allowPublicPublish:!1,defaultFunction:"_eventMasterDisconnect"},masterMessage:{allowPublicPublish:!1,defaultFunction:"_eventMasterMessage"}}});exports.default=_default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../js/cluster-worker.js"],"names":["_workerId","_cluster","worker","id","_moduleLogger","_logger","child","module","_path","basename","__filename","extname","workerId","_Initializable","send","message","Promise","resolve","reject","_process","error","details","_destroy","args","Object","keys","_processEvents","forEach","eventName","removeListener","Reflect","apply","prototype","_destroyComplete","timeout","disconnect","kill","_eventMasterDisconnect","info","_eventMasterMessage","event","data","type","method","_init","_publish","handle","_initialize","isWorker","on","_initializeComplete","_events","masterDisconnect","allowPublicPublish","defaultFunction","masterMessage"],"mappings":"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","sourcesContent":["import _cluster from '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 'path';\nimport _process from 'process';\n\nconst _workerId = _cluster.worker && _cluster.worker.id,\n\n    _moduleLogger = _logger.child({\n        module: _path.basename(__filename, _path.extname(__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 master'\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    _eventMasterDisconnect () {\n        _moduleLogger.info('Master disconnected');\n    },\n    _eventMasterMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventMasterMessage_${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('masterDisconnect');\n            },\n            message: (message, handle) => {\n                this._publish('masterMessage', {\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    _events: {\n        masterDisconnect: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventMasterDisconnect'\n        },\n        masterMessage: {\n            allowPublicPublish: false,\n            defaultFunction: '_eventMasterMessage'\n        }\n    }\n});\n"]}
+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

@@ -1,24 +1,22 @@
 {
     "author": "Steven Olmsted <steven.olmsted@ibigroup.com>",
     "bugs": "https://github.com/ibi-group/isotropic-cluster/issues",
-    "contributors": [
-        "Duane Sibilly <duane.sibilly@ibigroup.com>"
-    ],
     "dependencies": {
-        "isotropic-error": "~0.12.0",
-        "isotropic-initializable": "~0.9.0",
-        "isotropic-later": "~0.12.0",
-        "isotropic-logger": "~0.2.0",
-        "isotropic-make": "~0.12.0"
+        "isotropic-error": "~0.13.1",
+        "isotropic-initializable": "~0.11.0",
+        "isotropic-later": "~0.13.1",
+        "isotropic-logger": "~0.3.1",
+        "isotropic-make": "~0.13.1"
     },
     "description": "A reusable and extendable platform to manage local process clusters",
     "devDependencies": {
-        "bunyan-stream-isotropic": "~0.2.0",
-        "isotropic-dev-dependencies": "~0.1.0"
+        "bunyan-stream-isotropic": "~0.3.1",
+        "eslint": "~9.8.0",
+        "isotropic-dev-dependencies": "~0.3.1"
     },
     "engines": {
-        "node": "^14.15.5",
-        "npm": "^7.5.4"
+        "node": "^22.5.1",
+        "npm": "^10.8.2"
     },
     "files": [
         "lib"
@@ -29,17 +27,17 @@
     ],
     "license": "BSD-3-Clause",
     "name": "isotropic-cluster",
-    "repository": "ibi-group/isotropic-cluster",
+    "repository": "github:ibi-group/isotropic-cluster",
     "scripts": {
-        "build": "cross-env BABEL_ENV=node-minify babel --config-file ./node_modules/isotropic-dev-dependencies/config/babel.json js -d lib",
-        "lint": "eslint -c ./node_modules/isotropic-dev-dependencies/config/eslint-module.json --no-eslintrc --resolve-plugins-relative-to ./node_modules/isotropic-dev-dependencies js test",
-        "_postinstall": "husky install ./node_modules/isotropic-dev-dependencies/hooks",
-        "postpublish": "pinst --enable",
-        "posttest": "[ -z \"$npm_config_coverage\" ] || nyc --nycrc-path ./node_modules/isotropic-dev-dependencies/config/nyc.json check-coverage",
+        "build": "cross-env BABEL_ENV=node-minify babel --config-file ./node_modules/isotropic-dev-dependencies/config/babel.json js -d lib --delete-dir-on-start",
+        "lint": "eslint js test",
+        "postprepare": "node ./node_modules/isotropic-dev-dependencies/lib/install-git-hooks.js",
+        "posttest": "[ -z \"$npm_config_coverage\" ] || c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json check-coverage",
         "prepare": "npm run build",
-        "prepublishOnly": "npm test --coverage && pinst --disable",
+        "prepublishOnly": "npm test --coverage",
         "pretest": "npm run lint",
-        "test": "cross-env BABEL_ENV=test nyc --nycrc-path ./node_modules/isotropic-dev-dependencies/config/nyc.json mocha"
+        "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"
     },
-    "version": "0.2.0"
+    "type": "module",
+    "version": "0.4.0"
 }

package/lib/cluster-master.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _cluster2=_interopRequireDefault(require("cluster")),_isotropicError=_interopRequireDefault(require("isotropic-error")),_isotropicInitializable=_interopRequireDefault(require("isotropic-initializable")),_isotropicLogger=_interopRequireDefault(require("isotropic-logger")),_isotropicMake=_interopRequireDefault(require("isotropic-make")),_path2=_interopRequireDefault(require("path")),_process2=_interopRequireDefault(require("process"));function _interopRequireDefault(a){return a&&a.__esModule?a:{default:a}}const _moduleLogger=_isotropicLogger.default.child({module:_path2.default.basename(__filename,_path2.default.extname(__filename))},!0);var _default=(0,_isotropicMake.default)(_isotropicInitializable.default,{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((0,_isotropicError.default)({details:{message:a,workerId:e.id},error:b,message:"Error sending message to worker"})):c()}):d((0,_isotropicError.default)({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=>{_cluster2.default.removeListener(a,this._clusterListenerByEventName[a])}),this._clusterListenerByEventName=void 0,this._workerTimeByWorkerWeakMapByTag=void 0,Reflect.apply(_isotropicInitializable.default.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"),_cluster2.default.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,_cluster2.default.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:(0,_isotropicError.default)({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:(0,_isotropicError.default)({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(_isotropicInitializable.default.prototype._init,this,a)},_initialize(...a){_moduleLogger.info("Initializing master");const[{workerArgs:b,workerScript:c,workerSilent:d,workerStdio:e}={}]=a;_cluster2.default.setupMaster({args:"undefined"==typeof b?_process2.default.argv.slice(2):b,exec:"undefined"==typeof c?_process2.default.argv[1]:c,silent:"undefined"!=typeof d&&d,stdio:e}),Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster2.default.on(a,this._clusterListenerByEventName[a])})},_removeWorker({worker:a}){return a.id in this._workerById&&this._publish("removeWorker",{worker:a}),this}},{_events:{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"}}});exports.default=_default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../js/cluster-master.js"],"names":["_moduleLogger","_logger","child","module","_path","basename","__filename","extname","_Initializable","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","_cluster","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","setupMaster","_process","argv","slice","exec","silent","stdio","_events","addWorker","allowPublicPublish","defaultFunction","removeWorker","completeOnce","shutDownComplete","publishOnce","workerDisconnect","workerError","workerExit","workerFork","workerListening","workerMessage","workerOnline","workerReady"],"mappings":"4lBAQA,KAAMA,CAAAA,aAAa,CAAGC,yBAAQC,KAAR,CAAc,CAChCC,MAAM,CAAEC,eAAMC,QAAN,CAAeC,UAAf,CAA2BF,eAAMG,OAAN,CAAcD,UAAd,CAA3B,CADwB,CAAd,IAAtB,C,aAIe,2BAAME,+BAAN,CAAsB,CACjCC,IAAI,CAAE,CACFC,WAAW,CAAXA,CAAW,CAAG,CADZ,EAEF,EAFA,CAEI,CACJ,MAAO,MAAKC,OAAL,CACH,KAAKC,QAAL,CAAc,MAAd,CAAsB,CAClBF,WAAW,CAAXA,CADkB,CAAtB,CADG,CAIH,IACP,CATgC,CAUjCG,UAAU,CAAE,CACRC,GAAG,CAAHA,CAAG,CAAG,EADE,EAER,EAFM,CAEF,CACJ,GAAIC,CAAAA,CAAJ,CACIC,CAAgB,IADpB,CAEIC,CAAyB,CAAG,KAAKC,+BAAL,CAAqCJ,CAArC,CAFhC,CAIKG,CALD,GAMAA,CAAyB,CAAG,GAAIE,CAAAA,OANhC,CAOA,KAAKD,+BAAL,CAAqCJ,CAArC,EAA4CG,CAP5C,EAUJ,IAAK,KAAMG,CAAAA,CAAX,GAAqB,MAAKC,QAA1B,CAAoC,CAChC,KAAMC,CAAAA,CAAU,CAAGL,CAAyB,CAACM,GAA1B,CAA8BH,CAA9B,CAAnB,CAEA,GAAIE,CAAJ,CACQA,CAAU,CAAGN,CADrB,GAEQD,CAAY,CAAGK,CAFvB,CAGQJ,CAAgB,CAAGM,CAH3B,MAKO,CACHP,CAAY,CAAGK,CADZ,CAEH,KACH,CACJ,CAGD,MADAH,CAAAA,CAAyB,CAACO,GAA1B,CAA8BT,CAA9B,CAA4CU,IAAI,CAACC,GAAL,EAA5C,CACA,CAAOX,CACV,CAtCgC,CAuCjCY,IAAI,CAAE,CACFC,OAAO,CAAPA,CADE,CAEFC,EAAE,CAAFA,CAAE,CAAG,KAAKR,QAFR,CAAF,CAGD,CAOC,MANKS,CAAAA,KAAK,CAACC,OAAN,CAAcF,CAAd,CAML,GALIA,CAAE,CAAG,CACDA,CADC,CAKT,EAAOG,OAAO,CAACC,GAAR,CAAYJ,CAAE,CAACK,GAAH,CAAOL,CAAE,EAAI,GAAIG,CAAAA,OAAJ,CAAY,CAACG,CAAD,CAAUC,CAAV,GAAqB,CAC7D,KAAMhB,CAAAA,CAAM,CAAiB,QAAd,QAAOS,CAAAA,CAAP,CACX,KAAKQ,WAAL,CAAiBR,CAAjB,CADW,CAEXA,CAFJ,CAIIT,CAAM,EAAIA,CAAM,CAACO,IALwC,CAMzDP,CAAM,CAACO,IAAP,CAAYC,CAAZ,CAAqBU,CAAK,EAAI,CACtBA,CADsB,CAEtBF,CAAM,CAAC,4BAAO,CACVG,OAAO,CAAE,CACLX,OAAO,CAAPA,CADK,CAELY,QAAQ,CAAEpB,CAAM,CAACqB,EAFZ,CADC,CAKVH,KAAK,CAALA,CALU,CAMVV,OAAO,CAAE,iCANC,CAAP,CAAD,CAFgB,CAWtBO,CAAO,EAEd,CAbD,CANyD,CAqBzDC,CAAM,CAAC,4BAAO,CACVG,OAAO,CAAE,CACLX,OAAO,CAAPA,CADK,CAELC,EAAE,CAAFA,CAFK,CADC,CAKVD,OAAO,CAAE,6BALC,CAAP,CAAD,CAQb,CA7B+B,CAAb,CAAZ,CA8BV,CA/EgC,CAgFjCc,QAAQ,EAAI,CACR,MAAO,MAAK9B,QAAL,CAAc,UAAd,CACV,CAlFgC,CAmFjC,GAAI+B,CAAAA,UAAJ,EAAkB,CACd,MAAO,MAAKN,WACf,CArFgC,CAsFjC,GAAIO,CAAAA,OAAJ,EAAe,CACX,MAAO,MAAKvB,QACf,CAxFgC,CAyFjCwB,UAAU,CAAE,CACRzB,MAAM,CAANA,CADQ,CAAF,CAEP,CACC,MAAO,MAAKR,QAAL,CAAc,WAAd,CAA2B,CAC9BQ,MAAM,CAANA,CAD8B,CAA3B,CAGV,CA/FgC,CAgGjC0B,QAAQ,CAAE,GAAGC,CAAL,CAAW,OACX,MAAKpC,OADM,EAEX,KAAKqC,UAAL,CAAgB,kBAAhB,CAAoC,UAApC,CAFW,KAGX,MAAKN,QAAL,EAHW,OAOf,KAAK/B,OAAL,OAPe,CASfsC,MAAM,CAACC,IAAP,CAAY,KAAKC,2BAAjB,EAA8CC,OAA9C,CAAsDC,CAAS,EAAI,CAC/DC,kBAASC,cAAT,CAAwBF,CAAxB,CAAmC,KAAKF,2BAAL,CAAiCE,CAAjC,CAAnC,CACH,CAFD,CATe,CAaf,KAAKF,2BAAL,OAbe,CAef,KAAKjC,+BAAL,OAfe,CAiBfsC,OAAO,CAACC,KAAR,CAAcjD,gCAAekD,SAAf,CAAyBZ,QAAvC,CAAiD,IAAjD,CAAuDC,CAAvD,CAjBe,CAkBlB,CAlHgC,CAmHjCY,eAAe,CAAE,CACbC,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADO,CAAF,CAIZ,CACC,KAAKiB,WAAL,CAAiBjB,CAAM,CAACqB,EAAxB,EAA8BrB,CAD/B,CAEC,KAAKC,QAAL,CAAgB4B,MAAM,CAACY,MAAP,CAAc,KAAKxB,WAAnB,CACnB,CA1HgC,CA2HjCyB,UAAU,CAAE,CACRF,IAAI,CAAE,CACFlD,WAAW,CAAXA,CADE,CADE,CAAF,CAIP,MACsB,CAAd,CAAAA,CADR,EAEKV,aAAa,CAAC+D,IAAd,CAAmB,uBAAnB,CAFL,CAIKT,kBAAS7C,IAAT,EAJL,CAKKC,CAAW,EAAI,CAEtB,CAtIgC,CAuIjCsD,kBAAkB,CAAE,CAChBJ,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADU,CAAF,CAIf,CACC,MAAO,MAAKiB,WAAL,CAAiBjB,CAAM,CAACqB,EAAxB,CADR,CAEC,KAAKpB,QAAL,CAAgB4B,MAAM,CAACY,MAAP,CAAc,KAAKxB,WAAnB,CACnB,CA9IgC,CA+IjC4B,cAAc,EAAI,CASd,MARAjE,CAAAA,aAAa,CAAC+D,IAAd,CAAmB,uBAAnB,CAQA,CANA,KAAKpD,OAAL,GAMA,CAJA2C,kBAASY,UAAT,CAAoB,IAAM,CACtB,KAAKtD,QAAL,CAAc,kBAAd,CACH,CAFD,CAIA,CAAO,IACV,CAzJgC,CA0JjCuD,sBAAsB,EAAI,CACtBnE,aAAa,CAAC+D,IAAd,CAAmB,2BAAnB,CACH,CA5JgC,CA6JjCK,sBAAsB,CAAE,CACpBR,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADc,CAAF,CAInB,CACCpB,aAAa,CAAC+D,IAAd,CAAmB,CACfvB,QAAQ,CAAEpB,CAAM,CAACqB,EADF,CAAnB,CAEG,qBAFH,CADD,CAKC,KAAK4B,aAAL,CAAmB,CACfjD,MAAM,CAANA,CADe,CAAnB,CAGH,CAzKgC,CA0KjCkD,iBAAiB,CAAE,CACfV,IAAI,CAAE,CACFtB,KAAK,CAALA,CADE,CAEFlB,MAAM,CAANA,CAFE,CADS,CAAF,CAKd,CACCpB,aAAa,CAACuE,KAAd,CAAoB,CAChBjC,KAAK,CAAE,4BAAO,CACVC,OAAO,CAAE,CACLC,QAAQ,CAAEpB,CAAM,CAACqB,EADZ,CADC,CAIVH,KAAK,CAALA,CAJU,CAKVV,OAAO,CAAE,cALC,CAAP,CADS,CAQhBY,QAAQ,CAAEpB,CAAM,CAACqB,EARD,CAApB,CASG,cATH,CADD,CAYC,KAAK4B,aAAL,CAAmB,CACfjD,MAAM,CAANA,CADe,CAAnB,CAGH,CA9LgC,CA+LjCoD,gBAAgB,CAAE,CACdZ,IAAI,CAAE,CACFa,IAAI,CAAJA,CADE,CAEFC,MAAM,CAANA,CAFE,CAGFtD,MAAM,CAANA,CAHE,CADQ,CAAF,CAMb,CACKA,CAAM,CAACuD,qBADZ,CAEK3E,aAAa,CAAC+D,IAAd,CAAmB,CACfU,IAAI,CAAJA,CADe,CAEfC,MAAM,CAANA,CAFe,CAGflC,QAAQ,CAAEpB,CAAM,CAACqB,EAHF,CAAnB,CAIG,2BAJH,CAFL,CAOYgC,CAPZ,CAQKzE,aAAa,CAACuE,KAAd,CAAoB,CAChBE,IAAI,CAAJA,CADgB,CAEhBC,MAAM,CAANA,CAFgB,CAGhBlC,QAAQ,CAAEpB,CAAM,CAACqB,EAHD,CAApB,CAIG,0BAJH,CARL,CAcKzC,aAAa,CAACsC,KAAd,CAAoB,CAChBmC,IAAI,CAAJA,CADgB,CAEhBC,MAAM,CAANA,CAFgB,CAGhBlC,QAAQ,CAAEpB,CAAM,CAACqB,EAHD,CAApB,CAIG,aAJH,CAdL,CAqBC,KAAK4B,aAAL,CAAmB,CACfjD,MAAM,CAANA,CADe,CAAnB,CArBD,CAyBK,KAAKT,OAzBV,GA0BKX,aAAa,CAAC+D,IAAd,CAAmB,uBAAnB,CA1BL,CA4BK,KAAKtD,IAAL,EA5BL,CA8BF,CAnOgC,CAoOjCmE,gBAAgB,CAAE,CACdhB,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADQ,CAAF,CAIb,CACCpB,aAAa,CAAC+D,IAAd,CAAmB,CACfvB,QAAQ,CAAEpB,CAAM,CAACqB,EADF,CAAnB,CAEG,qBAFH,CADD,CAKCrB,CAAM,CAACyD,EAAP,CAAU,OAAV,CAAmBvC,CAAK,EAAI,CACxB,KAAK1B,QAAL,CAAc,aAAd,CAA6B,CACzB0B,KAAK,CAAE,4BAAO,CACVC,OAAO,CAAE,CACLnB,MAAM,CAANA,CADK,CADC,CAIVkB,KAAK,CAALA,CAJU,CAKVV,OAAO,CAAE,iBALC,CAAP,CADkB,CAQzBR,MAAM,CAANA,CARyB,CAA7B,CAUH,CAXD,CAYH,CAzPgC,CA0PjC0D,qBAAqB,CAAE,CACnBlB,IAAI,CAAE,CACFmB,OAAO,CAAPA,CADE,CAEF3D,MAAM,CAANA,CAFE,CADa,CAAF,CAKlB,CACCpB,aAAa,CAAC+D,IAAd,CAAmB,CACfgB,OAAO,CAAEA,CAAO,CAACA,OADF,CAEfC,IAAI,CAAED,CAAO,CAACC,IAFC,CAGfxC,QAAQ,CAAEpB,CAAM,CAACqB,EAHF,CAAnB,CAIG,qBAJH,CAKH,CArQgC,CAsQjCwC,mBAAmB,CAAEC,CAAF,CAAS,CACxB,GAAIA,CAAK,CAACtB,IAAN,CAAWhC,OAAX,EAAsBsD,CAAK,CAACtB,IAAN,CAAWhC,OAAX,CAAmBuD,IAA7C,CAAmD,CAC/C,KAAMC,CAAAA,CAAM,CAAG,KAAM,uBAAsBF,CAAK,CAACtB,IAAN,CAAWhC,OAAX,CAAmBuD,IAAK,EAApD,CAAf,CAEsB,UAAlB,QAAOC,CAAAA,CAHoC,EAI3C5B,OAAO,CAACC,KAAR,CAAc2B,CAAd,CAAsB,IAAtB,CAA4B,CACxBF,CADwB,CAA5B,CAIP,CACJ,CAhRgC,CAiRjCG,kBAAkB,CAAE,CAChBzB,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADU,CAAF,CAIf,CACCpB,aAAa,CAAC+D,IAAd,CAAmB,CACfvB,QAAQ,CAAEpB,CAAM,CAACqB,EADF,CAAnB,CAEG,sBAFH,CADD,CAKC,KAAM6C,CAAAA,CAAQ,CAAG1D,CAAO,EAAI,CACR,OAAZ,GAAAA,CADoB,GAEpBR,CAAM,CAACmC,cAAP,CAAsB,SAAtB,CAAiC+B,CAAjC,CAFoB,CAIpB,KAAK1E,QAAL,CAAc,aAAd,CAA6B,CACzBQ,MAAM,CAANA,CADyB,CAA7B,CAJoB,CAQ3B,CARD,CAUAA,CAAM,CAACyD,EAAP,CAAU,SAAV,CAAqBS,CAArB,CACH,CArSgC,CAsSjCC,iBAAiB,CAAE,CACf3B,IAAI,CAAE,CACFxC,MAAM,CAANA,CADE,CADS,CAAF,CAId,CACCpB,aAAa,CAAC+D,IAAd,CAAmB,CACfvB,QAAQ,CAAEpB,CAAM,CAACqB,EADF,CAAnB,CAEG,yBAFH,CADD,CAKC,KAAKI,UAAL,CAAgB,CACZzB,MAAM,CAANA,CADY,CAAhB,CAGH,CAlTgC,CAmTjCoE,KAAK,CAAE,GAAGzC,CAAL,CAAW,CA+CZ,MA9CA,MAAKpC,OAAL,GA8CA,CA5CA,KAAKwC,2BAAL,CAAmC,CAC/Be,UAAU,CAAE9C,CAAM,EAAI,CAClB,KAAKR,QAAL,CAAc,kBAAd,CAAkC,CAC9BQ,MAAM,CAANA,CAD8B,CAAlC,CAGH,CAL8B,CAM/BqE,IAAI,CAAE,CAACrE,CAAD,CAASqD,CAAT,CAAeC,CAAf,GAA0B,CAC5B,KAAK9D,QAAL,CAAc,YAAd,CAA4B,CACxB6D,IAAI,CAAJA,CADwB,CAExBC,MAAM,CAANA,CAFwB,CAGxBtD,MAAM,CAANA,CAHwB,CAA5B,CAKH,CAZ8B,CAa/BX,IAAI,CAAEW,CAAM,EAAI,CACZ,KAAKR,QAAL,CAAc,YAAd,CAA4B,CACxBQ,MAAM,CAANA,CADwB,CAA5B,CAGH,CAjB8B,CAkB/BsE,SAAS,CAAE,CAACtE,CAAD,CAAS2D,CAAT,GAAqB,CAC5B,KAAKnE,QAAL,CAAc,iBAAd,CAAiC,CAC7BmE,OAAO,CAAPA,CAD6B,CAE7B3D,MAAM,CAANA,CAF6B,CAAjC,CAIH,CAvB8B,CAwB/BQ,OAAO,CAAE,CAACR,CAAD,CAASQ,CAAT,CAAkB+D,CAAlB,GAA6B,CAClC,KAAK/E,QAAL,CAAc,eAAd,CAA+B,CAC3B+E,MAAM,CAANA,CAD2B,CAE3B/D,OAAO,CAAPA,CAF2B,CAG3BR,MAAM,CAANA,CAH2B,CAA/B,CAKH,CA9B8B,CA+B/BwE,MAAM,CAAExE,CAAM,EAAI,CACd,KAAKR,QAAL,CAAc,cAAd,CAA8B,CAC1BQ,MAAM,CAANA,CAD0B,CAA9B,CAGH,CAnC8B,CA4CnC,CANA,KAAKiB,WAAL,CAAmBY,MAAM,CAAC4C,MAAP,CAAc,IAAd,CAMnB,CAJA,KAAKxE,QAAL,CAAgB,EAIhB,CAFA,KAAKH,+BAAL,CAAuC+B,MAAM,CAAC4C,MAAP,CAAc,IAAd,CAEvC,CAAOrC,OAAO,CAACC,KAAR,CAAcjD,gCAAekD,SAAf,CAAyB8B,KAAvC,CAA8C,IAA9C,CAAoDzC,CAApD,CACV,CAnWgC,CAoWjC+C,WAAW,CAAE,GAAG/C,CAAL,CAAW,CAClB/C,aAAa,CAAC+D,IAAd,CAAmB,qBAAnB,CADkB,CAGlB,KAAM,CAAC,CACHgC,UAAU,CAAVA,CADG,CAEHC,YAAY,CAAZA,CAFG,CAGHC,YAAY,CAAZA,CAHG,CAIHC,WAAW,CAAXA,CAJG,EAKH,EALE,EAKInD,CALV,CAOAO,kBAAS6C,WAAT,CAAqB,CACjBpD,IAAI,CAAwB,WAAtB,QAAOgD,CAAAA,CAAP,CACFK,kBAASC,IAAT,CAAcC,KAAd,CAAoB,CAApB,CADE,CAEFP,CAHa,CAIjBQ,IAAI,CAA0B,WAAxB,QAAOP,CAAAA,CAAP,CACFI,kBAASC,IAAT,CAAc,CAAd,CADE,CAEFL,CANa,CAOjBQ,MAAM,CAA0B,WAAxB,QAAOP,CAAAA,CAAT,EAEFA,CATa,CAUjBQ,KAAK,CAAEP,CAVU,CAArB,CAVkB,CAuBlBjD,MAAM,CAACC,IAAP,CAAY,KAAKC,2BAAjB,EAA8CC,OAA9C,CAAsDC,CAAS,EAAI,CAC/DC,kBAASuB,EAAT,CAAYxB,CAAZ,CAAuB,KAAKF,2BAAL,CAAiCE,CAAjC,CAAvB,CACH,CAFD,CAGH,CA9XgC,CA+XjCgB,aAAa,CAAE,CACXjD,MAAM,CAANA,CADW,CAAF,CAEV,CAOC,MANIA,CAAAA,CAAM,CAACqB,EAAP,GAAa,MAAKJ,WAMtB,EALI,KAAKzB,QAAL,CAAc,cAAd,CAA8B,CAC1BQ,MAAM,CAANA,CAD0B,CAA9B,CAKJ,CAAO,IACV,CAzYgC,CAAtB,CA0YZ,CACCsF,OAAO,CAAE,CACLC,SAAS,CAAE,CACPC,kBAAkB,GADX,CAEPC,eAAe,CAAE,iBAFV,CADN,CAKLpG,IAAI,CAAE,CACFmG,kBAAkB,GADhB,CAEFC,eAAe,CAAE,YAFf,CALD,CASLC,YAAY,CAAE,CACVF,kBAAkB,GADR,CAEVC,eAAe,CAAE,oBAFP,CATT,CAaLnE,QAAQ,CAAE,CACNkE,kBAAkB,GADZ,CAENG,YAAY,GAFN,CAGNF,eAAe,CAAE,gBAHX,CAbL,CAkBLG,gBAAgB,CAAE,CACdJ,kBAAkB,GADJ,CAEdC,eAAe,CAAE,wBAFH,CAGdI,WAAW,GAHG,CAlBb,CAuBLC,gBAAgB,CAAE,CACdN,kBAAkB,GADJ,CAEdC,eAAe,CAAE,wBAFH,CAvBb,CA2BLM,WAAW,CAAE,CACTP,kBAAkB,GADT,CAETC,eAAe,CAAE,mBAFR,CA3BR,CA+BLO,UAAU,CAAE,CACRR,kBAAkB,GADV,CAERC,eAAe,CAAE,kBAFT,CA/BP,CAmCLQ,UAAU,CAAE,CACRT,kBAAkB,GADV,CAERC,eAAe,CAAE,kBAFT,CAnCP,CAuCLS,eAAe,CAAE,CACbV,kBAAkB,GADL,CAEbC,eAAe,CAAE,uBAFJ,CAvCZ,CA2CLU,aAAa,CAAE,CACXX,kBAAkB,GADP,CAEXC,eAAe,CAAE,qBAFN,CA3CV,CA+CLW,YAAY,CAAE,CACVZ,kBAAkB,GADR,CAEVC,eAAe,CAAE,oBAFP,CA/CT,CAmDLY,WAAW,CAAE,CACTb,kBAAkB,GADT,CAETC,eAAe,CAAE,mBAFR,CAnDR,CADV,CA1YY,C","sourcesContent":["import _cluster from 'cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'path';\nimport _process from 'process';\n\nconst _moduleLogger = _logger.child({\n    module: _path.basename(__filename, _path.extname(__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 master');\n\n        const [{\n            workerArgs,\n            workerScript,\n            workerSilent,\n            workerStdio\n        } = {}] = args;\n\n        _cluster.setupMaster({\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    _events: {\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"]}