@aj-shadow/z-abs-corelayer-server 0.0.0-aj-beta.221

package/project/server/worker/worker-channel.js

@@ -0,0 +1,175 @@
+
+'use strict';
+
+
+class WorkerChannel {
+  constructor(id, type, port) {
+    this.id = id;
+    this.type = type;
+    this.port = port;
+    this.responses = new Map();
+    this.currentResponseId = 0;
+    this.cbExitKill = null;
+    this.exitType = WorkerChannel.CB_NONE;
+    this.state = WorkerChannel.STATE_OPEN;
+  }
+  
+  static MSG_COMMAND = 0;
+  static MSG_REQUEST = 1;
+  static MSG_RESPONSE = 2;
+  static MSG_METHOD = 3;
+  static MSG_MESSAGE = 4;
+  
+  static MSG_TYPES = ['COMMAND', 'REQUEST', 'RESPONSE', 'METHOD', 'MESSAGE'];
+  
+  static STATE_OPEN = 0;
+  static STATE_STOPPED = 1;
+  static STATE_KILLED = 2;
+  
+  static TYPE_MAIN = 0;
+  static TYPE_THREAD = 1;
+  static TYPES = ['MAIN', 'THREAD'];
+  
+  static CB_NONE = -1;
+  static CB_EXIT = 0;
+  static CB_KILL = 1;
+  
+  start() {
+    this.state = WorkerChannel.STATE_OPEN;
+  }
+  
+  stop(cbExit) {
+    if(0 === this.responses.size) {
+      cbExit(() => {
+        this.state = WorkerChannel.STATE_STOPPED;
+      });
+    }
+    else {
+      this.cbExitKill = cbExit;
+      this.exitType = WorkerChannel.CB_EXIT;
+    }
+  }
+  
+  kill(cbKill) {
+    if(0 === this.responses.size) {
+      cbKill(() => {
+        this.state = WorkerChannel.STATE_KILLED;
+      });
+    }
+    else {
+      this.cbExitKill = cbKill;
+      this.exitType = WorkerChannel.CB_KILL;
+    }
+  }
+  
+  dead(done) {
+    this.responses.forEach((response) => {
+      response.done();
+    });
+    process.nextTick(done);
+  }
+  
+  command(msgId, done, transferList, ...params) {
+    const responseId = this.currentResponseId++;
+    this.responses.set(responseId, {
+      msgId,
+      type: 'request',
+      done
+    });
+    this.port.postMessage({
+      type: WorkerChannel.MSG_COMMAND,
+      msgId: msgId,
+      responseId: responseId,
+      params: params
+    }, transferList);
+  }
+  
+  request(msgId, done, transferList, ...params) {
+    if(WorkerChannel.STATE_OPEN === this.state) {
+      const responseId = this.currentResponseId++;
+      this.responses.set(responseId, {
+        msgId,
+        type: 'request',
+        done
+      });
+      this.port.postMessage({
+        type: WorkerChannel.MSG_REQUEST,
+        msgId: msgId,
+        responseId: responseId,
+        params: params
+      }, transferList);
+    }
+    else {
+      ddb.warning(this.id, 'Channel not open(request).', msgId, params);
+      process.nextTick(done, new Error('Channel not open.'), msgId, params);
+    }
+  }
+  
+  response(message, ...params) {
+    this.port.postMessage({
+      type: WorkerChannel.MSG_RESPONSE,
+      responseId: message.responseId,
+      msgId: message.msgId,
+      params: params
+    });
+  }
+  
+  method(msgId, done, transferList, ...params) {
+    if(WorkerChannel.STATE_OPEN === this.state) {
+      const responseId = this.currentResponseId++;
+      this.responses.set(responseId, {
+        msgId,
+        type: 'method',
+        done
+      });
+      this.port.postMessage({
+        type: WorkerChannel.MSG_METHOD,
+        msgId: msgId,
+        responseId: responseId,
+        params: params
+      }, transferList);
+    }
+    else {
+      ddb.warning(this.id, 'Channel not open(method).', msgId, params);
+      process.nextTick(done, new Error('Channel not open(method).'));
+    }
+  }
+  
+  message(msgId, transferList, ...params) {
+    if(WorkerChannel.STATE_OPEN === this.state) {
+      this.port.postMessage({
+        type: WorkerChannel.MSG_MESSAGE,
+        msgId: msgId,
+        params: params
+      }, transferList);
+    }
+    else {
+      ddb.warning(this.id, 'Channel not open(message).', msgId, params);
+    }
+  }
+  
+  handleResponse(message, cb) {
+    const cbResponse = this.responses.get(message.responseId);
+    if(cb) {
+      cb(message.msgId, ...message.params);
+    }
+    if(cbResponse) {
+      this.responses.delete(message.responseId);
+      cbResponse.done(...message.params);
+      if(this.cbExitKill) {
+        if(0 === this.responses.size) {
+          if(WorkerChannel.STATE_KILLED === this.state) {
+          }
+          this.cbExitKill(() => {
+            this.state = this.exitType;
+          });
+          this.cbExitKill = null;
+          this.exitType = WorkerChannel.CB_NONE;
+        }    
+      }
+    }
+  }
+}  
+
+
+module.exports = WorkerChannel;

package/project/server/worker/worker-core.js

@@ -0,0 +1,58 @@
+
+'use strict';
+
+const HighResolutionTimestamp = require('../high-resolution-timestamp');
+const { Worker, isMainThread, parentPort, workerData, threadId } = require('worker_threads');
+
+if(isMainThread) {
+  
+  class WorkerCore {
+    constructor(typeName, instanceId, factoryThreadPath, workerPool) {
+      this.typeName = typeName;
+      this.instanceId = instanceId;
+      this.factoryThreadPath = factoryThreadPath;
+      this.workerPool = workerPool;
+      this.id = -1;
+      this.worker = null;
+      this.error = null;
+    }
+    
+    start(cbExit) {
+      const releaseData = Reflect.get(global, 'release-data@actorjs_global');
+      this.worker = new Worker(__filename, {
+        workerData: {
+          appName: releaseData.appName,
+          releaseStep: releaseData.releaseStep,
+          organization: releaseData.organization,
+          path: this.factoryThreadPath,
+          dateStamp: HighResolutionTimestamp.dateStamp,
+          timeStamp: HighResolutionTimestamp.timeStamp
+        }
+      });
+      this.worker.on('exit', (exitCode) => {
+        this.worker = null;
+        //ddb.info(`Worker[${this.id}] exitCode:${exitCode}`, this.typeName);
+        process.nextTick(cbExit, exitCode);
+      });
+      this.worker.on('error', (err) => {
+        console.log(`WORKER ERROR[${this.typeName}:${this.id}]:`, err.valueOf());
+        ddb.error(`WORKER ERROR[${this.typeName}:${this.id}]:`, err);
+        this.error = err;
+      });
+    }
+  }
+
+module.exports = WorkerCore;
+
+}
+else {
+  Reflect.set(global, 'release-data@actorjs_global', {
+    appName: workerData.appName,
+    releaseStep: workerData.releaseStep,
+    organization: workerData.organization
+  });
+  HighResolutionTimestamp.workerInit(workerData.dateStamp, workerData.timeStamp);
+  const workerThread = new (require(workerData.path))();
+  workerThread._init(parentPort);
+}
+

package/project/server/worker/worker-main.js

@@ -0,0 +1,165 @@
+
+'use strict';
+
+const WorkerChannel = require('./worker-channel');
+
+
+class WorkerMain {
+  constructor() {
+    this.id = -1;
+    this.parentObject = null;
+    this.typeName = '';
+    this.instanceId = -1;
+    this.globalInstanceId = -1;
+    this.workerPool = null;
+    this.workerCore = null;
+    this.channel = null;
+    this.cbStart = null;
+    this.cbStop = null;
+    this.state = WorkerMain.STATE_NONE;
+  }
+  
+  static STATE_NONE = 0;
+  static STATE_STARTED = 1;
+  static STATED_STOPPED = 2;
+  static STATED_KILLED = 3;
+  static STATES = ['NONE', 'STARTED', 'STOPPED', 'KILLED'];
+  
+  _init(typeName, instanceId, globalInstanceId, workerPool, workerCore) {
+    this.typeName = typeName;
+    this.instanceId = instanceId;
+    this.globalInstanceId = globalInstanceId;
+    this.workerPool = workerPool;
+    this.workerCore = workerCore;
+  }
+  
+  start(id, parentObject, cbStart, cbStop) {
+    this.id = id;
+    this.workerCore.id = id;
+    this.parentObject = parentObject;
+    this.cbStart = cbStart;
+    this.cbStop = cbStop;
+    if(WorkerMain.STATE_NONE !== this.state && WorkerMain.STATED_STOPPED !== this.state) {
+      process.nextTick((self, WorkerMain) => {
+        if(self.cbStart) {
+          self.cbStart(new Error(`Can not start Worker in state: '${WorkerMain.STATES[self.state]}'.`));
+          self.cbStart = null;
+        }
+      }, this, WorkerMain);
+      return;
+    }
+    if(null === this.channel) {
+      this.workerCore.start((exitCode) => {
+        this.state = WorkerMain.STATED_KILLED;
+        if(this.cbStop) {
+          if(this.channel) {
+            this.channel.dead(() => {
+              if(this.cbStart) {
+                this.cbStart(new Error('Can not start Worker, it died. exitCode: ' + exitCode + '.'));
+                this.cbStart = null;
+              }
+              if(this.cbStop) {
+                this.cbStop(exitCode);
+                this.cbStop = null;
+                this.channel = null;
+              }
+            });
+          }
+          else {
+            this.cbStop(exitCode);
+            this.cbStop = null;
+          }
+        }
+      });
+      this.channel = new WorkerChannel(id, WorkerChannel.TYPE_MAIN, this.workerCore.worker);
+      this.workerCore.worker.on('message', (message) => {
+        if(WorkerChannel.MSG_RESPONSE === message.type) {
+          if(this.channel) {
+            this.channel.handleResponse(message);
+          }
+          else {
+            ddb.warning('DROPPED', message);
+          }
+        }
+        else {
+          const func = Reflect.get(this.parentObject, `on${message.msgId}`).bind(this.parentObject);
+          if(null !== func) {
+            if(WorkerChannel.MSG_MESSAGE === message.type) {
+              func(this.id, ...message.params);
+            }
+            else if(WorkerChannel.MSG_METHOD === message.type) {
+              func((err, ...params) => {
+                if(this.channel) {
+                  this.channel.response(message, err, ...params);
+                }
+                else {
+                  ddb.warning('DROPPED', message);
+                }
+              }, ...message.params);
+            }
+          }
+          else {
+           ddb.error(`Error function 'on${message.msgId}' not found.`);
+          }
+        }
+      });
+    }
+    this.channel.start(this.id);
+    this.channel.command('start', (err) => {
+      this.state = WorkerMain.STATE_STARTED;
+      if(this.cbStart) {
+        this.cbStart(err);
+        this.cbStart = null;
+      }
+    }, undefined, id);
+  }
+  
+  stop(done) {
+    if(WorkerMain.STATE_STARTED !== this.state) {
+      process.nextTick(done);
+      return;
+    }
+    this.channel.stop((cbStopped) => {
+      this.channel.command('stop', (err) => {
+        cbStopped();
+        this.state = WorkerMain.STATED_STOPPED;
+        if(this.cbStop) {
+          this.cbStop(-1);
+          this.cbStop = null;
+        }
+        if(!err && !this.workerCore.error) {
+          //this.id = -1;
+          this.workerCore.id = -1;
+          this.workerPool.store(this);
+        }
+        else {
+          this.channel = null;
+        }
+        done(err);
+      }, undefined);
+    });
+  }
+  
+  kill(done) {
+    if(WorkerMain.STATE_STARTED !== this.state && WorkerMain.STATED_STOPPED !== this.state) {
+      process.nextTick(done);
+      return;
+    }
+    if(this.channel) {
+      this.channel.kill((cbKilled) => {
+        this.channel.command('kill', (err) => {
+          cbKilled();
+          this.state = WorkerMain.STATED_KILLED;
+          this.channel = null;
+          done(err);
+        }, undefined);
+      });
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+}
+
+
+module.exports = WorkerMain;

package/project/server/worker/worker-pool.js

@@ -0,0 +1,94 @@
+
+'use strict';
+
+const WorkerCore = require('./worker-core');
+
+
+class WorkerPool {
+  constructor() {
+    if(1 === ++WorkerPool.global.instancesPool) {
+      WorkerPool.global.intervalId = setInterval((workersQueue) => {
+        workersQueue.forEach((workersTypeData, typeName) => {
+          const now = process.hrtime.bigint();
+          while(1 <= workersTypeData.queue.length) {
+            let timestamp = workersTypeData.queue[0].timestamp;
+            if(now - timestamp < WorkerPool.TIMEOUT_BIG) {
+              break;
+            }
+            else {
+              const workerMain = workersTypeData.queue.shift().workerMain;
+              workerMain.kill(() => {
+                WorkerPool.global.workersInstances.delete(workerMain.globalInstanceId);
+              });
+            }
+          }
+        });
+      }, WorkerPool.TIMEOUT, WorkerPool.global.workersQueue);
+    }
+  }
+  
+  static global = {
+    workersQueue: new Map(),
+    workersInstances: new Map(),
+    instancesPool: 0,
+    instancesWorkes: 0,
+    intervalId: -1
+  };
+  static TIMEOUT = 256000;
+  static TIMEOUT_BIG = BigInt(1000000 * WorkerPool.TIMEOUT);
+  
+  release() {
+    if(0 === --WorkerPool.global.instancesPool) {
+      clearInterval(WorkerPool.global.intervalId);
+      WorkerPool.global.intervalId = -1;
+      WorkerPool.global.workersQueue.forEach((workersTypeData, typeName) => {
+        const now = process.hrtime.bigint();
+        while(1 <= workersTypeData.queue.length) {
+          const workerMain = workersTypeData.queue.shift().workerMain;
+          workerMain.kill(() => {
+            WorkerPool.global.workersInstances.delete(workerMain.globalInstanceId);
+          });
+        }
+      });
+    }
+  }
+  
+  getWorker(typeName, factoryMain, factoryThreadPath) {
+    let workersTypeData = WorkerPool.global.workersQueue.get(typeName);
+    if(!workersTypeData) {
+      workersTypeData = {
+        instanceId: -1,
+        queue: []
+      };
+      WorkerPool.global.workersQueue.set(typeName, workersTypeData);
+    }
+    if(0 === workersTypeData.queue.length) {
+      const globalInstanceId = ++WorkerPool.global.instancesWorkes;
+      const workerMain = new factoryMain();
+      WorkerPool.global.workersInstances.set(globalInstanceId, workerMain);
+      ++workersTypeData.instanceId;
+      workerMain._init(typeName, workersTypeData.instanceId, globalInstanceId, this, new WorkerCore(typeName, workersTypeData.instanceId, factoryThreadPath, this));
+      return workerMain;
+    }
+    else {
+      const workerData = workersTypeData.queue.shift();
+      return workerData.workerMain;
+    }
+  }
+  
+  store(workerMain) {
+    const workersTypeData = WorkerPool.global.workersQueue.get(workerMain.typeName);
+    if(workersTypeData) {
+      workersTypeData.queue.push({
+        workerMain: workerMain,
+        timestamp: process.hrtime.bigint()
+      });
+    }
+    else {
+      ddb.error(`Can not reuse Worker not defined, typeName: '${workerMain.typeName}'`);
+    }
+  }
+}
+
+
+module.exports = WorkerPool;

package/project/server/worker/worker-thread.js

@@ -0,0 +1,128 @@
+
+'use strict';
+
+const WorkerChannel = require('./worker-channel');
+
+
+class WorkerThread {
+  constructor() {
+    this.id = -1;
+    this.channel = null;
+    this.parentPort = null;
+    this.state = WorkerThread.STATE_NONE;
+  }
+  
+  static STATE_NONE = 0;
+  static STATE_STARTED = 1;
+  static STATED_STOPPED = 2;
+  static STATED_KILLED = 3;
+  static STATES = ['NONE', 'STARTED', 'STOPPED', 'KILLED'];
+  
+  handleCommand(message) {
+    if('start' === message.msgId) {
+      this.state = WorkerThread.STATE_STARTED;
+      this.id = message.params[0];
+      this.channel.start(this.id);
+      if(this.onStart) {
+        this.channel.id = this.id;
+        this.onStart(this.id, () => {
+          this.channel.response(message);  
+        });
+      }
+      else {
+        process.nextTick((self) => {
+          self.channel.response(message);
+        }, this);
+      }
+    }
+    else if('stop' === message.msgId) {
+      this.channel.stop((cbStopped) => {
+        if(this.onStop) {
+          this.onStop(() => {
+            this.state = WorkerThread.STATED_STOPPED;
+            this.channel.response(message);
+            cbStopped();
+          });
+        }
+        else {
+          this.state = WorkerThread.STATED_STOPPED;
+          process.nextTick((self, message, cbStopped) => {
+            self.channel.response(message);
+            cbStopped();
+          }, this, message, cbStopped);
+        }
+      });
+    }
+    else if('kill' === message.msgId) {
+      this.state = WorkerThread.STATED_KILLED;
+      this.channel.kill((cbKilled) => {
+        this.parentPort.unref();
+        this.parentPort = null;
+        this.channel.response(message);
+        cbKilled();
+      });
+    }
+  }
+  
+  handleRequest(message) {
+    const func = Reflect.get(this, message.msgId).bind(this);
+    if(func) {
+      func(...message.params, (...params) => {
+        this.channel.response(message, ...params);
+      });
+    }
+    else {
+      throw new Error(`Not Implemented. '${message.msgId}'`);
+    }
+  }
+  
+  _init(parentPort) {
+    this.parentPort = parentPort;
+    this.channel = new WorkerChannel(-1, WorkerChannel.TYPE_THREAD, parentPort);
+    parentPort.on('message', (message) => {
+      if(WorkerChannel.MSG_COMMAND === message.type) {
+        try {
+          this.handleCommand(message);
+        }
+        catch(err) {
+          ddb.error(err.message);
+          this.channel.response(message, err);
+        }
+      }
+      else if(WorkerChannel.MSG_REQUEST === message.type) {
+        try {
+          this.handleRequest(message);
+        }
+        catch(err) {
+          ddb.error(err.message);
+          this.channel.response(message, err);
+        }
+      }
+      else if(WorkerChannel.MSG_RESPONSE === message.type) {
+        try {
+          this.channel.handleResponse(message);
+        }
+        catch(err) {
+          ddb.error(err);
+        }
+      }
+      else if(WorkerChannel.MSG_MESSAGE === message.type) {
+        try {
+          ddb.error('Not Implemented.');
+        }
+        catch(err) {
+          ddb.error(err);
+        }
+      }
+      else {
+        ddb.warning('DROPPED message. type = ', WorkerChannel.MSG_TYPES[message.type]);
+      }
+    });
+    parentPort.on('messageerror', (err) => {
+      ddb.error('messageerror', err);
+    });
+  }
+}
+
+
+module.exports = WorkerThread;