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

package/project/server/node/external-services.js

@@ -0,0 +1,209 @@
+
+'use strict';
+
+const Const = require('./const');
+
+
+class ExternalServices {
+  static emptyMap = new Map();
+  static NODE = ddb.cyan('Node:     ');
+  
+  constructor() {
+    this.nodes = new Map();
+    this.services = new Map();
+    this.dependencyNodeNames = new Set();
+    this.eventListeners = new Map();
+  }
+  
+  addDependencyNodeNames(dependencyNodeNames) {
+    this.dependencyNodeNames = new Set([...dependencyNodeNames]);
+  }
+  
+  _hasNode(nodeName) {
+    for(let [symbol, node] of this.nodes) {
+      if(nodeName === node.nodeName) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  getOfferData(nodeName, nodeSymbol) {
+    let offer = true;
+    let isDependent = this.dependencyNodeNames.has(nodeName);
+    const dependencies = this.dependencyNodeNames.size;
+    let connectedDependencies = 0;
+    if(isDependent) {
+      this.dependencyNodeNames.forEach((dependencyNodeName) => {
+        if(this._hasNode(dependencyNodeName)) {
+          ++connectedDependencies;
+        }
+        else {
+          offer = false;
+        }
+      });
+    }
+    return {
+      offer: offer || !isDependent,
+      isDependent,
+      dependencies,
+      connectedDependencies
+    };
+  }
+  
+  addNode(connectionData) {
+    const externalNode = {
+      nodeSymbol: connectionData.nodeSymbol,
+      nodeName: connectionData.nodeName,
+      nodeType: connectionData.nodeType,
+      connectionData: connectionData,
+      isDependent: this.dependencyNodeNames.has(connectionData.nodeName),
+      offered: false,
+      serviceExport: null
+    };
+    this.nodes.set(connectionData.nodeSymbol, externalNode);
+    ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.green(' connected'));
+    return externalNode;
+  }
+  
+  deleteNode(connectionData) {
+    if(this.nodes.delete(connectionData.nodeSymbol)) {
+      ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.red(' disconnected'));
+    }
+    this.offerOff(connectionData);
+  }
+  
+  getNodeData(connectionData) {
+    return this.nodes.get(connectionData.nodeSymbol);
+  }
+  
+  setNodeOffer(connectionData, serviceExport) {
+    const nodeData = this.nodes.get(connectionData.nodeSymbol);
+    nodeData.serviceExport = serviceExport;
+  }
+  
+  offerOn(connectionData, serviceExport) {
+    serviceExport.frontendServices.forEach((serviceName) => {
+      this._offerOn(serviceName, Const.OFFER_FRONTEND, connectionData);
+    });
+    serviceExport.backendServices.forEach((serviceName) => {
+      this._offerOn(serviceName, Const.OFFER_BACKEND, connectionData);
+    });
+    serviceExport.surveillanceServices.forEach((serviceName) => {
+      this._offerOn(serviceName, Const.OFFER_SURVEILLANCE, connectionData);
+    });
+  }
+  
+  offerOff(connectionData) {
+    connectionData.frontendServices.forEach((serviceName) => {
+      this._offerOff(serviceName, connectionData);
+    });
+    connectionData.backendServices.forEach((serviceName) => {
+      this._offerOff(serviceName, connectionData);
+    });
+    connectionData.surveillanceServices.forEach((serviceName) => {
+      this._offerOff(serviceName, connectionData);
+    });
+  }
+  
+  _offerOn(serviceName, offerType, connectionData) {
+    const externalService = this.services.get(serviceName);
+    if(!externalService) {
+      connectionData.addService(serviceName, offerType);
+      this.services.set(serviceName, new Map([[connectionData.id, {connectionData , instances: 1}]]));
+      ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.yellow(' offer '), ddb.cyan(serviceName), ddb.green(' on'), ddb.yellow(' id: '), connectionData.id, ', instances: ', ddb.yellow(1));
+    }
+    else {
+      let externalConnectionData = null;
+      if(externalService.has(connectionData.id)) {
+        externalConnectionData = externalService.get(connectionData.id);
+        ++externalConnectionData.instances;
+      }
+      else {
+        connectionData.addService(serviceName, offerType);
+        externalConnectionData = {connectionData , instances: 1};
+        externalService.set(connectionData.id, externalConnectionData);
+      }
+      ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.yellow(' offer '), ddb.cyan(serviceName), ddb.green(' on'), ddb.yellow(' id: '), connectionData.id, ', instances: ', ddb.yellow(externalConnectionData.instances));
+    }
+    const serviceListeners = this.eventListeners.get(serviceName);
+    if(serviceListeners) {
+      serviceListeners.forEach((cb) => {
+        process.nextTick(cb, connectionData, true);
+     });
+    }
+  }
+  
+  _offerOff(serviceName, connectionData) {
+    const externalService = this.services.get(serviceName);
+    if(externalService) {
+      const externalConnectionData = externalService.get(connectionData.id);
+      if(externalConnectionData) {
+        if(0 === --externalConnectionData.instances) {
+          connectionData.deleteService(serviceName);
+          externalService.delete(connectionData.id);
+          if(0 === externalService.size) {
+            this.services.delete(serviceName, connectionData.nodeType);
+          }
+          const serviceListeners = this.eventListeners.get(serviceName);
+          if(serviceListeners) {
+            serviceListeners.forEach((cb) => {
+              process.nextTick(cb, connectionData, false);
+            });
+          }
+        }
+        ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.yellow(' offer '), ddb.cyan(serviceName), ddb.red(' off'), ddb.yellow(' id: '), connectionData.id, ', instances: ', ddb.yellow(externalConnectionData.instances));
+      }
+      else {
+        ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.red(' Service: '), ddb.cyan(serviceName), ddb.yellow(' id: '), connectionData.id, ddb.red(' not removed, it does not exist!'));
+      }
+    }
+    else {
+      ddb.writelnTime(ExternalServices.NODE, connectionData.nodeName, ddb.yellow('::'), connectionData.nodeId, ddb.red(' Service: '), ddb.cyan(serviceName), ddb.yellow(' not removed, it does not exist!'));
+    }
+  }
+  
+  getServices() {
+    if(0 !== this.services.size) {
+      return [...this.services.keys()];
+    }
+    else {
+      return [];
+    }
+  }
+  
+  /*has(serviceName) {
+    return this.services.has(serviceName);
+  }*/
+  
+  getConnectionData(serviceName) {
+    const externalService = this.services.get(serviceName);
+    if(externalService) {
+      // ROUND - ROBIN
+      const externalConnectionData = externalService.entries().next().value[1];
+      if(1 <= externalService.size) {
+        externalService.delete(externalConnectionData.connectionData.id);
+        externalService.set(externalConnectionData.connectionData.id, externalConnectionData);
+      }
+      return externalConnectionData.connectionData;
+    }
+    else {
+      return null;
+    }
+  }
+  
+  on(serviceName, pluginService, cb) {
+    let serviceListeners = this.eventListeners.get(serviceName);
+    if(!serviceListeners) {
+      serviceListeners = new Map();
+      this.eventListeners.set(serviceName, serviceListeners);
+    }
+    serviceListeners.set(pluginService, cb);
+    if(this.services.has(serviceName)) {
+      cb();
+    }
+  }
+}
+
+
+module.exports = ExternalServices;

package/project/server/node/http-cache.js

@@ -0,0 +1,109 @@
+
+'use strict';
+
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+const MimeTypes = require('mime-types');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class HttpCache {
+  constructor() {
+    this.pathsArray = [];
+    this.cacheContent = new Map();
+    this.watchPaths = new Set();
+  }
+  
+  setPaths(watchPaths) {
+    this.pathsArray.push(watchPaths); 
+    watchPaths.forEach((watchPath) => {
+      if(!this.watchPaths.has(watchPath)) {
+        Fs.watch(watchPath, {persistent: false, recursive: true}, (eventType, filename) => {
+          if(filename && 'change' === eventType) {
+            const file = `${watchPath}/${filename.replace(/\\/g, '/')}`;
+            this.cacheContent.delete(file);
+          }
+        });
+        this.watchPaths.add(watchPath);
+      }
+    });
+    return this.pathsArray.length - 1;
+  }
+  
+  get(pathIndex, req, file, compressed, cb) {
+    const paths = this.pathsArray[pathIndex];
+    if(0 == paths.length) {
+      cb(false, null);
+    }
+    else {
+      const pragma = req.headers['pragma'];
+      if('no-cache' === pragma) {
+        this.cacheContent.delete(file);
+      }
+      this._getContent(req, file, paths, compressed, (data) => {
+        if(!data) {
+          cb(true, null);
+          return;
+        }
+        const ifNoneMatch = req.headers['if-none-match'];
+        if(ifNoneMatch === data.eTag) {
+          cb(false, data);
+          return;
+        }
+        const ifModifiedSince = req.headers['if-modified-since'];
+        if(ifModifiedSince === data.lastModified) {
+          cb(false, data);
+          return;
+        }
+        cb(true, data);
+      });
+    }
+  }
+  
+  _readFile(file, paths, compressed, cb) {
+    let found = false;
+    let index = 0;
+    let pendings = paths.length;
+    while(!found && index < paths.length) {
+      const fileAndPath = `${paths[index++]}${file}${compressed ? '.gzip' : ''}`;
+      Fs.readFile(fileAndPath, (err, data) => {
+        if(!err) {
+          if(!found) {
+            found = true;
+            const foundContent = {
+              content: data,
+              contentLength: Buffer.byteLength(data),
+              mimeType: MimeTypes.lookup(file),
+              lastModified: new Date().toUTCString(),
+              eTag: `W/"${GuidGenerator.create()}"`
+            };
+            this.cacheContent.set(file, foundContent);
+            cb(foundContent);
+          }
+          --pendings;
+        }
+        else {
+          if(0 === --pendings) {
+            if(!found) {
+              cb(null);
+            }
+          }
+        }
+      });
+    }
+  }
+  
+  _getContent(req, file, paths, compressed, cb) {
+    const range = req.headers['range'];
+    const content = this.cacheContent.get(file);
+    if(content) {
+      cb(content);
+    }
+    else {
+      this._readFile(file, paths, compressed, cb);
+    }
+  }
+}
+
+
+module.exports = HttpCache;

package/project/server/node/http-proxy.js

@@ -0,0 +1,97 @@
+
+'use strict';
+
+const http = require('http');
+
+class HttpProxy {
+  constructor() {
+    
+  }
+  
+  init(httpData, tls) {}
+  
+  handle(req, res) {
+    let reqUrl = '';
+    if(req.url.startsWith('/http')) {
+      reqUrl = req.url.substring(1).replaceAll('%3A', ':');
+      reqUrl = reqUrl.replaceAll('%2E', '.');
+    }
+    else {
+      reqUrl = req.url;
+    }
+    console.log('reqUrl:', reqUrl);
+    const url = new URL(reqUrl);
+    const httpAgent = new http.Agent({keepAlive:true});
+    const options = {
+      hostname: url.hostname,
+      port: url.port,
+      path: req.path,
+      method: req.method,
+      headers: {...req.headers, connection:'keep-alive'}//,
+    //  agent: httpAgent
+    };
+    Reflect.set(options.headers, 'host', url.hostname);
+    // Reflect.set(options.headers, 'referer', `http://${url.hostname}`);
+    
+    this.sendRequest(req, res, options);
+  }
+  
+  sendRequest(req, res, options) {
+    console.log('****', options.hostname);
+    console.log('****', options.port);
+    console.log('****', options.path);
+    console.log('****', options.method);
+    console.log('****', options.headers);
+    const proxy = http.request(options, (proxyRes) => {
+      //console.log(proxyRes);
+      /*const headers = { ...proxyRes.headers, connection: 'keep-alive' };
+      res.writeHead(proxyRes.statusCode, headers);
+      //proxyRes.pipe(res, { end: true });*/
+      let body = '';
+      
+        // Collect the response data
+        proxyRes.on('data', (chunk) => {
+          console.log('************************************************** data');
+           body += chunk;
+          console.log(chunk.toString());
+        });
+        
+        // Modify the response data and send it back to the client
+        proxyRes.on('end', () => {
+          console.log('************************************************** end');
+            // Modify the body here
+           // body = body.replace('original text', 'modified text');
+           console.log(body.toString());
+            // Modify response headers if necessary
+        const headers = { ...proxyRes.headers, connection: 'keep-alive' }; // Set keep-alive header
+          console.log('#####', proxyRes.statusCode)
+        if(200 === proxyRes.statusCode) {
+          res.writeHead(proxyRes.statusCode, headers);
+          res.end(body);
+        }
+        else if(302 === proxyRes.statusCode) {
+        //  console.log(proxyRes.headers);
+        //  console.log(proxyRes.rawHeaders);
+          options.path = headers.location;
+          this.sendRequest(req, res, options);
+        }
+        else {
+          res.writeHead(proxyRes.statusCode, headers);
+          res.end(body);
+        }
+      });
+    });
+    
+    proxy.on('error', (err) => {
+      console.log('************************************************** error');
+      console.error('Error with proxy:', err);
+      res.writeHead(502, { 'Content-Type': 'text/plain' });
+      res.end('Bad Gateway');
+    });
+    
+    req.pipe(proxy, { end: true });
+  }
+}
+
+
+module.exports = HttpProxy;

package/project/server/node/http-request-handler.js

@@ -0,0 +1,219 @@
+
+'use strict';
+
+
+class HttpRequestHandler {
+  constructor(httpCache, dataResponse, defaultSite) {
+    this.httpCache = httpCache;
+    this.dataResponse = dataResponse;
+    this.defaultSite  = defaultSite.startsWith('/') ? defaultSite : `/${defaultSite}`;
+    this.baseUrl = '';
+    this.pathId = -1;
+    this.authenticationToken = `token-${this.dataResponse.appName}=`
+    this.production = 'production' === process.env.NODE_ENV;
+    this.content = [
+      {
+        search: '/assets/',
+        route: '',
+        remove: ''
+      },
+      {
+        search: '/fonts/',
+        route: '',
+        remove: '/fonts'
+      }
+    ];
+  }
+  
+  _getToken(cookie) {
+     let token = '';
+     if(cookie) {
+      let startIndex = cookie.indexOf(this.authenticationToken);
+      if(-1 !== startIndex) {
+        startIndex += this.authenticationToken.length;
+        const stopIndex = cookie.indexOf(';', startIndex);
+        token = cookie.substring(startIndex, -1 !== stopIndex ? stopIndex : undefined);
+      }
+    }
+  }
+  
+  handle(req, res) {
+    //console.log('############################################');
+    //console.log(req.url, {...req.headers});
+    //console.log('############################################');
+    const myURL = new URL(req.url, this.baseUrl);
+    //console.log(req.url);
+   // console.log(req.headers);
+    if(myURL.pathname.startsWith('/abs-data/')) {
+      try {
+        if(req.method == 'POST') {
+          const rawBody = [];
+          req.on('data', (chunk) => {
+            rawBody.push(chunk);
+          });
+          req.on('end', () => {
+            const token = this._getToken(req.headers.cookie);
+            const requestObject = this._safeJsonParse(Buffer.concat(rawBody).toString());
+            if(null !== requestObject) {
+              this.dataResponse.handleRequests(requestObject, token, null, (response, dataBuffers, debug, token) => {
+                if(!token) {
+                  this.jsonResponseHttp(res, JSON.stringify(response));
+                }
+                else {
+                  this.jsonLoginResponseHttp(res, token, JSON.stringify(response));
+                }
+              }, (message) => {
+                ddb.warning('DROPPED MSG:');
+              });
+            }
+            else {
+              ddb.error('BAD REQ:');
+              res.writeHead(400, 'Bad Request', {'Content-Length': '0'});
+              res.end();
+            }
+          });
+          return;
+        }
+      }
+      catch(err) {
+        ddb.error(err);
+        this.notFound(res);
+        return;
+      }
+      this.notImplementedServerError(res);
+    }
+    else if(myURL.pathname.startsWith('/abs-scripts/')) {
+      this.contentResponse(req, res, `/${myURL.pathname.substring('/abs-scripts/'.length)}`, true);
+    }
+    else if(myURL.pathname.startsWith('/abs-css/')) {
+      this.contentResponse(req, res, `/${myURL.pathname.substring('/abs-css/'.length)}`, true);
+    }
+    else if(myURL.pathname.startsWith('/abs-images/')) {
+      this.contentResponse(req, res, `/${myURL.pathname.substring('/abs-images/'.length)}`);
+    }
+    else {
+      const foundIndex = this.content.findIndex((content) => (-1 != myURL.pathname.indexOf(content.search)));
+      if(-1 !== foundIndex) {
+        const content = this.content[foundIndex];
+        const url = `${content.route}${myURL.pathname.substring(myURL.pathname.indexOf(content.search) + content.remove.length)}`;
+        this.contentResponse(req, res, url);
+      }
+      else if(myURL.pathname === '/favicon.ico') {
+        this.contentResponse(req, res, '/svg/ActorJsA.svg');
+      }
+      else if(myURL.pathname === '/') {
+        this.redirect(res, this.defaultSite);
+      }
+      else if(myURL.pathname.startsWith('/abs-api/')) {
+        const rawBody = [];
+        req.on('data', (chunk) => {
+          rawBody.push(chunk);
+        });
+        req.on('end', () => {
+          const token = this._getToken(req.headers.cookie);
+          this.dataResponse._handleRest(req.method, myURL.pathname, req.headers['content-type'], rawBody, token, (statusCode, reasonPhrase, contentType, content) => {
+            this.restResponse(res, statusCode, reasonPhrase, contentType, content)
+          });
+        });
+      }
+      else {
+        this.contentResponse(req, res, '/index.html', false, true);
+      }
+    }
+  }
+  
+  init(data, tls) {
+    this.baseUrl = `http${tls ? 's' : ''}://${data.host}:${data.port}`;
+    this.domain = data.host;
+    this.pathId = this.httpCache.setPaths(data.directories);
+  }
+  
+  contentResponse(req, res, file, compressed, forced) {
+    const useCompressed = !!compressed && this.production;
+    this.httpCache.get(this.pathId, req, file, useCompressed, (modified, data) => {
+      if(data) {
+        if(modified || forced) {
+          res.setHeader('Accept-Ranges', 'bytes');
+          res.setHeader('Cache-Control', 'public, max-age=604800');
+          res.setHeader('ETag', data.eTag);
+          res.setHeader('Content-Type', data.mimeType + '; charset=utf-8');
+          res.setHeader('Date', new Date().toUTCString());
+          if(useCompressed) {
+            res.setHeader('Content-Encoding', 'gzip');
+          }
+          res.write(data.content);
+          res.end();
+        }
+        else {
+          res.writeHead(304, 'Not Modified', {
+            'Cache-Control': 'public, max-age=604800',
+            'ETag': data.eTag,
+            'Date': new Date().toUTCString()
+          });
+          res.end();
+        }
+      }
+      else {
+        ddb.error('not found:', file);
+        this.notFound(res);
+      }
+    });
+  }
+  
+  jsonResponseHttp(res, data) {
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.write(data);
+    res.end();
+  }
+  
+  jsonLoginResponseHttp(res, token, data) {
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('Set-Cookie', `${this.authenticationToken}${'-1' === token ? '' : token}; Domain=${this.domain}; Max-Age=${'-1' === token ? '0' : '604800'}; HttpOnly`);
+    res.write(data);
+    res.end();
+  }
+  
+  restResponse(res, statusCode, reasonPhrase, contentType, content) {
+    res.writeHead(statusCode, reasonPhrase);
+    if(content) {
+      res.setHeader('Content-Type', contentType + '; charset=utf-8');
+      if('application/json' === contentType) {
+        res.write(JSON.stringify(content, null, 2));
+      }
+      else {
+        res.write(content);
+      }
+    }
+    res.end();
+  }
+  
+  redirect(res, to) {
+    res.writeHead(302, {'Location': to});
+    res.end();
+  }
+  
+  notImplementedServerError(res) {
+    res.writeHead(501, "Not implemented", {'Content-Type': 'text/html; charset=utf-8'});
+    res.end(this.errorHtml('501 - Not implemented', '<h1>Not implemented!</h1>'));
+  }
+  
+  notFound(res) {
+    res.writeHead(404, 'Not Found', {"Content-Type": "text/html; charset=utf-8"});
+    res.end(this.errorHtml('404 - Not Found', '<h1>Not Found!</h1>'));
+  }
+  
+  errorHtml(title, bodyText) {
+    return '<!DOCTYPE html><html lang="en-US"><head><title>' + title + '</title><meta charset="UTF-8"></head><body>' + bodyText + '</body></html>';
+  }
+  
+  _safeJsonParse(string) {
+    try {
+      return JSON.parse(string);
+    }
+    catch(err) {
+      return null;
+    }
+  }
+}
+
+module.exports = HttpRequestHandler;

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

@@ -0,0 +1,36 @@
+
+'use strict';
+
+const HttpProxy = require('./http-proxy');
+const HttpRequestHandler = require('./http-request-handler');
+const Http = require('http');
+
+
+class HttpServer {
+  constructor(serverData, nodeName, nodeId, httpCache, dataResponse, defaultSite) {
+    this.serverData = serverData;
+    this.nodeName = nodeName;
+    this.nodeId = nodeId;
+    this.httpRequestHandler = 'web & rest' === serverData.type ? new HttpRequestHandler(httpCache, dataResponse, defaultSite) : new HttpProxy();
+    this.pathsId = -1;
+  }
+  
+  start(httpData, cb) {
+    this.httpRequestHandler.init(httpData, false);
+    const server = Http.createServer((req, res) => {
+      this.httpRequestHandler.handle(req, res);
+    });
+    server.on('listening', () => {
+      ddb.writelnTime(ddb.cyan('Server:   '), `${this.nodeName}-${httpData.name} `, ddb.green('started at '), `http://${httpData.host}:${httpData.port}`);
+      cb();
+    });
+	  server.on('error', (err) => {
+      ddb.writelnTimeError(err, ddb.red('Server: '), `'${this.nodeName}-${httpData.name}' `, ddb.red('did not start at '), `http://${httpData.host}:${httpData.port }`, ddb.red(',error: '), err.message);
+      cb(err);
+    });
+    server.listen(httpData.port, httpData.host);
+  }
+}
+
+
+module.exports = HttpServer;