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

package/project/server/stack/network/network-connection.js

@@ -0,0 +1,134 @@
+
+'use strict';
+
+const BufferManager = require('./buffer-manager');
+const Transport = require('./transport');
+
+
+class NetworkConnection {
+  constructor(transportProperties, name, type, connection) {
+    this.transportProperties = transportProperties;
+    this.name = name;
+    this.type = type;
+    this.connection = connection;
+    this.prefixLength = name.length + 1;
+    this.bufferManager = new BufferManager();
+    this.askedForReceiveLine = false;
+    this.askedForReceiveSize = 0;
+    this.askedForReceive = false;
+    this.cbDone = null;
+    this.isCancel = false;
+    this.lockSend = false;
+    this.lockReceive = false;
+  }
+  
+  halfClosed() {
+    return false;
+  }
+  
+  setTransportProperties(options, allowedProperties) {
+    Transport.setTransportProperties(options, this.transportProperties, allowedProperties, this.prefixLength)
+  }
+  
+  send(msg, done) {
+    this.isCancel = false;
+    this.sendMessage(msg, done);
+  }
+  
+  receiveLine(done) {
+    this.isCancel = false;
+    if(this.bufferManager.findLine()) {
+      const line = this.bufferManager.getLine();
+      process.nextTick(done, line, null);
+      this.cbDone = null;
+      this.askedForReceiveLine = false;  
+    }
+    else {
+      this.cbDone = done;
+      this.askedForReceiveLine = true;
+    }
+  }
+  
+  receiveSize(size, done) {
+    this.isCancel = false;
+    const buffer = this.bufferManager.receiveSize(size);
+    if(buffer) {
+      process.nextTick(done, buffer, null);
+      this.cbDone = null;
+      this.askedForReceiveSize = 0;
+    }
+    else {
+      this.cbDone = done;
+      this.askedForReceiveSize = size;
+    }
+  }
+  
+  receive(done) {
+    this.isCancel = false;
+    const buffers = this.bufferManager.receive();
+    if(buffers) {
+      process.nextTick(done, buffers, null);
+      this.cbDone = null;
+      this.askedForReceive = false;  
+    }
+    else {
+      this.cbDone = done;
+      this.askedForReceive = true;
+    }
+  }
+  
+  cancel() {
+    this.isCancel = true;
+  }
+  
+  onBuffer(buffer) {
+    if(this.isCancel) {
+      // TODO: Log dropped buffer
+      return;
+    }
+    this.bufferManager.addBuffer(buffer);
+    if(this.askedForReceiveLine) {
+      this.receiveLine(this.cbDone);
+    }
+    else if(0 < this.askedForReceiveSize) {
+      this.receiveSize(this.askedForReceiveSize, this.cbDone);
+    }
+    else if(this.askedForReceive) {
+      this.receive(this.cbDone);
+    }
+  }
+  
+  onEnd() {
+    const done = this.cbDone;
+    this.cbDone = null;
+    if(this.askedForReceiveLine || this.askedForReceive || 0 !== this.askedForReceiveSize) {
+      process.nextTick(done, null, new Error('internal_error_network_end'));
+      this.askedForReceiveLine = false;
+      this.askedForReceiveSize = 0;
+      this.askedForReceive = false;
+    }
+  }
+  
+  onError() {
+    
+  }
+    
+  getSrvAddress() {
+    return this.srvAddress;
+  }
+  
+  getDstAddress() {
+    return this.dstAddress;
+  }
+  
+  getLocal() {
+    return this.localAddress;
+  }
+  
+  getRemote() {
+    return this.remoteAddress;
+  }
+}
+
+
+module.exports = NetworkConnection;

package/project/server/stack/network/network-helper.js

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

package/project/server/stack/network/network-server.js

@@ -0,0 +1,36 @@
+
+'use strict';
+
+const Transport = require('./transport');
+
+
+class NetworkServer {
+  constructor(connection, cbConnection, name) {
+    this.connection = connection;
+    this.cbConnection = cbConnection;
+    this.name = name;
+    this.srvAddress = null;
+    this.dstAddress = null;
+    this.prefixLength = name.length + 1;
+    this.serverSocket = null;
+  }
+  
+  close(cbClose) {
+    if(null !== this.serverSocket) {
+      this.serverSocket.close((err) => {
+        cbClose();
+      });
+      this.serverSocket = null;
+    }
+    else {
+      process.nextTick(cbClose);
+    }
+  }
+  
+  setTransportProperties(options, transportProperties, allowedProperties) {
+    Transport.setTransportProperties(options, transportProperties, allowedProperties, this.prefixLength)
+  }
+}
+
+
+module.exports = NetworkServer;

package/project/server/stack/network/network-type.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+// TODO: Remove - equal as 
+class NetworkType {
+  static getNetworkName(networkId) {
+    if(networkId < NetworkType.NetworkNames.length && networkId >= 0) {
+      return NetworkType.NetworkNames[networkId];
+    }
+    else {
+      return NetworkType.NetworkNameUnknown;
+    }
+  }
+  static getNetworkType(networkName) {
+    return _NetworkTypeConst_NetworkTypeNames.get(networkName);
+  }
+}
+
+NetworkType.DEFAULT = -1;
+NetworkType.TCP = 0;
+NetworkType.UDP = 1;
+NetworkType.MC = 2;
+NetworkType.TLS = 3;
+NetworkType.BC = 4;
+NetworkType.SCTP = 5;
+NetworkType.QUIC = 6;
+
+NetworkType.NetworkNames = [
+  'tcp',
+  'udp',
+  'mc',
+  'tls',
+  'bc',
+  'sctp',
+  'quic'
+];
+
+NetworkType.NetworkNameUnknown = 'unknown';
+
+const _NetworkTypeConst_NetworkTypeNames = new Map();
+for(let i = 0; i < NetworkType.NetworkNames.length; ++i) {
+  _NetworkTypeConst_NetworkTypeNames.set(NetworkType.NetworkNames[i], i);
+}
+
+
+module.exports = NetworkType;

package/project/server/stack/network/tcp/tcp-connection-client-shared.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const TcpConnectionShared = require('./tcp-connection-shared');
+
+
+class TcpConnectionClientShared extends TcpConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+  
+  connect(done) {
+    this.networkConnection.connect(done);
+  }
+}
+
+
+module.exports = TcpConnectionClientShared;

package/project/server/stack/network/tcp/tcp-connection-client.js

@@ -0,0 +1,71 @@
+
+'use strict';
+
+const TcpConnection = require('./tcp-connection');
+const Net = require('net');
+
+
+class TcpConnectionClient extends TcpConnection {
+  static TRANSPORT_PROPERTIES = new Set(['allowHalfOpen', 'noDelay', 'keepAlive', 'keepAliveInitialDelay']);
+  
+  constructor(srcAddress, dstAddress, transportProperties, connection) {
+    super(transportProperties, 'client', connection);
+    this.srcAddress = srcAddress;
+    this.dstAddress = dstAddress;
+    this.err = null;
+  }
+  
+  connect(done) {
+    let timeoutId = -1;
+    this.cbError = (err) => {
+      this.cbError = null;
+      if(-1 !== timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.err = err;
+    };
+    const options = {
+      host: this.dstAddress.host,
+      port: this.dstAddress.port,
+      localAddress: this.srcAddress.host,
+      localPort: this.srcAddress.port
+    };
+    this.setTransportProperties(options, TcpConnectionClient.TRANSPORT_PROPERTIES);
+    const socket = Net.connect(options, () => {
+      if(this.cbError) {
+        this.cbError();
+        if(done) {
+          const doDone = done;
+          done = null;
+          doDone(this.err);
+        }
+      }
+    });
+    if(!this.connection.actor.debug) {
+      timeoutId = setTimeout(() => {
+        if(this.cbError) {
+          this.cbError(new Error('Timeout'));
+          socket.destroy();
+        }
+      }, 10);
+    }
+    socket.on('error', (err) => {
+      if(this.cbError) {
+        this.cbError(err);
+      }
+    });
+    socket.on('close', () => {
+      if(this.err) {
+        if(done) {
+          const doDone = done;
+          done = null;
+          doDone(this.err);
+        }
+      }
+    });
+    this.attach(socket);
+  }
+}
+
+
+module.exports = TcpConnectionClient;

package/project/server/stack/network/tcp/tcp-connection-server-shared.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+const TcpConnectionShared = require('./tcp-connection-shared');
+
+
+class TcpConnectionServerShared extends TcpConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+}
+
+
+module.exports = TcpConnectionServerShared;

package/project/server/stack/network/tcp/tcp-connection-server.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const TcpConnection = require('./tcp-connection');
+
+
+class TcpConnectionServer extends TcpConnection {
+  constructor(srvAddress, dstAddress, transportProperties, connection) {
+    super(transportProperties, 'server', connection);
+    this.srvAddress = srvAddress;
+    this.dstAddress = dstAddress;
+  }
+}
+
+
+module.exports = TcpConnectionServer;

package/project/server/stack/network/tcp/tcp-connection-shared.js

@@ -0,0 +1,55 @@
+
+'use strict';
+
+const NetworkConnectionShared = require('../network-connection-shared');
+
+
+class TcpConnectionShared extends NetworkConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+    
+  attach(socket) {
+    this.networkConnection.attach(socket);
+  }
+  
+  close(done) {
+    if(0 === this.unref()) {
+      this.networkConnection.close(done);
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  sendMessage(msg) {
+    this.networkConnection.sendMessage(msg);
+  }
+    
+  getLocalAddress() {
+    return this.networkConnection.getLocalAddress();
+  }
+  
+  getLocalPort() {
+    return this.networkConnection.getLocalPort();
+  }
+  
+  getLocalFamily() {
+    return this.networkConnection.getLocalFamily();
+  }
+  
+  getRemoteAddress() {
+    return this.networkConnection.getRemoteAddress();
+  }
+  
+  getRemotePort() {
+    return this.networkConnection.getRemotePort();
+  }
+  
+  getRemoteFamily() {
+    return this.networkConnection.getRemoteFamily();
+  }
+}
+
+
+module.exports = TcpConnectionShared;

package/project/server/stack/network/tcp/tcp-connection.js

@@ -0,0 +1,167 @@
+
+'use strict';
+
+const NetworkConnection = require('../network-connection');
+
+
+class TcpConnection extends NetworkConnection {
+  constructor(transportProperties, type, connection) {
+    super(transportProperties, 'tcp', type, connection);
+    this.socket = null;
+    this.cbError = null;
+    this.queue = [];
+    this.stall = false;
+    this.endDone = null;
+    this.closeDone = null;
+  }
+  
+  attach(socket) {
+    this.socket = socket;
+    this.socket.on('data', (buffer) => {
+      this.onBuffer(buffer);
+    });
+    this.socket.on('end', () => {
+      this.onEnd();
+    });
+    this.socket.on('error', (err) => {
+      if(this.cbError) {
+        this.cbError(err);
+      }
+      else {
+        this.onError(err);
+      }
+    });
+  }
+  
+  end(done) {
+    if(null !== this.socket) {
+      if(this.transportProperties?.has('allowHalfOpen')) {
+        if(this.queue.length > 0) {
+          this.endDone = done;
+          return;
+        }
+        this.socket.once('end', (hadError) => {
+          done();
+        });
+        this.socket.end();
+        return;
+      }
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  close(done) {
+    if(null !== this.socket) {
+      if(this.queue.length > 0) {
+        this.closeDone = done;
+        return;
+      }
+      this.socket.once('close', (hadError) => {
+        done();
+      });
+      this.socket.destroy();
+      return;
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  closed() {
+    return !this.socket || this.socket && this.socket.destroyed;
+  }
+  
+  halfClosed() {
+    return !this.socket || this.socket && 'readOnly' === this.socket.readyState;
+  }
+  
+  sendMessage(msg) {
+    if(this.stall) {
+      this.queue.push(msg);
+      return;
+    }
+    const ok = this.socket.write(msg);
+    if(!ok) {
+      this._enterStall();
+    }
+  }
+  
+  _enterStall() {
+    if(this.stall) {
+      return;
+    }
+    this.stall = true;
+    this.socket.once('drain', () => {
+      this.stall = false;
+      this._flushQueue();
+    });
+  }
+  
+  _flushQueue() {
+    while(!this.stall && this.queue.length > 0) {
+      const msg = this.queue.shift();
+      const ok = this.socket.write(msg);
+      if(!ok) {
+        this._enterStall();
+        return;
+      }
+    }
+    if(0 === this.queue.length) {
+      if(this.endDone) {
+        this.end(() => {
+          this.endDone();
+          this.endDone = null;
+          if(this.closeDone) {
+            this.close(this.closeDone);
+            this.closeDone = null;
+          }
+        });
+      }
+      else if(this.closeDone) {
+        this.close(this.closeDone);
+        this.closeDone = null;
+      }
+    }
+  }
+    
+  getLocalAddress() {
+    if(null !== this.socket) {
+      return this.socket.localAddress;
+    }
+  }
+  
+  getLocalPort() {
+    if(null !== this.socket) {
+      return this.socket.localPort;
+    }
+  }
+  
+  getLocalFamily() {
+    if(null !== this.socket) {
+      return this.socket.localFamily;
+    }
+  }
+  
+  getRemoteAddress() {
+    if(null !== this.socket) {
+      return this.socket.remoteAddress;
+    }
+  }
+  
+  getRemotePort() {
+    if(null !== this.socket) {
+      return this.socket.remotePort;
+    }
+  }
+  
+  getRemoteFamily() {
+    if(null !== this.socket) {
+      return this.socket.remoteFamily;
+    }
+  }
+}
+
+
+module.exports = TcpConnection;

package/project/server/stack/network/tcp/tcp-server.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const NetworkServer = require('../network-server');
+const Net = require('net');
+
+
+class TcpServer extends NetworkServer {
+  static TRANSPORT_PROPERTIES = new Set(['allowHalfOpen', 'pauseOnConnect', 'noDelay', 'keepAlive', 'keepAliveInitialDelay']);
+  
+  constructor(connection, cbConnection) {
+    super(connection, cbConnection, 'tcp');
+  }
+  
+  init(srvAddress, dstAddress, transportProperties, cbListen) {
+    this.srvAddress = srvAddress;
+    const options = {};
+    this.setTransportProperties(options, transportProperties, TcpServer.TRANSPORT_PROPERTIES);
+    this.serverSocket = Net.createServer(options, (socket) => {
+      this.cbConnection(socket);
+    });
+    this.serverSocket.on('error', (err) => {
+      cbListen(err);
+    });
+    this.serverSocket.listen({
+      host: this.srvAddress.host,
+      port: this.srvAddress.port
+    }, () => {
+      cbListen();
+    });
+  }
+}
+
+
+module.exports = TcpServer;

package/project/server/stack/network/tls/tls-connection-client-shared.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const TlsConnectionShared = require('./tls-connection-shared');
+
+
+class TlsConnectionClientShared extends TlsConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+  
+  connect(done) {
+    this.networkConnection.connect(done);
+  }
+}
+
+
+module.exports = TlsConnectionClientShared;

package/project/server/stack/network/tls/tls-connection-client.js

@@ -0,0 +1,76 @@
+
+'use strict';
+
+const StackComponentsCerts = require('z-abs-funclayer-stack-server/server/factory/stack-components-certs');
+const TlsConnection = require('./tls-connection');
+const Tls = require('tls');
+
+
+class TlsConnectionClient extends TlsConnection {
+  static TRANSPORT_PROPERTIES = new Set(['allowHalfOpen', 'noDelay', 'rejectUnauthorized', 'keepAlive', 'keepAliveInitialDelay']);
+  
+  constructor(srcAddress, dstAddress, transportProperties, connection) {
+    super(transportProperties, 'client', connection);
+    this.srcAddress = srcAddress;
+    this.dstAddress = dstAddress;
+    this.err = null;
+  }
+  
+  connect(done) {
+    let timeoutId = -1;
+    this.cbError = (err) => {
+      this.cbError = null;
+      if(-1 !== timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.err = err;
+    };
+    const options = {
+      host: this.dstAddress.host,
+      port: this.dstAddress.port,
+      localAddress: this.srcAddress.host,
+      localPort: this.srcAddress.port,
+      checkServerIdentity: (host, cert) => {
+        //ddb.writeln('checkServerIdentity', host, cert);
+      },
+      ca: StackComponentsCerts.ca
+    };
+    this.setTransportProperties(options, TlsConnectionClient.TRANSPORT_PROPERTIES);
+    const socket = Tls.connect(options, () => {
+      if(this.cbError) {
+        this.cbError();
+        if(done) {
+          const doDone = done;
+          done = null;
+          doDone(this.err);
+        }
+      }
+    });
+    if(!this.connection.actor.debug) {
+      timeoutId = setTimeout(() => {
+        if(this.cbError) {
+          this.cbError(new Error('Timeout'));
+          socket.destroy();
+        }
+      }, 10);
+    }
+    socket.on('error', (err) => {
+      if(this.cbError) {
+        this.cbError(err);
+      }
+    });
+    socket.on('close', () => {
+      if(this.err) {
+        if(done) {
+          const doDone = done;
+          done = null;
+          doDone(this.err);
+        }
+      }
+    });
+    this.attach(socket);
+  }
+}
+
+
+module.exports = TlsConnectionClient;