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

package/project/server/log/log-config.js

@@ -0,0 +1,107 @@
+
+'use strict';
+
+let Clc = require('cli-color');
+
+
+class LogConfig {
+  constructor() {
+    this.config = [
+      {
+        name: 'ENGINE',
+        type: 'ENGINE ',
+        color: [
+          Clc.black.bgWhiteBright,
+          Clc.black.bgWhite
+        ],
+        groups: [
+          {
+            name: 'AS',
+            enabled: false,
+            displayName: 'Actor State '
+          },
+          {
+            name: 'AR',
+            enabled: false,
+            displayName: 'Actor Result'
+          },
+          {
+            name: 'DP',
+            enabled: false,
+            displayName: 'Data Plugin '
+          },
+          {
+            name: 'PTH',
+            enabled: false,
+            displayName: 'Actor Paths '
+          },
+          {
+            name: 'BLD',
+            enabled: false,
+            displayName: 'Build Clean '
+          },
+          {
+            name: 'MSG',
+            enabled: false,
+            displayName: 'Message     '
+          },
+          {
+            name: 'TC',
+            enabled: false,
+            displayName: 'Test Case   '
+          }
+        ],
+        groupAll: false
+      },
+      {
+        name: 'DEBUG',
+        type: 'DEBUG  ',
+        color: [
+          Clc.magentaBright.bgWhiteBright,
+          Clc.magentaBright.bgWhite
+        ],
+        groups: [
+          {
+            name: 'AC',
+            enabled: false,
+            displayName: 'Actor'
+          },
+          {
+            name: 'AM',
+            enabled: false,
+            displayName: 'Actor Method'
+          },
+          {
+            name: 'DE',
+            enabled: false,
+            displayName: 'Debug Output'
+          }
+        ],
+        groupAll: false
+      },
+      {
+        name: 'ERROR',
+        type: 'ERROR  ',
+        color: [
+          Clc.redBright.bgWhiteBright,
+          Clc.redBright.bgWhite
+        ],
+        groups: [
+          {
+            name: 'ERR',
+            enabled: true,
+            displayName: 'error       '
+          },
+          {
+            name: 'CATCH',
+            enabled: true,
+            displayName: 'Catch(e)    '
+          }
+        ],
+        groupAll: true
+      },
+    ];
+  }
+}
+
+module.exports = new LogConfig();

package/project/server/log/log-types.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+
+class LogTypes {
+  constructor() {
+    this.ENGINE = 0;
+    this.DEBUG = 1;
+    this.ERROR = 2;
+    this.name = ['Engine', 'Debug ', 'Error '];
+  }
+}
+
+module.exports = new LogTypes();

package/project/server/log/logger-console.js

@@ -0,0 +1,36 @@
+
+'use strict';
+
+const LogConfig = require('./log-config');
+const LogTypes = require('./log-types');
+const HighResolutionDate = require('z-abs-corelayer-cs/clientServer/time/high-resolution-date');
+const Clc = require('cli-color');
+
+
+class LoggerConsole {
+  constructor() {
+    this.id = 0;
+  }
+
+  log(msg) {
+    let id = this.id = LoggerConsole.IDS[this.id];
+//    setImmediate(() => {
+      if(msg.log.length > LoggerConsole.LOG_SIZE) {
+        console.log(LogConfig.config[msg.type].color[id](`${LogTypes.name[msg.type]} : ${new HighResolutionDate(msg.date).getDateMilliSeconds()} : ${LoggerConsole.PID_ZEROS[`${msg.pid}`.length]}${msg.pid} : ${msg.log.substring(0, LoggerConsole.LOG_SIZE - 3)}... : ${LogConfig.config[msg.type].groups[msg.group].displayName} : ${msg.fileName}`));
+      }
+      else {
+        console.log(LogConfig.config[msg.type].color[id](`${LogTypes.name[msg.type]} : ${new HighResolutionDate(msg.date).getDateMilliSeconds()} : ${LoggerConsole.PID_ZEROS[`${msg.pid}`.length]}${msg.pid} : ${msg.log}${LoggerConsole.SPACE_STORE.substring(0, LoggerConsole.LOG_SIZE - msg.log.length)} : ${LogConfig.config[msg.type].groups[msg.group].displayName} : ${msg.fileName}`));
+      }
+      if(undefined !== msg.err) {
+        console.log(LogConfig.config[msg.type].color[id](msg.err));
+      }
+//    });
+  }
+}
+
+LoggerConsole.IDS = [1, 0];
+LoggerConsole.SPACE_STORE = '                                                                                                                                                                                                                                                                                                                                              ';
+LoggerConsole.LOG_SIZE = 256;
+LoggerConsole.PID_ZEROS = ['', '     ', '    ', '   ', '  ',  ' ', ''];
+
+module.exports = LoggerConsole;

package/project/server/log/logger.js

@@ -0,0 +1,114 @@
+
+'use strict';
+
+const LogConfig = require('./log-config');
+const LogTypes = require('./log-types');
+const HighResolutionTimestamp = require('../high-resolution-timestamp');
+const LoggerConsole = require('./logger-console');
+
+
+class Logger {
+  constructor() {
+    this.listener = null;
+    this.loggerImpl = new LoggerConsole();
+    // Create Constants from LogConfig. To avoid double code or exported dependencies.
+    LogConfig.config.forEach((config, index) => {
+      const groups = {}
+      config.groups.forEach((group, index) => {
+        Reflect.set(groups, group.name, index);
+      });
+      Reflect.set(this, config.name, groups);
+    });
+  }
+  
+  engine(group, log, fileName) {
+    this._log(LogTypes.ENGINE, group, log, undefined, fileName);
+  }
+
+  debug(group, log, fileName) {
+    this._log(LogTypes.DEBUG, group, log, undefined, fileName);
+  }
+
+  error(group, log, err, fileName) {
+    this._log(LogTypes.ERROR, group, log, err, fileName);
+  }
+
+  isLogEngine(group) {
+    return (LogConfig.config[LogTypes.ENGINE].groupAll) || (LogConfig.config[LogTypes.ENGINE].groups[group].enabled);
+  }
+  
+  isLogDebug(group) {
+    return (LogConfig.config[LogTypes.DEBUG].groupAll) || (LogConfig.config[LogTypes.DEBUG].groups[group].enabled);
+  }
+  
+  isLogError(group) {
+    return (LogConfig.config[LogTypes.ERROR].groupAll) || (LogConfig.config[LogTypes.ERROR].groups[group].enabled);
+  }
+  
+  addListener(listener) {
+    this.listener = listener;
+  }
+  
+  clearListener() {
+    this.listener = null;
+  }
+  
+  _log(type, group, log, err, fileName) {
+    if((LogConfig.config[type].groupAll) || (LogConfig.config[type].groups[group].enabled)) {
+      let date = HighResolutionTimestamp.getHighResolutionDate();
+      let logData = {
+        type: type,
+        date: date,
+        pid: process.pid,
+        log: log,
+        group: group,
+        err: undefined !== err ? err.message : undefined,
+        fileName: fileName
+      };
+      this.loggerImpl.log(logData);
+      if(null !== this.listener) {
+        this.listener(logData);
+      }
+    }
+  }
+
+  initTestCase(name, timestamp) {
+    let logTc = {
+      name: name,
+      start: HighResolutionTimestamp.getHighResolutionDate(timestamp),
+      stop: undefined
+    };
+    /*setImmediate(() => {
+      this.loggerImpl.tcStart(logTc);
+    });*/
+    return logTc;
+  }
+
+  exitTestCase(logTc, timestamp) {
+    /*logTc.stop = HighResolutionTimestamp.getHighResolutionDate(timestamp);
+    setImmediate(() => {
+      this.loggerImpl.tcStop(logTc);
+    });*/
+  }
+  
+  initTestSuite(name, timestamp) {
+    let logTs = {
+      name: name,
+      start: HighResolutionTimestamp.getHighResolutionDate(timestamp),
+      stop: undefined
+    };
+    /*setImmediate(() => {
+      this.loggerImpl.tsStart(logTs);
+    });*/
+    return logTs;
+  }
+
+  exitTestSuite(logTs, timestamp) {
+    /*logTs.stop = HighResolutionTimestamp.getHighResolutionDate(timestamp);
+    setImmediate(() => {
+      this.loggerImpl.tsStop(logTs);
+    });*/
+  }
+}
+
+module.exports = new Logger();

package/project/server/node/channel-input.js

@@ -0,0 +1,65 @@
+
+'use strict';
+
+const Decoder = require('../communication/core-protocol/decoder');
+const DeserializerMessageRequest = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/deserializer-message-request');
+const DeserializerMessageResponse = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/deserializer-message-response');
+const DeserializerMessageServiceInitRequest = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/deserializer-message-service-init-request');
+const TextCache = require('z-abs-corelayer-cs/clientServer/communication/cache/text-cache');
+const Deserializer = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/deserializer');
+const AppDeserializer = require('z-abs-corelayer-cs/clientServer/communication/app-protocol/app-deserializer');
+const CoreProtocolConst = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/core-protocol-const');
+
+
+class ChannelInput {
+  constructor(name) {
+    this.name = name;
+    this.textCache = new TextCache(name, process.pid);
+    this.deserializer = new Deserializer(Decoder, this.textCache);
+    this.appDeserializer = new AppDeserializer(new Decoder(this.textCache), new Decoder());
+    this.appDeserializer.register(CoreProtocolConst.REQUEST, null, new DeserializerMessageRequest(Deserializer.jsonFunc));
+    this.appDeserializer.register(CoreProtocolConst.RESPONSE, null, new DeserializerMessageResponse(Deserializer.jsonFunc));
+    this.appDeserializer.register(CoreProtocolConst.SERVICE_INIT_REQUEST, null, new DeserializerMessageServiceInitRequest(Deserializer.jsonFunc));
+  }
+  
+  register(id, name, deserializer) {
+    this.appDeserializer.register(id, name, deserializer);
+  }
+  
+  onMessage(msg, open) {
+    const coreMessage = this.deserializer.do(msg);
+    if(coreMessage) {
+      if(open) {
+        if(coreMessage.isBinary) {
+          if(coreMessage.hasTextCache) {
+            this.appDeserializer.doCachedText(coreMessage.cachedTextBuffer);
+          }
+          coreMessage.msg = this.appDeserializer.do(coreMessage.msgId, coreMessage.bin, null, coreMessage.isServiceAction);
+        }
+      }
+      return coreMessage;
+    }
+    else {
+      return null;
+    }
+  }
+  
+  onNewMessage(msg, open, cbMessage) {
+    const coreMessage = this.deserializer.do(msg);
+    if(coreMessage) {
+      if(open) {
+        if(coreMessage.isBinary) {
+          if(coreMessage.hasTextCache) {
+            this.appDeserializer.doCachedText(coreMessage.cachedTextBuffer);
+          }
+          coreMessage.msg = this.appDeserializer.do(coreMessage.msgId, coreMessage.bin, coreMessage.isServiceAction);
+        }
+      }
+      cbMessage(coreMessage);
+      this.onNewMessage(null, open, cbMessage);
+    }
+  }
+}
+
+
+module.exports = ChannelInput;

package/project/server/node/channel-output.js

@@ -0,0 +1,39 @@
+
+'use strict';
+
+const Encoder = require('../communication/core-protocol/encoder');
+const TextCache = require('z-abs-corelayer-cs/clientServer/communication/cache/text-cache');
+const Serializer = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/serializer');
+
+
+class ChannelOutput {
+  constructor(name, channel) {
+    this.name = name;
+    this.textCache = new TextCache(name, process.pid);
+    this.channel = channel;
+    this.serializer = new Serializer(`ChannelOutput-${this.name}`, Encoder, this.textCache);
+  }
+  
+  register(id, serializer) {
+    this.serializer.register(id, serializer);
+  }
+  
+  send(msg, dataBuffers, debug, envelope) {
+    const buffers = this.serializer.do(msg, dataBuffers, envelope);
+    if(!debug) {
+      setImmediate((self, buffers) => {
+        buffers.forEach((buffer) => {
+          self.channel(buffer);
+        });
+      }, this, buffers);
+    }
+    else {
+      buffers.forEach((buffer) => {
+        this.channel(buffer);
+      });
+    }
+  }
+}
+
+
+module.exports = ChannelOutput;

package/project/server/node/clients.js

@@ -0,0 +1,80 @@
+
+'use strict';
+
+const Const = require('./const');
+const TcpClient = tryRequire('z-abs-corelayer-bs/server/node/tcp-client');
+
+
+class Clients {
+  constructor(nodeName, nodeId, nodeSettings, dataResponse) {
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.nodeSettings = nodeSettings;
+    this.dataResponse = dataResponse;
+    this.clients = new Map();
+  }
+  
+  create() {
+    if(0 === this.nodeSettings.tcpClients.length) {
+      return;
+    }
+    if(TcpClient && 0 !== this.nodeSettings.tcpClients.length) {
+      this.nodeSettings.tcpClients.forEach((tcpClientData) => {
+        this._createIpClient(Const.TRANSPORT_TCP, this.dataResponse, tcpClientData);
+      });
+    }
+    const dependencyServiceNames = [];
+    this.clients.forEach((client, key) => {
+      if(client.serverData.dependency) {
+        dependencyServiceNames.push(key);
+      }
+    });
+    dependencyServiceNames.sort();
+    this.dataResponse.externalServices.addDependencyNodeNames(dependencyServiceNames);
+  }
+  
+  start(cb) {
+    let pendings = this.clients.size;
+    if(0 === pendings) {
+      process.nextTick(cb);
+      return;
+    }
+    this.clients.forEach((client) => {
+      client.start(client.serverData, () => {
+        if(0 === --pendings) {
+          cb();
+        }
+      });
+    });
+  }
+  
+  subscribeOnConnectionEvents(guid, eventType, name, cb) {
+    const client = this.clients.get(name);
+    if(client) {
+      client.ipServer.dataResponse.ipSubscription.subscribeOnConnectionEvents(guid, eventType, name, cb);
+    }
+  }
+  
+  unsubscribeOnConnectionEvents(guid, eventType, name) {
+    const client = this.clients.get(name);
+    if(client) {
+      client.ipServer.dataResponse.ipSubscription.unsubscribeOnConnectionEvents(guid, eventType, name);
+    }
+  }
+  
+  _createIpClient(type, channel, clientData) {
+    let client = null;
+    if(Const.TRANSPORT_TCP === type) {
+      client = new TcpClient(clientData.name, this.nodeName, this.nodeId, channel, clientData);
+    }
+    if(client) {
+      this.clients.set(clientData.name, client);
+	}
+	else {
+      console.log('ERROR');
+	}
+  }
+}
+
+
+module.exports = Clients;

package/project/server/node/connection-address.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+
+class ConnectionAddress {
+  constructor(localHost, localPort, remoteHost, remotePort, family) {
+    this.localHost = localHost;
+    this.localPort = localPort;
+    this.remoteHost = remoteHost;
+    this.remotePort = remotePort;
+    this.family = family;
+    
+    this.connectionDataId = '';
+    this.transport = '';
+  }
+  
+  setData(connectionDataId, transport) {
+    this.connectionDataId = connectionDataId;
+    this.transport = transport;
+  }
+}
+
+
+module.exports = ConnectionAddress;

package/project/server/node/connection-data-ip.js

@@ -0,0 +1,82 @@
+
+'use strict';
+
+const Const = require('./const');
+const ChannelInput = require('./channel-input');
+const ChannelOutput = require('./channel-output');
+const HighResolutionTimestamp = require('../high-resolution-timestamp');
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+
+
+class ConnectionDataIp {
+  static id = 0;
+  
+  constructor(channelInputName, channelOutputName, outputCbMessage) {
+    this.id = GuidGenerator.create();
+    this.sessionCache = new Map();
+    this.channelInput = channelInputName ? new ChannelInput(channelInputName) : null;
+    this.channelOutput = channelOutputName ? new ChannelOutput(channelOutputName, outputCbMessage) : null;
+    
+    this.name = '';
+    this.connectionAddress = null;
+    this.timestampConnect = HighResolutionTimestamp.getHighResolutionDate();
+    this.timestampDisconnect = null;
+    
+    this.initialized = false;
+    this.nodeName = '';
+    this.nodeId = '';
+    this.nodeType = -1;
+    this.nodeSymbol = null;
+    this.frontendServices = new Set();
+    this.backendServices = new Set();
+    this.surveillanceServices = new Set();
+  }
+  
+  setConnectionInit(name, connectionAddress) {
+    this.name = name;
+    this.connectionAddress = connectionAddress;
+  }
+  
+  setServiceInit(nodeName, nodeId, nodeType) {
+    this.initialized = true;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.nodeType = nodeType;
+    this.nodeSymbol = Symbol(`${this.nodeName}::${this.nodeId}`);
+  }
+  
+  closed() {
+    this.timestampDisconnect = HighResolutionTimestamp.getHighResolutionDate();
+  }
+  
+  addService(serviceName, offerType) {
+    if(Const.OFFER_FRONTEND === offerType) {
+      this.frontendServices.add(serviceName);
+    }
+    else if(Const.OFFER_BACKEND === offerType) {
+      this.backendServices.add(serviceName);
+    }
+    else if(Const.OFFER_SURVEILLANCE === offerType) {
+      this.surveillanceServices.add(serviceName);
+    }
+  }
+  
+  deleteService(serviceName, offerType) {
+    if(Const.OFFER_FRONTEND === offerType) {
+      this.frontendServices.delete(serviceName);
+    }
+    else if(Const.OFFER_BACKEND === offerType) {
+      this.backendServices.delete(serviceName);
+    }
+    else if(Const.OFFER_SURVEILLANCE === offerType) {
+      this.surveillanceServices.delete(serviceName);
+    }
+  }
+  
+  print() {
+    console.log(this.initialized, this.nodeName, this.serviceNames);
+  }
+}
+
+
+module.exports = ConnectionDataIp;

package/project/server/node/connection-data.js

@@ -0,0 +1,25 @@
+
+'use strict';
+
+const ChannelInput = require('./channel-input');
+const ChannelOutput = require('./channel-output');
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+
+
+class ConnectionData {
+  static id = 0;
+  
+  constructor(channelInputName, channelOutputName, outputCbMessage) {
+    this.id = GuidGenerator.create();
+    this.sessionCache = new Map();
+    this.channelInput = channelInputName ? new ChannelInput(channelInputName) : null;
+    this.channelOutput = channelOutputName ? new ChannelOutput(channelOutputName, outputCbMessage) : null;
+  }
+  
+  print() {
+    console.log(this.initialized, this.nodeName, this.serviceNames);
+  }
+}
+
+
+module.exports = ConnectionData;

package/project/server/node/const.js

@@ -0,0 +1,44 @@
+
+'use strict';
+
+
+class Const {
+  static CONNECTION_TYPE_SERVER_REST = 0;
+  static CONNECTION_TYPE_SERVER_IP = 1;
+  static CONNECTION_TYPE_SERVER_WORKER = 2;
+  static CONNECTION_TYPE_SERVER_WEB = 3;
+  static CONNECTION_TYPE_CLIENT_IP = 4;
+  static CONNECTION_TYPE_CLIENT_WORKER = 5;
+  
+  static EVENT_TYPE_CONNECTION = 0;
+  static IP_EVENT_CONNECTED = 0;
+  static IP_EVENT_DISCONNECTED = 1;
+  
+  static TRANSPORT_TCP = 0;
+  static TRANSPORT_TLS = 1;
+  static TRANSPORT_WS = 2;
+  static TRANSPORT_WSS = 3;
+  static TRANSPORT_HTTP = 4;
+  static TRANSPORT_HTTPS = 5;
+  static TRANSPORT_HTTP2 = 6;
+  
+  static TRANSPORT_AS_TEXT = ['tcp', 'tls', 'ws', 'wss', 'http', 'http', 'http'];
+  
+  static NODE_TYPE_FRONTEND = 0;
+  static NODE_TYPE_BACKEND = 1;
+  static NODE_TYPE_PROXY = 2;
+  static NODE_TYPE_SURVEILLANCE = 3;
+  static NODE_TYPE_WORKER = 4;
+  
+  #BUILD_DEBUG_START
+  static NODE_TYPES = ['NODE_TYPE_FRONTEND', 'NODE_TYPE_BACKEND', 'NODE_TYPE_PROXY', 'NODE_TYPE_SURVEILLANCE', 'NODE_TYPE_WORKER'];
+  #BUILD_DEBUG_STOP
+  
+  static OFFER_LOCAL = 0;
+  static OFFER_FRONTEND = 1;
+  static OFFER_BACKEND = 2;
+  static OFFER_SURVEILLANCE = 3;
+}
+
+
+module.exports = Const;