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

package/project/server/address/address.js

@@ -0,0 +1,176 @@
+
+'use strict';
+
+const Net = require('net');
+const Dns = require('dns');
+
+
+class Address {
+  static IS_LOCAL = true;
+  static IS_REMOTE = false;
+  
+  static CLIENT = 'client';
+  static SUT = 'sut';
+  static SERVER = 'server';
+  
+  static PORT_NOT_SET = 0;
+  static PORT_VALUE = 1;
+  static PORT_ZERO = 2;
+  static PORT_GENERATED = 3;
+  
+  static DNS_RESOLVED_NOT = 0;
+  static DNS_RESOLVED_PENDING = 1;
+  static DNS_RESOLVED = 2;
+  
+  constructor(addressName, host, family, port, type, page, incognitoBrowser, uri) {
+    this.addressName = addressName;
+    //this.logName = '';
+    this.host = host;
+    this.family = family ? family : 'IPv4';
+    this.port = 'number' === typeof port ? port: (!!port ? Number.parseInt(port) : null);
+    this.portValueType = null === this.port ? Address.PORT_NOT_SET : (0 === this.port ? Address.PORT_ZERO : Address.PORT_VALUE);
+    this.type = type;
+    this.page = page;
+    this.incognitoBrowser = incognitoBrowser;
+    this.uri = uri
+    this.domain = null;
+    this.proxy = false;
+    this.isResolved = Address.DNS_RESOLVED_NOT;
+  }
+  
+  clone(port) {
+    const address = new Address(this.addressName, this.host, this.family, port ? port : this.port, this.type, this.page, this.incognitoBrowser, this.uri);
+    address.portValueType = this.portValueType;
+    address.domain = this.domain;
+    address.proxy = this.proxy;
+    address.isResolved = this.isResolved;
+    //address.logName = this.logName;
+    return address;
+  }
+  
+  //setLogName(logName) {
+  //  this.logName =     this.logName = logName;
+  ///
+  
+  static from(address) {
+    const newAddress = new Address(address.addressName, address.host, address.family, address.port, address.type, address.page, address.incognitoBrowser, address.uri);
+    newAddress.portValueType = address.portValueType;
+    newAddress.domain = address.domain;
+    newAddress.proxy = address.proxy;
+    newAddress.isResolved = address.isResolved;
+    //address.logName = this.logName;
+    return newAddress;
+  }
+  
+  static netAddress(srcAddress, dstAddress, port=-1, protocol='') {
+    if(!protocol) {
+      if(-1 !== port) {
+        return Address._netAddressTcp(srcAddress, dstAddress, port);
+      }
+      else {
+        return Address._netAddressTcp(srcAddress, dstAddress.host, dstAddress.port);
+      }
+    }
+    else {
+      if(-1 !== port) {
+        return Address._netAddressTls(srcAddress, dstAddress, port);
+      }
+      else {
+        return Address._netAddressTls(srcAddress, dstAddress.host, dstAddress.port);
+      }
+    }
+  }
+  
+  static _netAddressTcp(srcAddress, address, port) {
+    if('DEFAULT_SRC' !== srcAddress.addressName) {
+      return {
+        localAddress: srcAddress.host,
+        localPort: srcAddress.port,
+        host: address,
+        port: port,
+        allowHalfOpen: true
+      };
+    }
+    else {
+      return {
+        host: address,
+        port: port,
+        allowHalfOpen: true
+      };
+    }
+  }
+  
+  static _netAddressTls(srcAddress, address, port) {
+    if('DEFAULT_SRC' !== srcAddress.addressName) {
+      return {
+        localAddress: srcAddress.host,
+        localPort: srcAddress.port,
+        host: address,
+        port: port,
+        allowHalfOpen: true,
+        checkServerIdentity: (host, cert) => {}
+      };
+    }
+    else {
+      return {
+        host: address,
+        port: port,
+        allowHalfOpen: true,
+        checkServerIdentity: (host, cert) => {}
+      };
+    }
+  }
+  
+  resolve(portDefault) {
+    if(Address.DNS_RESOLVED === this.isResolved) {
+      return Address.DNS_RESOLVED;
+    }
+    if(!!this.uri) {
+      const url = new URL(this.uri);
+      this.domain = url.hostname;
+      this.port = url.port ? Number.parseInt(url.port) : this.port;
+      if(0 === this.port) {
+          this.portValueType = Address.PORT_ZERO;
+        }
+        else {
+          this.portValueType = Address.PORT_VALUE;
+        }
+    }
+    if(!this.port) {
+      if(!portDefault) {
+        this.port = 0;
+        this.portValueType = Address.PORT_ZERO;
+      }
+      else {
+        this.port = portDefault;
+        if(0 === this.port) {
+          this.portValueType = Address.PORT_ZERO;
+        }
+        else {
+          this.portValueType = Address.PORT_VALUE;
+        }
+      }
+    }
+    return Address.DNS_RESOLVED_PENDING;
+  }
+  
+  setResolved(address) {
+    this.host = address;
+    this.isResolved = Address.DNS_RESOLVED;
+  }
+  
+  setProxy(address) {
+    this.host = address.host;
+    this.port = address.port;
+    if(0 === this.port) {
+      this.portValueType = Address.PORT_ZERO;
+    }
+    else {
+      this.portValueType = Address.PORT_VALUE;
+    }
+    this.proxy = true;
+  }
+}
+
+
+module.exports = Address;

package/project/server/address/addresses.js

@@ -0,0 +1,122 @@
+
+'use strict';
+
+const Address = require('./address');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const Fs = require('fs');
+
+
+class Addresses {
+  constructor() {
+    this.srcs = new Map();
+    this.sutSrvs = new Map();
+    this.srvs = new Map();
+  }
+  
+  getSrc(name) {
+    if(name) {
+      const src = this.srcs.get(name);
+      if(src) {
+        return src;
+      }
+      else {
+        return this.sutSrvs.get(name);
+      }
+    }
+    else {
+      const firstSrc = this.srcs.values().next().value;
+      if(firstSrc) {
+        return firstSrc;
+      }
+      else {
+        return this.sutSrvs.values().next().value;
+      }
+    }
+  }
+  
+  getDst(name) {
+    if(name) {
+      const dst = this.sutSrvs.get(name);
+      if(undefined !== dst) {
+        return dst;
+      }
+      else {
+        return this.srvs.get(name);
+      }
+    }
+    else {
+      const dst = this.sutSrvs.values().next().value;
+      if(dst) {
+        return dst;
+      }
+      else {
+        return this.srvs.values().next().value;
+      }
+    }
+  }
+  
+  getSrv(name) {
+    if(name) {
+      const srv = this.srvs.get(name);
+      if(srv) {
+        return srv;
+      }
+      else {
+        return this.sutSrvs.get(name);
+      }
+    }
+    else {
+      const firstSrv = this.srvs.values().next().value;
+      if(firstSrv) {
+        return firstSrv;
+      }
+      else {
+        return this.sutSrvs.values().next().value;
+      }
+    }
+  }
+  
+  getDefaultSrc() {
+    
+  }
+  
+  sut(name) {
+    return this.srvs.has(name);
+  }
+    
+  static save(addresses, done) {
+    Fs.writeFile(ActorPathGenerated.getAddressesFile(), JSON.stringify(addresses, null, 2), (err) => {
+      done(err);
+    });
+  }
+  
+  static set(from, to) {
+    if(from) {
+      from.forEach((value) => {
+        const address = value[1];
+        to.set(value[0], new Address(address.addressName, address.host, address.family, address.port, address.type, address.page, address.incognitoBrowser, address.uri));
+      });
+    }
+  }
+  
+  static load(addresses, done) {
+    Fs.readFile(ActorPathGenerated.getAddressesFile(), (err, data) => {
+      if(err) {
+        return done(err);
+      }
+      try {
+        const parsedAddresses = JSON.parse(data);
+        Addresses.set(parsedAddresses.srcs, addresses.srcs);
+        Addresses.set(parsedAddresses.dsts, addresses.sutSrvs);
+        Addresses.set(parsedAddresses.srvs, addresses.srvs);
+        done();
+      }
+      catch(e) {
+        done(e);  
+      }
+    });
+  }
+}
+
+module.exports = Addresses;

package/project/server/address/dns-url-cache.js

@@ -0,0 +1,130 @@
+
+'use strict';
+
+const Address = require('./address');
+const Dns = require('dns');
+const Net = require('net');
+
+
+class DnsUrlCache {
+  static id = 0;
+  
+  constructor() {
+    this.localDns = new Map();
+    this.cache = new Map();
+    this.pendings = new Map();
+  }
+  
+  resolveAddress(address, local, done) {
+    if(Address.DNS_RESOLVED === address.resolve()) {
+      process.nextTick(done, null);
+    }
+    else if(Address.DNS_RESOLVED === address.resolve()) {
+      const pendingQueue = this.pendings.get(address);
+      if(!pendingQueue) {
+        this.pendings.set(address, [done]);
+      }
+      else {
+        pendingQueue.push(done);
+      }
+    }
+    else {
+      this.get(local ? address.host : (address.domain ? address.domain : address.host), address.family, (err, ipAddress) => {
+        address.setResolved(ipAddress);
+        const pendingQueue = this.pendings.get(address);
+        process.nextTick(done, null);
+        if(pendingQueue) {
+          pendingQueue.forEach((queueDone) => {
+            process.nextTick(queueDone, null);
+          });
+        }
+        this.pendings.delete(address);
+      });
+    }
+  }
+  
+  setLocalDns(localDns) {
+    this.localDns = localDns;
+  }
+  
+  getLocalDns() {
+    return this.localDns;
+  }
+  
+  get(domain, family, done) {
+    const recordLocal = this.localDns.get(domain);
+    if(recordLocal) {
+      const position = recordLocal.position++;
+      if(position !== recordLocal.addresses.length) {
+        return done(null, recordLocal.addresses[position]);
+      }
+      else {
+        recordLocal.position = 0;
+        return done(null, recordLocal.addresses[0]);
+      }
+    }
+    const record = this.cache.get(domain);
+    if(record) {
+      const position = record.position++;
+      if(position !== record.addresses.length) {
+        return done(null, record.addresses[position]);
+      }
+      else {
+        record.position = 0;
+        return done(null, record.addresses[0]);
+      }
+    }
+    if('IPv4' === family) {
+      if(Net.isIPv4(domain)) {
+        this._Add(domain, [domain]);
+        return done(null, domain);
+      }
+      else {
+        Dns.resolve4(domain, (err, addresses) => {
+          if(err) {
+            return done(err);
+          }
+          this._Add(domain, addresses);
+          return done(null, addresses[0]);
+        });
+      }
+    }
+    else if('IPv6' === family) {
+      if(Net.isIPv6(domain)) {
+        this._Add(domain, [domain]);
+        return done(null, domain);
+      }
+      else {
+        Dns.resolve6(domain, (err, addresses) => {
+          if(err) {
+            return done(err);
+          }
+          this._Add(domain, addresses);
+          return done(null, addresses[0]);
+        });
+      }
+    }
+    else {
+      return done(new Error(`Unknown IP family '${family}'.`));
+    }
+  }
+  
+  _Add(domain, addresses) {
+    this.cache.set(domain, {
+      position: 0,
+      addresses: addresses
+    });
+  }
+  
+  override(address) {
+    if(address.proxy) {
+      this.cache.set(address.uri, {
+        position: 0,
+        addresses: [address]
+      });
+    }
+  }
+}
+
+
+module.exports = DnsUrlCache;

package/project/server/address/interfaces.js

@@ -0,0 +1,100 @@
+
+'use strict';
+
+const Address = require('./address');
+
+
+class Interfaces {
+  constructor(loginReport) {
+    this.loginReport = loginReport;
+  }
+  
+  calculate(networks, srcs, dsts, srvs) {
+    const addresses = {
+      srcs: [],
+      dsts: [],
+      srvs: []
+    };
+    const addressesSutSearch = new Map();
+    const addressesServerSearch = new Map();
+    const addressesClientSearch = new Map();
+    const networkSearch = new Map();
+    
+    networks.forEach((network) => {
+      networkSearch.set(network.networkName, network);
+      network.suts.forEach((sut) => {
+        addressesSutSearch.set(sut.interfaceName, sut);
+      });
+      network.servers.forEach((server) => {
+        addressesServerSearch.set(server.interfaceName, server);
+      });
+      network.clients.forEach((client) => {
+        addressesClientSearch.set(client.interfaceName, client);
+      });
+    });
+    srcs.forEach((src) => {
+      const addressClient = addressesClientSearch.get(src.interfaceName);
+      if(!!addressClient) {
+        const network = networkSearch.get(addressClient.networkName);
+        if(!!network) {
+          addresses.srcs.push([src.addressName, new Address(src.addressName, addressClient.address, network.family, src.port, Address.CLIENT, src.page, src.incognitoBrowser)]);
+        }
+        else {
+          this.loginReport.networkLog(`Src network '${addressClient.networkName}' does not exist.`);
+          // TODO: create log
+          ddb.error(`src network '${addressClient.networkName}' does not exist.`);
+        }
+      }
+      else {
+        // TODO: create log
+        ddb.error(`src address interface '${src.interfaceName}' does not exist.`);
+      }
+    });
+    dsts.forEach((dst) => {
+      const addressSut = addressesSutSearch.get(dst.interfaceName);
+      if(!!addressSut) {
+        const network = networkSearch.get(addressSut.networkName);
+        if(!!network) {
+          addresses.dsts.push([dst.addressName, new Address(dst.addressName, addressSut.address, network.family, dst.port, Address.SUT, undefined, undefined, dst.uri)]);
+        }
+        else {
+          this.loginReport.networkLog(`Dst network '${addressSut.networkName}' does not exist.`);
+          // TODO: create log
+          ddb.error(`dst network '${addressSut.networkName}' does not exist.`);
+        }
+      }
+      else if(!!dst.uri) {
+        addresses.dsts.push([dst.addressName, new Address(dst.addressName, null, null, dst.port, Address.SUT, undefined, undefined, dst.uri)]);
+      }
+      else {
+        // TODO: create log
+        ddb.error(`dst address interface '${dst.interfaceName}' does not exist.`);
+      }
+    });
+    const srvAddresses = new Map();
+    srvs.forEach((srv) => {
+      const addressServer = addressesServerSearch.get(srv.interfaceName);
+      if(!!addressServer) {
+        const network = networkSearch.get(addressServer.networkName);
+        if(!!network) {
+          addresses.srvs.push([srv.addressName, new Address(srv.addressName, addressServer.address, network.family, srv.port, Address.SERVER, undefined, undefined, srv.uri)]);
+        }
+        else {
+          this.loginReport.networkLog(`Srv network '${addressServer.networkName}' does not exist.`);
+          // TODO: create log
+          ddb.error(`srv network '${addressServer.networkName}' does not exist.`);
+        }
+      }
+      else if(!!srv.uri) {
+        addresses.srvs.push([srv.addressName, new Address(srv.addressName, null, null, srv.port, Address.SERVER, undefined, undefined, srv.uri)]);
+      }
+      else {
+        // TODO: create log
+        ddb.error(`srv address interface '${srv.interfaceName}' does not exist.`);
+      }
+    });
+    return addresses;
+  }
+}
+
+module.exports = Interfaces;

package/project/server/address/local-dns.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const Fs = require('fs');
+
+
+class LocalDns {
+  static save(dns, done) {
+    Fs.writeFile(ActorPathGenerated.getLocalDnsFile(), JSON.stringify(dns, null, 2), (err) => {
+      done(err);
+    });
+  }
+  
+  static load(localDns, done) {
+    Fs.readFile(ActorPathGenerated.getLocalDnsFile(), (err, data) => {
+      if(err) {
+        return done(err);
+      }
+      try {
+        const parsedDns = JSON.parse(data);
+        parsedDns.forEach((dns) => {
+          localDns.set(dns[0], dns[1]);
+        });
+        done();
+      }
+      catch(e) {
+        done(e);  
+      }
+    });
+  }
+}
+
+
+module.exports = LocalDns;

package/project/server/address/login-report.js

@@ -0,0 +1,56 @@
+
+'use strict';
+
+
+class LoginReport {
+  constructor() {
+    this.logs = [];
+  }
+  
+  addressLog(action, status, log) {
+    this.logs.push({
+      reportType: 'address',
+      action: action,
+      status: status,
+      log: log
+    });
+  }
+  
+  realAddressLog(action, status, log) {
+    this.logs.push({
+      reportType: 'real-address',
+      action: action,
+      status: status,
+      log: log
+    });
+  }
+  
+  networkLog(action, status, log) {
+    this.logs.push({
+      reportType: 'network',
+      action: action,
+      status: status,
+      log: log
+    });
+  }
+  
+  interfaceLog(action, status, log) {
+    this.logs.push({
+      reportType: 'interface',
+      action: action,
+      status: status,
+      log: log
+    });
+  }
+  
+  dnsLog(action, status, log) {
+    this.logs.push({
+      reportType: 'dns',
+      action: action,
+      status: status,
+      log: log
+    });
+  }
+}
+
+module.exports = LoginReport;