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

package/project/server/node/servers.js

@@ -0,0 +1,168 @@
+
+'use strict';
+
+const Const = require('./const');
+const HttpCache = require('./http-cache');
+const HttpServer = require('./http-server');
+const HttpsServer = require('./https-server');
+const Http2Server = require('./http2-server');
+const WsServer = require('./ws-server');
+const WssServer = require('./wss-server');
+const WsWebServer = require('./ws-web-server');
+const TcpServer = tryRequire('z-abs-corelayer-bs/server/node/tcp-server');
+const TlsServer = tryRequire('z-abs-corelayer-bs/server/node/tls-server');
+const IpProxy = tryRequire('z-abs-corelayer-bs/server/node/ip-proxy');
+const HttpProxy = tryRequire('z-abs-corelayer-bs/server/node/http-proxy');
+const HttpProxyServer = tryRequire('z-abs-corelayer-bs/server/node/http-proxy-server');
+const HttpsProxyServer = tryRequire('z-abs-corelayer-bs/server/node/https-proxy-server');
+const Http2ProxyServer = tryRequire('z-abs-corelayer-bs/server/node/http2-proxy-server');
+
+
+class Servers {
+  constructor(nodeName, nodeId, nodeSettings, defaultSite, dataResponse) {
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.nodeSettings = nodeSettings;
+    this.defaultSite = defaultSite;
+    this.dataResponse = dataResponse;
+    this.proxyServerDatas = [];
+    this.httpCache = new HttpCache();
+    this.servers = new Map();
+  }
+  
+  create() {
+    if(0 === this.nodeSettings.wsWebServers.length && 0 === this.nodeSettings.httpServers.length && 0 === this.nodeSettings.httpsServers.length && 0 === this.nodeSettings.http2Servers.length && 0 === this.nodeSettings.tcpServers.length && 0 === this.nodeSettings.tlsServers.length && 0 === this.nodeSettings.wsServers.length && 0 === this.nodeSettings.wssServers.length && 0 === this.nodeSettings.ipProxyServers.length) {
+      return;
+    }
+    if(0 !== this.nodeSettings.httpServers.length) {
+      this.nodeSettings.httpServers.forEach((httpServerData) => {
+        const httpServer = new HttpServer(httpServerData, this.nodeName, this.nodeId, this.httpCache, this.dataResponse, this.defaultSite);
+        this.servers.set(httpServerData.name, httpServer);
+      });
+    }
+    if(0 !== this.nodeSettings.httpsServers.length) {
+      this.nodeSettings.httpsServers.forEach((httpsServerData) => {
+        const httpsServer = new HttpsServer(httpsServerData, this.nodeName, this.nodeId, this.httpCache, this.dataResponse, this.localServices, this.defaultSite);
+        this.servers.set(httpsServerData.name, httpsServer);
+      });
+    }
+    if(0 !== this.nodeSettings.http2Servers.length) {
+      this.nodeSettings.http2Servers.forEach((http2ServerData) => {
+        const httpsServer = new Http2Server(http2ServerData, this.nodeName, this.nodeId, this.httpCache, this.dataResponse, this.localServices, this.defaultSite);
+        this.servers.set(http2ServerData.name, httpsServer);
+      });
+    }
+    if(TcpServer && 0 !== this.nodeSettings.tcpServers.length) {
+      this.nodeSettings.tcpServers.forEach((tcpServerData) => {
+        this._createIpServer(Const.TRANSPORT_TCP, this.dataResponse, tcpServerData);
+      });
+    }
+    if(TlsServer && 0 !== this.nodeSettings.tlsServers.length) {
+      this.nodeSettings.tlsServers.forEach((tlsServerData) => {
+        this._createIpServer(Const.TRANSPORT_TLS, this.dataResponse, tlsServerData);
+      });
+    }
+    if(0 !== this.nodeSettings.wsServers.length) {
+      this.nodeSettings.wsServers.forEach((wsServerData) => {
+        this._createIpServer(Const.TRANSPORT_WS, this.dataResponse, wsServerData);
+      });
+    }
+    if(0 !== this.nodeSettings.wssServers.length) {
+      this.nodeSettings.wssServers.forEach((wssServerData) => {
+        this._createIpServer(Const.TRANSPORT_WSS, this.dataResponse, wssServerData);
+      });
+    }
+    if(IpProxy && 0 !== this.nodeSettings.ipProxyServers.length) {
+      this.nodeSettings.ipProxyServers.forEach((proxyServerData) => {
+        const ipProxy = new IpProxy(this.nodeName, this.nodeId);
+        this._createIpServer(proxyServerData.frontend.type, ipProxy.ipProxyFrontend, proxyServerData.frontend.settings);
+        this._createIpServer(proxyServerData.backend.type, ipProxy.ipProxyBackend, proxyServerData.backend.settings);
+      });
+    }
+    if(HttpProxy && 0 !== this.nodeSettings.httpProxyServers.length) {
+      this.nodeSettings.httpProxyServers.forEach((proxyServerData) => {
+        const httpProxy = new HttpProxy(this.nodeName, this.nodeId, proxyServerData.backends);
+        this._createHttpProxyServer(proxyServerData.frontend.type, httpProxy, proxyServerData.frontend.settings);
+      });
+    }
+    if(0 !== this.nodeSettings.wsWebServers.length) {
+      this.nodeSettings.wsWebServers.forEach((wsWebServerData) => {
+    		const wsWebServer = new WsWebServer(wsWebServerData, this.nodeName, this.nodeId, this.dataResponse);
+		    this.servers.set(wsWebServerData.name, wsWebServer);
+      });
+    }
+  }
+  
+  start(cb) {
+    let pendings = this.servers.size;
+    if(0 === pendings) {
+      process.nextTick(cb);
+      return;
+    }
+    this.servers.forEach((server) => {
+      server.start(server.serverData, () => {
+        if(0 === --pendings) {
+          cb();
+        }
+      });
+    });
+  }
+  
+  subscribeOnConnectionEvents(guid, eventType, name, cb) {
+    const server = this.servers.get(name);
+    if(server) {
+      server.ipServer.dataResponse.ipSubscription.subscribeOnConnectionEvents(guid, eventType, name, cb);
+    }
+  }
+  
+  unsubscribeOnConnectionEvents(guid, eventType, name) {
+    const server = this.servers.get(name);
+    if(server) {
+      server.ipServer.dataResponse.ipSubscription.unsubscribeOnConnectionEvents(guid, eventType, name);
+    }
+  }
+  
+  _createIpServer(type, channel, serverData) {
+    let server = null;
+    if(Const.TRANSPORT_TCP === type) {
+      server = new TcpServer(serverData.name, serverData, this.nodeName, this.nodeId, channel);
+    }
+    else if(Const.TRANSPORT_TLS === type) {
+      server = new TlsServer(serverData.name, serverData, this.nodeName, this.nodeId, channel);
+    }
+    else if(Const.TRANSPORT_WS === type) {
+      server = new WsServer(serverData.name, serverData, this.nodeName, this.nodeId, channel);
+    }
+    else if(Const.TRANSPORT_WSS === type) {
+      server = new WssServer(serverData.name, serverData, this.nodeName, this.nodeId, channel);
+    }
+    if(server) {
+      this.servers.set(serverData.name, server);
+    }
+    else {
+      console.log('ERROR');
+    }
+  }
+  
+  _createHttpProxyServer(type, httpProxy, serverData) {
+    let server = null;
+    if(Const.TRANSPORT_HTTP === type) {
+      server = new HttpProxyServer(serverData.name, serverData, httpProxy);
+    }
+    else if(Const.TRANSPORT_HTTPS === type) {
+      server = new HttpsProxyServer(serverData.name, serverData, httpProxy);
+    }
+    else if(Const.TRANSPORT_HTTP2 === type) {
+      server = new Http2ProxyServer(serverData.name, serverData, httpProxy);
+    }
+    if(server) {
+      this.servers.set(serverData.name, server);
+    }
+    else {
+      console.log('ERROR');
+    }
+  }
+}
+
+
+module.exports = Servers;

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

@@ -0,0 +1,12 @@
+
+'use strict';
+
+
+class WsClient {
+  constructor() {
+    
+  }
+}
+
+
+module.exports = WsClient;

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

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const Const = require('./const');
+const ConnectionAddress = require('./connection-address');
+const IpServer = require('./ip-server');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+
+
+class WsServer {
+  constructor(name, serverData, nodeName, nodeId, dataResponse) {
+  	this.transport = Const.TRANSPORT_WS;
+    this.name = name;
+    this.serverData = serverData;
+    this.ipServer = new IpServer(this, nodeName, nodeId, dataResponse, serverData.protocols);
+  }
+}
+
+
+module.exports = WsServer;

package/project/server/node/ws-web-server.js

@@ -0,0 +1,52 @@
+
+'use strict';
+
+const Const = require('./const');
+const DataResponse = require('../data-response');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+const WebSocketServer = require('ws').Server;
+
+
+class WsWebServer {
+  constructor(serverData, nodeName, nodeId, dataResponse) {
+    this.serverData = serverData;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.dataResponse = dataResponse;
+    this.protocols = serverData.protocols;
+    this.pluginFactoryProtocol = new PluginFactoryProtocol();
+  }
+  
+  start(wsData, cb) {
+    this.pluginFactoryProtocol.load(this.protocols, () => {
+      wsData.server = new WebSocketServer({
+        perMessageDeflate: false,
+        host: wsData.host,
+        port: wsData.port
+      }, () => {
+        ddb.writelnTime(ddb.cyan('Server:   '), `${this.nodeName}-${wsData.name}`, ddb.green(' started at'), ` http://${wsData.host}:${wsData.port}`);
+        cb();
+      });
+      wsData.server.on('connection', (ws) => {
+        ws.on('message', (msgIn) => {
+          this.dataResponse.onMessage(msgIn, connectionData);
+        });
+        ws.on('close', () => {
+          this.dataResponse.onConnectionClose(Const.CONNECTION_TYPE_SERVER_WEB, connectionData);
+        });
+        const connectionData = this.dataResponse.onConnectionConnected(Const.CONNECTION_TYPE_SERVER_WEB, (buffer) => {
+          ws.send(buffer);
+        });
+        this.pluginFactoryProtocol.register(connectionData.channelInput, connectionData.channelOutput);
+      });
+      wsData.server.on('error', (err) => {
+        const date = new Date();
+        ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${wsData.name}'`, ddb.red(' did not start at'), ` http://${wsData.host}:${wsData.port}` + ddb.red('. Error: '), err.message);
+        cb(err);
+      });
+    });
+  }
+}
+
+
+module.exports = WsWebServer;

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

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const Const = require('./const');
+const ConnectionAddress = require('./connection-address');
+const IpServer = require('./ip-server');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+
+
+class WssServer {
+  constructor(name, serverData, nodeName, nodeId, dataResponse) {
+    this.transport = Const.TRANSPORT_WSS;
+    this.name = name;
+    this.serverData = serverData;
+    this.ipServer = new IpServer(this, nodeName, nodeId, dataResponse, serverData.protocols);
+  }
+}
+
+
+module.exports = WssServer;

package/project/server/node/wss-web-server.js

@@ -0,0 +1,82 @@
+
+'use strict';
+
+const Const = require('./const');
+const DataResponse = require('../data-response');
+const PluginFactoryProtocol = require('../plugin-factor-protocol');
+const WebSocketServer = require('ws').Server;
+const Https = require ('https');
+
+
+class WssWebServer {
+  constructor(serverData, nodeName, nodeId, dataResponse) {
+    this.serverData = serverData;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.dataResponse = dataResponse;
+    this.protocols = serverData.protocols;
+    this.pluginFactoryProtocol = new PluginFactoryProtocol();
+  }
+  
+  start(wssData, cb) {
+    this.pluginFactoryProtocol.load(this.protocols, () => {
+      const options = this._readKeys(wssData);
+      if(options) {
+        const httpsServer = https.createServer(options);
+        server.listen(wssData.port, wssData.host);
+        wssData.server = new WebSocketServer({
+          perMessageDeflate: false,
+          server: httpsServer
+        }, () => {
+          ddb.writelnTime(ddb.cyan('Server:   '), `${this.nodeName}-${wssData.name}`, ddb.green(' started at'), ` https://${wssData.host}:${wssData.port}`);
+          cb();
+        });
+        wssData.server.on('connection', (ws) => {
+          ws.on('message', (msgIn) => {
+            this.dataResponse.onMessage(msgIn, connectionData);
+          });
+          ws.on('close', () => {
+            this.dataResponse.onConnectionClose(Const.CONNECTION_TYPE_SERVER_WEB, connectionData);
+          });
+          const connectionData = this.dataResponse.onConnectionConnected(Const.CONNECTION_TYPE_SERVER_WEB, (buffer) => {
+            ws.send(buffer);
+          });
+          this.pluginFactoryProtocol.register(connectionData.channelInput, connectionData.channelOutput);
+        });
+        wssData.server.on('error', (err) => {
+          const date = new Date();
+          ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${wssData.name}'`, ddb.red(' did not start at'), ` https://${wssData.host}:${wssData.port}` + ddb.red('. Error: '), err.message);
+          cb(err);
+        });
+      });
+    }
+    else {
+      const err = new Error('-----');
+      ddb.writelnTimeError(err, ddb.red('Server:'), ` '${this.nodeName}-${wssData.name}'`, ddb.red(' did not start at'), ` https://${wssData.host}:${wssData.port}` + ddb.red('. No SSL keys.'));
+      cb(err);
+    }
+  }
+  
+  _readKeys(wssData) {
+    if(wssData.keyFile && wssData.certFile) {
+      try {
+        const keyFile = Fs.readFileSync(wssData.keyFile);
+        const certFile = Fs.readFileSync(wssData.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 = WssWebServer;

package/project/server/path/actor-path-build.js

@@ -0,0 +1,29 @@
+
+'use strict';
+
+const ActorPath = require('./actor-path');
+const Path = require('path');
+
+
+class ActorPathBuild {
+  constructor() {
+    this.actorBuildPath = ActorPath.setPath(ActorPath.getActorPath(), `${Path.sep}build`);
+  }
+  
+  getActorBuildPath() {
+    return this.actorBuildPath;
+  }
+  
+  getCodeFile(file, projectType) {
+    if(!projectType) {
+      const fileName = file.substring('./project/'.length);
+      return Path.normalize(`${this.getActorBuildPath()}${Path.sep}AppLayer${Path.sep}${fileName.replace(new RegExp('[/\\\\]', 'g'), Path.sep)}`);
+    }
+    else {
+      return Path.normalize(`${this.getActorBuildPath()}${Path.sep}${file.replace(new RegExp('[/\\\\]', 'g'), Path.sep)}`);
+    }
+  }
+}
+
+
+module.exports = new ActorPathBuild();

package/project/server/path/actor-path-content.js

@@ -0,0 +1,51 @@
+
+'use strict';
+
+const ActorPath = require('./actor-path');
+const Path = require('path');
+
+
+class ActorPathContent {
+  constructor() {
+    if(ActorPath.releaseStepDelivery) {
+      this.contentFolder = ActorPath.setPath(ActorPath.getActorPath(), `..${Path.sep}..${Path.sep}..${Path.sep}Content`);
+      this.contentGlobalFolder = ActorPath.setPath(ActorPath.getActorPath(), `${Path.sep}node_modules${Path.sep}${ActorPath.organization}${Path.sep}actorjs-content-global`);
+    }
+    else if(ActorPath.releaseStepCandidate) {
+      this.contentFolder = ActorPath.setPath(ActorPath.getActorPath(), `..${Path.sep}Content`);
+      this.contentGlobalFolder = ActorPath.setPath(ActorPath.getActorPath(), `${Path.sep}node_modules${Path.sep}actorjs-content-global`);
+    }
+    else {
+      this.contentFolder = ActorPath.setPath(ActorPath.getActorPath(), `..${Path.sep}Content`);
+      this.contentGlobalFolder = ActorPath.setPath(this.contentFolder, `${Path.sep}actorjs-content-global`);
+    }
+    
+    // *** LOCAL
+    
+    this.contentLocalFolder = ActorPath.setPath(this.contentFolder, `${Path.sep}actorjs-content-local`);
+    this.contentLocalReadMeFile = ActorPath.setPath(this.contentLocalFolder, `${Path.sep}README.md`);
+  }
+  
+  getContentFolder() {
+    return this.contentFolder;
+  }
+  
+  getContentLocalFolder() {
+    return this.contentLocalFolder;
+  }
+
+  getContentGlobalFolder() {
+    return this.contentGlobalFolder;
+  }
+  
+  getContentFile(repoPath, path) {
+    return Path.normalize(`${repoPath}${Path.sep}${path}`);
+  }
+  
+  getReadMeFile() {
+    return this.contentLocalReadMeFile;
+  }
+}
+
+
+module.exports = new ActorPathContent();

package/project/server/path/actor-path-creator.js

@@ -0,0 +1,90 @@
+
+'use strict';
+
+const Fs = require('fs');
+
+
+class ActorPathCreator {
+  constructor(folderPaths, filePaths) {
+    this.folderPaths = folderPaths;
+    this.filePaths = filePaths;
+    this.indexFolder = this.folderPaths.length;
+    this.indexFile = this.filePaths.length;
+  }
+  
+  verifyOrCreate(done) {
+    if(0 !== this.indexFolder) {
+      this.verifyOrCreateFolders((errorsFolder) => {
+        if(0 !== errorsFolder.length) {
+          done(errorsFolder);
+        }
+        else {
+          if(0 !== this.indexFile) {
+            this.verifyOrCreateFiles((errorsFile) => {
+              done(0 !== errorsFile.length ? errorsFile : undefined);
+            });
+          }
+          else {
+            process.nextTick(done);
+          }
+        }
+      });
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  verifyOrCreateFolders(done) {
+    let pendings = 0;
+    const errors = [];
+    this.folderPaths.forEach((folder) => {
+      ++pendings;
+      Fs.access(folder, Fs.constants.R_OK | Fs.constants.W_OK, (err) => {
+        if(err) {
+          Fs.mkdir(folder, { recursive: true }, (e) => {
+            if(e) {
+              errors.push(e);
+            }
+            if(0 === --pendings) {
+              done(errors);
+            }
+          });
+        }
+        else {
+          if(0 === --pendings) {
+            done(errors);
+          }
+        }
+      });    
+    });
+  }
+
+  verifyOrCreateFiles(done) {
+    let pendings = 0;
+    const errors = [];
+    this.filePaths.forEach((file) => {
+      ++pendings;
+      Fs.access(file.path, Fs.constants.R_OK | Fs.constants.W_OK, (err) => {
+        if(err) {
+          Fs.writeFile(file.path, file.default ? JSON.stringify(file.default, null, 2) : file.text, (e) => {
+            if(e) {
+              errors.push(e);
+            }
+            if(0 === --pendings) {
+              done(errors);
+            }
+          });
+        }
+        else {
+          if(0 === --pendings) {
+            done(errors);
+          }
+        }
+      });
+    });
+  }
+}
+
+
+module.exports = ActorPathCreator;