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

package/project/server/node/http2-server.js

@@ -0,0 +1,67 @@
+
+'use strict';
+
+const HttpRequestHandler = require('./http-request-handler');
+const Fs = require('fs');
+const Http2 = require('http2');
+
+
+class Http2Server {
+  constructor(serverData, nodeName, nodeId, httpCache, dataResponse, defaultSite) {
+    this.serverData = serverData;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.httpRequestHandler = new HttpRequestHandler(httpCache, dataResponse, defaultSite);
+  }
+  
+  start(http2Data, cb) {
+    this.httpRequestHandler.init(http2Data, true);
+    const options = this._readKeys(http2Data);
+    if(options) {
+      const server = Http2.createSecureServer({
+        cert: options.certFile,
+        key: options.keyFile,
+        allowHTTP1: false 
+      }, (req, res) => {
+        this.httpRequestHandler.handle(req, res);
+      });
+      server.on('listening', () => {
+        ddb.writelnTime(ddb.cyan('Server:   '), `${this.nodeName}-${http2Data.name} `, ddb.green('started at '), `http://${http2Data.host}:${http2Data.port}`);
+        cb();
+      });
+	    server.on('error', (err) => {
+        ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${http2Data.name}'`, ddb.red(' did not start at'), ` http://${http2Data.host}:${http2Data.port}` + ddb.red('. Error: '), err.message);
+        cb(err);
+      });
+      server.listen(http2Data.port, http2Data.host);
+    }
+    else {
+      const err = new Error('-----');
+      ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${http2Data.name}'`, ddb.red(' did not start at '), ` http://${http2Data.host}:${http2Data.port}` + ddb.red('. No SSL keys.'));
+      cb(err);
+    }
+  }
+  
+  _readKeys(http2Data) {
+    if(http2Data.keyFile && http2Data.certFile) {
+      try {
+        const keyFile = Fs.readFileSync(http2Data.keyFile);
+        const certFile = Fs.readFileSync(http2Data.certFile);
+        return {
+          key: keyFile,
+          cert: certFile
+        };
+      }
+      catch(err) {
+        ddb.writelnTimeError(ddb.red(`Could not get cert and key file, error:`), err);
+        return null;
+      }
+    }
+    else {
+      return null;
+    }
+  }
+}
+
+
+module.exports = Http2Server;

package/project/server/node/https-server.js

@@ -0,0 +1,63 @@
+
+'use strict';
+
+const HttpRequestHandler = require('./http-request-handler');
+const Fs = require('fs');
+const Https = require('https');
+
+
+class HttpsServer {
+  constructor(serverData, nodeName, nodeId, httpCache, dataResponse, defaultSite) {
+    this.serverData = serverData;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.httpRequestHandler = new HttpRequestHandler(httpCache, dataResponse, defaultSite);
+  }
+  
+  start(httpsData, cb) {
+    this.httpRequestHandler.init(httpsData, true);
+    const options = this._readKeys(httpsData);
+    if(options) {
+      const server = Https.createServer(options, (req, res) => {
+        this.httpRequestHandler.handle(req, res);
+      });
+      server.on('listening', () => {
+        ddb.writelnTime(ddb.cyan('Server:   '), ` ${this.nodeName}-${httpsData.name}`, ddb.green(' started at'), ` http://${httpsData.host}:${httpsData.port}`);
+        cb();
+      });
+	    server.on('error', (err) => {
+        ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${httpsData.name}'`, ddb.red(' did not start at'), ` http://${httpsData.host}:${httpsData.port}` + ddb.red('. Error: '), err.message);
+        cb(err);
+      });
+      server.listen(httpsData.port, httpsData.host);
+    }
+    else {
+      const err = new Error('-----');
+      ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${httpsData.name}'`, ddb.red(' did not start at'), ` http://${httpsData.host}:${httpsData.port}` + ddb.red('. No SSL keys.'));
+      cb(err);
+    }
+  }
+  
+  _readKeys(httpsData) {
+    if(httpsData.keyFile && httpsData.certFile) {
+      try {
+        const keyFile = Fs.readFileSync(httpsData.keyFile);
+        const certFile = Fs.readFileSync(httpsData.certFile);
+        return {
+          key: keyFile,
+          cert: certFile
+        };
+      }
+      catch(err) {
+        ddb.writelnTimeError(ddb.red(`Could not get cert and key file, error:`), err);
+        return null;
+      }
+    }
+    else {
+      return null;
+    }
+  }
+}
+
+
+module.exports = HttpsServer;

package/project/server/node/ip-client.js

@@ -0,0 +1,98 @@
+
+'use strict';
+
+const Const = require('./const');
+const DataResponse = require('../data-response');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+
+
+class IpClient {
+  static STATE_CONNECTING = 1;
+  static STATE_CONNECTED = 2;
+  static STATE_NOT_CONNECTED = 3;
+  
+  constructor(client, nodeName, nodeId, dataResponse, protocols) {
+    this.client = client;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.dataResponse = dataResponse;
+    this.protocols = protocols ? protocols : [];
+    this.pluginFactoryProtocol = new PluginFactoryProtocol();
+    this.data = null;
+    this.state = IpClient.STATE_NOT_CONNECTED;
+    this.timerId = -1;
+    this.downTicks = 0;
+    this.connectionData = null;
+  }
+  
+  start(data, cb) {
+    this.data = data;
+    this.pluginFactoryProtocol.load(this.protocols, () => {
+      this._connectionHandler(cb);
+    });
+  }
+  
+  stop(cb) {
+    if(-1 !== this.timerId) {
+      clearTimeout(this.timerId);
+      this.timerId = -1;
+    }
+    this.data = null;
+    process.nextTick(cb);
+  }
+  
+  _connectionHandler(cb) {
+    if(IpClient.STATE_NOT_CONNECTED === this.state) {
+      this.state = IpClient.STATE_CONNECTING;
+      this._connect((connected) => {
+        if(!connected) {
+          this.state = IpClient.STATE_NOT_CONNECTED;
+          this.downTicks += 1;
+          this.timerId = setTimeout(() => {
+            this.timerId = -1;
+            this._connectionHandler();
+          }, 1000);
+        }
+        else {
+          this.state = IpClient.STATE_CONNECTED;
+          this.downTicks = 0;
+        }
+        if(cb) {
+          cb();
+        }
+      });
+    }
+  }
+  
+  _connect(cbConnected) {
+    this.client.onConnect(this.data, cbConnected);
+  }
+  
+  onConnected(connectionAddress) {
+    //ddb.writelnTime(ddb.blueBright('Client:   '), ddb.green('connected '), this.nodeName, ddb.yellow('::'), this.nodeId, ddb.green(' to '), this.data.name, ddb.green(' at'), ` tcp://${this.data.host}:${this.data.port}`);
+    this.connectionData = this.dataResponse.onConnectionConnected(Const.CONNECTION_TYPE_CLIENT_IP, (buffer) => {
+      this.client.onSend(buffer);
+    });
+    connectionAddress.setData(this.connectionData.id, this.client.transport);
+    this.connectionData.setConnectionInit(this.client.name, connectionAddress);
+    this.pluginFactoryProtocol.register(this.connectionData.channelInput, this.connectionData.channelOutput);
+  }
+  
+  onData(msgIn) {
+    this.dataResponse.onMessage(msgIn, this.connectionData);
+  }
+  
+  onClose() {
+    //ddb.writelnTime(ddb.blueBright('Client:   '), ddb.red('disconnected '), this.nodeName, ddb.yellow('::'), this.nodeId, ddb.red(' from '), this.data.name, ddb.red(' at'), ` tcp://${this.data.host}:${this.data.port}`);
+    this.connectionData.closed();
+    this.dataResponse.onConnectionClose(Const.CONNECTION_TYPE_CLIENT_IP, this.connectionData);
+    this.state = IpClient.STATE_NOT_CONNECTED;
+  }
+
+  onError(err) {
+    this.state = IpClient.STATE_NOT_CONNECTED;
+  }
+}
+
+
+module.exports = IpClient;

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

@@ -0,0 +1,63 @@
+
+'use strict';
+
+const Const = require('./const');
+const DataResponse = require('../data-response');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+
+
+class IpServer {
+  constructor(server, nodeName, nodeId, dataResponse, protocols) {
+    this.server = server;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.dataResponse = dataResponse;
+    this.protocols = protocols ? protocols : [];
+    this.pluginFactoryProtocol = new PluginFactoryProtocol();
+    this.data = null;
+  }
+  
+  start(data, cb) {
+    this.data = data;
+    this.pluginFactoryProtocol.load(this.protocols, () => {
+      this.server.onListen(this.data, cb);
+    });
+  }
+  
+  stop(cb) {
+    this.data = null;
+    process.nextTick(cb);
+  }
+  
+  onListen(transport, err) {
+    if(!err) {
+      ddb.writelnTime(ddb.cyan('Server:   '), this.nodeName, ddb.yellow('::'), this.nodeId, ddb.yellow('::'), this.data.name, ddb.green(' started at '), `${Const.TRANSPORT_AS_TEXT[transport]}://${this.data.host}:${this.data.port}`);
+    }
+    else {
+      ddb.writelnTimeError(err, ddb.cyan('Server:   '), this.nodeName, ddb.yellow('::'), this.nodeId, ddb.yellow('::'), this.data.name, ddb.red(' did not start at'), ` ${Const.TRANSPORT_AS_TEXT[transport]}://${this.data.host}:${this.data.port}`);
+    }
+  }
+  
+  onConnected(connectionAddress, cbMessage) {
+    const connectionData = this.dataResponse.onConnectionConnected(Const.CONNECTION_TYPE_SERVER_IP, (buffer) => {
+      cbMessage(buffer);
+    });
+    connectionAddress.setData(connectionData.id, this.server.transport);
+    connectionData.setConnectionInit(this.server.name, connectionAddress);
+    this.pluginFactoryProtocol.register(connectionData.channelInput, connectionData.channelOutput);
+    this.dataResponse.sendServiceInitRequest(connectionData);
+    return connectionData;
+  }
+  
+  onClose(connectionData) {
+    connectionData.closed();
+    this.dataResponse.onConnectionClose(Const.CONNECTION_TYPE_SERVER_IP, connectionData);
+  }
+  
+  onData(msgIn, connectionData) {
+    this.dataResponse.onMessage(msgIn, connectionData);
+  }
+}
+
+
+module.exports = IpServer;

package/project/server/node/ip-subscription.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+
+class IpSubscription {
+  constructor() {
+    this.subscribers = new Map();
+  }
+  
+  subscribeOnConnectionEvents(guid, eventType, name, cb) {
+    const key = `${eventType}_${name}`;
+    if(!this.subscribers.has(key)) {
+      this.subscribers.set(key, new Map([[guid, cb]]));
+    }
+    else {
+      const subscribers = this.subscribers.get(key);
+      if(subscribers) {
+        subscribers.set(guid, cb);
+      }
+    }
+  }
+  
+  unsubscribeOnConnectionEvents(guid, eventType, name) {
+    const key = `${eventType}_${name}`;
+    const subscribers = this.subscribers.get(key);
+    if(subscribers) {
+      subscribers.delete(guid);
+      if(0 === subscribers.size) {
+        this.subscribers.delete(key);
+      }
+    }
+  }
+  
+  event(eventType, name, eventId, data) {
+    const key = `${eventType}_${name}`;
+    const subscribers = this.subscribers.get(key);
+    if(subscribers) {
+      subscribers.forEach((cb) => {
+        cb(eventId, data);
+      });
+    }
+  }
+}
+
+
+module.exports = IpSubscription;

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

@@ -0,0 +1,98 @@
+
+'use strict';
+
+const CoreProtocolConst = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/core-protocol-const');
+const ActionRequest = require('z-abs-corelayer-cs/clientServer/communication/action-request');
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+
+
+class MessageChannel {
+  constructor(socket, dataResponse, BufferHandler, name) {
+    this.socket = socket;
+    this.dataResponse = dataResponse;
+    this.BufferHandler = BufferHandler;
+    this.name = name;
+    this.initialized = false;
+    this.requests = new Map();
+    this.connectionSessionDataCache = new Map();
+  }
+  
+  request(serviceAction, sessionId, cb) {
+    const guid = GuidGenerator.create();
+    serviceAction.setIds(guid, sessionId);
+    const request = {
+      type: 'DP_REQ',
+      sessionId: sessionId,
+      data: serviceAction.actionRequest
+    };
+    this.requests.set(guid, {
+      serviceAction: serviceAction,
+      cb: cb
+    });
+    this.socket.write(this.BufferHandler.convertToBuffer(request));
+  }
+  
+  onMessage(msg, cbInit) {
+    if(CoreProtocolConst.INIT === msg.msgId) {
+      this.initialized = true;
+      cbInit(msg);
+    }
+    else if(CoreProtocolConst.RESPONSE === msg.msgId) {
+      this._response(msg);
+    }
+    else if('DP_REQ' === msg.type || 0 !== msg.msgId) {
+      if(this.initialized) {
+        this.dataResponse.onMessage(msg, this.connectionSessionDataCache, (msgOut) => {
+          if('object' === typeof msgOut) {
+            this.socket.write(this.BufferHandler.convertToBuffer(msgOut), (err) => {});
+          }
+          else {
+            this.socket.write(this.BufferHandler.convertToBufferWithoutStringify(msgOut));
+          }
+        });
+      }
+      else {
+        if('DP_REQ' === msg.type) {
+          // TODO: make an error response.
+          ddb.warning(ddb.red('Server: '), this.name, ddb.red(` DROPPED message, received a request when the connection where not initialized. `), this._jsonStringify(msg));
+        }
+        else {
+          ddb.warning(ddb.red('Server: '), this.name, ddb.red(` DROPPED message, received a message when the connection where not initialized. `), this._jsonStringify(msg));
+        }
+      }
+    }
+    else {
+      ddb.warning(ddb.red('Server: '), this.name, ddb.red(' DROPPED message, received a message of unknown type: '), this._jsonStringify(msg));
+    }
+  }
+  
+  _response(response) {
+    const serviceActionData = this.requests.get(response.id);
+    this.requests.delete(response.id);
+    serviceActionData.serviceAction.setResponses(response.responses);
+    const responses = serviceActionData.serviceAction.responses;
+    if(1 === responses.length) {
+      if('success' === responses[0].result.code) {
+        serviceActionData.cb(null, responses[0].data);
+      }
+      else {
+        serviceActionData.cb(new Error(responses[0].result.msg));
+      }
+    }
+    else {
+      serviceActionData.cb(new Error('Wrong response format'));
+    }
+  }
+  
+  _jsonStringify(msg) {
+    try {
+      return JSON.stringify(msg);
+    }
+    catch(err) {
+      return ddb.red('Could not stringify msg');
+    }
+  }
+}
+
+
+module.exports = MessageChannel;