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

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

@@ -0,0 +1,51 @@
+
+'use strict';
+
+const McConnectionShared = require('./mc-connection-shared');
+
+
+class McConnectionClientShared extends McConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+  
+  addMembership(host, interfaceHost) {
+    return this.networkConnection.addMembership(host, interfaceHost);
+  }
+  
+  connect(done) {
+    this.networkConnection.connect(done);
+  }
+  
+  closed() {
+    return this.networkConnection.closed();
+  }
+  
+  close(done) {
+    if(0 === this.unref()) {
+      this.networkConnection.close(done);
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  sendMessage(msg) {
+    this.networkConnection.sendMessage(msg);
+  }
+  
+  getRemoteAddress() {
+    return this.networkConnection.getRemoteAddress();
+  }
+  
+  getRemotePort() {
+    return this.networkConnection.getRemotePort();
+  }
+  
+  getRemoteFamily() {
+    return this.networkConnection.getRemoteFamily();
+  }
+}
+
+
+module.exports = McConnectionClientShared;

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

@@ -0,0 +1,117 @@
+
+'use strict';
+
+const McConnection = require('./mc-connection');
+const Dgram = require('dgram');
+
+
+class McConnectionClient extends McConnection {
+  constructor(srcAddress, dstAddress, transportProperties, connection) {
+    super(transportProperties, 'client', connection);
+    this.srcAddress = srcAddress;
+    if(0 === this.srcAddress.port) {
+      throw Error('Can not bind multicast client port to 0.');
+    }
+    this.dstAddress = dstAddress;
+    this.isOpen = false;
+  }
+  
+  addMembership(host, interfaceHost) {
+    try {
+      this.socket.setMulticastTTL(40);
+      this.socket.addSourceSpecificMembership(this.srcAddress.host, host, interfaceHost);
+      return null;
+    }
+    catch(err) {
+      return err;
+    }
+  }
+  
+  connect(done) {
+    let bindDone = done;
+    if('IPv4' === this.dstAddress.family) {
+      this.socket = Dgram.createSocket({type: 'udp4', reuseAddr: true});
+    }
+    else if('IPv6' === this.dstAddress.family) {
+      this.socket = Dgram.createSocket({type: 'udp6', reuseAddr: true});
+    }
+    else {
+      process.nextTick((done) => {
+        done(new Error(`No accepted IP family; '${dstAddress.family}'`));
+      }, done);
+      return;
+    }
+    this.socket.on('error', (err) => {
+      if(bindDone) {
+        bindDone(err);
+      }
+    });
+    this.socket.bind({
+      port: this.srcAddress.port,
+      address: this.srcAddress.host,
+      reuseAddr: true
+    }, (err) => {
+      bindDone = null;
+      if(err) {
+        return done(err);
+      }
+      const error = this.addMembership(this.dstAddress.host, this.srcAddress.host);
+      if(error) {
+        return done(error);
+      }
+      this.isOpen = true;
+      done();
+    });
+    this.socket.on('message', (buffer, rinfo) => {
+      /*if(rinfo.host != this.dstAddress.host || rinfo.port != this.dstAddress.port) {
+        // TODO: addlog error here.
+        return;
+      }*/
+      this.onBuffer(buffer);
+    });
+    this.socket.on('close', () => {
+      this.isOpen = false;
+    });
+  }
+  
+  closed() {
+    return !this.isOpen;
+  }
+  
+  close(done) {
+    if(null !== this.socket) {
+      this.socket.close((err) => {
+        // TODO: Log
+        done(err);
+      });
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  sendMessage(msg) {
+    this.socket.send(msg);
+  }
+  
+  getRemoteAddress() {
+    if(null !== this.socket) {
+      return this.dstAddress.host;
+    }
+  }
+  
+  getRemotePort() {
+   if(null !== this.socket) {
+      return this.dstAddress.port;
+    }
+  }
+  
+  getRemoteFamily() {
+    if(null !== this.socket) {
+      return this.dstAddress.family;;
+    }
+  }
+}
+
+
+module.exports = McConnectionClient;

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

@@ -0,0 +1,51 @@
+
+'use strict';
+
+const McConnectionShared = require('./mc-connection-shared');
+
+
+class McConnectionServerShared extends McConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+  
+  setRemoteAddress(remoteAddress) {
+    this.networkConnection.setRemoteAddress(remoteAddress);
+  }
+  
+  attach(socket) {
+    this.networkConnection.attach(socket);
+  }
+  
+  closed() {
+    return this.networkConnection.closed();
+  }
+  
+  close(done) {
+    if(0 === this.unref()) {
+      this.networkConnection.close(done);
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  sendMessage(msg) {
+    this.networkConnection.sendMessage(msg);
+  }
+  
+  getRemoteAddress() {
+    return this.networkConnection.getRemoteAddress();
+  }
+  
+  getRemotePort() {
+    return this.networkConnection.getRemotePort();
+  }
+  
+  getRemoteFamily() {
+    return this.networkConnection.getRemoteFamily();
+  }
+}
+
+
+module.exports = McConnectionServerShared;

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

@@ -0,0 +1,58 @@
+
+'use strict';
+
+const McConnection = require('./mc-connection');
+const Dgram = require('dgram');
+
+
+class McConnectionServer extends McConnection {
+  constructor(srvAddress, dstAddress, mcServer, transportProperties, connection) {
+    super(transportProperties, 'server', connection);
+    this.srvAddress = srvAddress;
+    this.dstAddress = dstAddress;
+    this.mcServer = mcServer;
+    this.remoteAddress = null;
+  }
+  
+  setRemoteAddress(remoteAddress) {
+    this.remoteAddress = remoteAddress;
+  }
+  
+  attach(socket) {
+    this.socket = socket;
+  }
+  
+  closed() {
+    return this.mcServer.closed();
+  }
+  
+  close(done) {
+    this.mcServer.closeConnection(this.remoteAddress);
+    process.nextTick(done);
+  }
+  
+  sendMessage(msg) {
+    this.mcServer.send(msg, this.remoteAddress);
+  }
+  
+  getRemoteAddress() {
+    if(null !== this.remoteAddress) {
+      return this.remoteAddress.host;
+    }
+  }
+  
+  getRemotePort() {
+   if(null !== this.remoteAddress) {
+      return this.remoteAddress.port;
+    }
+  }
+  
+  getRemoteFamily() {
+    if(null !== this.remoteAddress) {
+      return this.remoteAddress.family;
+    }
+  }
+}
+
+
+module.exports = McConnectionServer;

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

@@ -0,0 +1,26 @@
+
+'use strict';
+
+const NetworkConnectionShared = require('../network-connection-shared');
+
+
+class McConnectionShared extends NetworkConnectionShared {
+  constructor(networkConnection, connectionName) {
+    super(networkConnection, connectionName);
+  }
+  
+  getLocalAddress() {
+    return this.networkConnection.getLocalAddress();
+  }
+  
+  getLocalPort() {
+    return this.networkConnection.getLocalPort();
+  }
+  
+  getLocalFamily() {
+    return this.networkConnection.getLocalFamily();
+  }
+}
+
+
+module.exports = McConnectionShared;

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

@@ -0,0 +1,33 @@
+
+'use strict';
+
+const NetworkConnection = require('../network-connection');
+
+
+class McConnection extends NetworkConnection {
+  constructor(transportProperties, type, connection) {
+    super(transportProperties, 'mc', type, connection);
+    this.socket = null;
+  }
+  
+  getLocalAddress() {
+    if(null !== this.socket) {
+      return this.socket.address().address;
+    }
+  }
+  
+  getLocalPort() {
+    if(null !== this.socket) {
+      return this.socket.address().port;
+    }
+  }
+  
+  getLocalFamily() {
+    if(null !== this.socket) {
+      return this.socket.address().family;
+    }
+  }
+}
+
+
+module.exports = McConnection;

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

@@ -0,0 +1,90 @@
+
+'use strict';
+
+const NetworkServer = require('../network-server');
+const Dgram = require('dgram');
+
+
+class McServer extends NetworkServer {
+  constructor(connection, cbConnection) {
+    super(connection, cbConnection, 'mc');
+    this.logicConnections = new Map();
+    this.isOpen = false;
+  }
+  
+  init(srvAddress, dstAddress, transportProperties, cbListen) {
+    this.srvAddress = srvAddress;
+    this.dstAddress = dstAddress;
+    if(!this.dstAddress) {
+      process.nextTick((cbListen) => {
+        cbListen(new Error('MC - A multicast server must have an dstAddress'));
+      }, cbListen);
+      return;
+    }
+    if('IPv4' === this.dstAddress.family) {
+      this.serverSocket = Dgram.createSocket({type: 'udp4', reuseAddr: true});
+    }
+    else if('IPv6' === this.dstAddress.family) {
+      this.serverSocket = Dgram.createSocket({type: 'udp6', reuseAddr: true});
+    }
+    else {
+      process.nextTick((self, cbListen) => {
+        cbListen(new Error(`No accepted IP family; '${self.srvAddress.family}'`));
+      }, this, cbListen);
+      return;
+    }
+    this.serverSocket.on('error', (err) => { // ??? Isn't this part of 'connection.attach'.
+      cbListen(err);
+    });
+    try {
+      this.serverSocket.bind({
+        port: this.srvAddress.port,
+        address: this.srvAddress.host,
+        exclusive: false
+      }, (err) => {
+        try {
+          this.serverSocket.setMulticastInterface(this.srvAddress.host);
+          this.serverSocket.setMulticastTTL(4);
+        }
+        catch(err) {
+          return cbListen(err);
+        }
+        this.isOpen = true;
+        cbListen();
+        process.nextTick((self) => {
+          const key = `${self.dstAddress.host}:${self.dstAddress.port}`;
+          const connection = self.cbConnection(self.serverSocket, {
+            name: '',
+            port: self.dstAddress.port,
+            host: self.dstAddress.host,
+            family: self.srvAddress.family,
+            type: 'client'
+          });
+          self.logicConnections.set(key, connection);
+        }, this);
+      });
+    }
+    catch(err) {
+      console.log('BIND:', err);
+    }
+    this.serverSocket.on('close', () => {
+      this.isOpen = false;
+    });
+  }
+  
+  closed() {
+    return !this.isOpen;
+  }
+  
+  closeConnection(address) {
+    const key = `${address.address}:${address.port}`;
+    this.logicConnections.delete(key);
+  }
+  
+  send(msg, address) {
+    this.serverSocket.send(msg, address.port, address.host);
+  }
+}
+
+
+module.exports = McServer;

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

@@ -0,0 +1,177 @@
+
+'use strict';
+
+const PendingInner = require('../pending/pending-inner');
+
+
+class NetworkConnectionShared extends PendingInner {
+  constructor(networkConnection, connectionName) {
+    super(connectionName);
+    this.networkConnection = networkConnection;
+    this.connectionName = connectionName;
+    this.instances = 0;
+    this.sending = false;
+    this.sendLockQueue = [];
+    this.receiving = false;
+    this.receiveLockQueue = [];
+    this.receiveSelectorsQueue = new Set();
+    this.messagesQueue = new Set();
+  }
+  
+  closed() {
+    return this.networkConnection.closed();
+  }
+  
+  halfClosed() {
+    return this.networkConnection.closed();
+  }
+  
+  sendLock(cbExecute) {
+    if(!this.sending) {
+      this.sending = true;
+      cbExecute();
+    }
+    else {
+      this.sendLockQueue.push({
+        cbExecute
+      });
+    }
+  }
+  
+  sendUnlock() {
+    if(0 === this.sendLockQueue.length) {
+      this.sending = false;
+    }
+    else {
+      process.nextTick((self) => {
+        const sendLockData = self.sendLockQueue.shift();
+        sendLockData.cbExecute();
+      }, this);
+    }
+  }
+  
+  send(msg, done) {
+    this.networkConnection.send(msg, () => {
+      done();
+    });
+  }
+  
+  receiveLine(done) {
+    this.networkConnection.receiveLine(done);
+  }
+  
+  receiveSize(size, done) {
+    this.networkConnection.receiveSize(size, done);
+  }
+  
+  receiveLock(cbExecute) {
+    if(!this.receiving) {
+      this.receiving = true;
+      cbExecute();
+    }
+    else {
+      this.receiveLockQueue.push({
+        cbExecute: cbExecute
+      });
+    }
+  }
+  
+  receiveUnlock() {
+    if(0 === this.receiveLockQueue.length) {
+      this.receiving = false;
+    }
+    else {
+      process.nextTick((self) => {
+        const receivingData = self.receiveLockQueue.shift();
+        receivingData.cbExecute();
+      }, this);
+    }
+  }
+  
+  addReceiveSelector(sharedMessageSelector, cbMessage) {
+    this.receiveSelectorsQueue.add({
+      sharedMessageSelector: sharedMessageSelector,
+      cbMessage: cbMessage
+    });
+  }
+  
+  addReceivedMessage(msg) {
+    this.messagesQueue.add(msg);
+    this.messagesQueue.forEach((msg) => {
+      this.receiveSelectorsQueue.forEach((receiveSelector) => {
+        if(!receiveSelector.sharedMessageSelector || receiveSelector.sharedMessageSelector._select(msg)) {
+          const selectedMsg = msg;
+          const selectedReceiveSelector = receiveSelector;
+          process.nextTick((self, selectedMsg, selectedReceiveSelector) => {
+            self.messagesQueue.delete(selectedMsg);
+            self.receiveSelectorsQueue.delete(selectedReceiveSelector);
+            selectedReceiveSelector.cbMessage(selectedMsg);
+          }, this, selectedMsg, selectedReceiveSelector);
+        }
+      });
+    });
+  }
+  
+  cancel() {
+    this.networkConnection.cancel();
+  }
+  
+  onBuffer(buffer) {
+    this.networkConnection.onBuffer(buffer);
+  }
+  
+  ref() {
+    return ++this.instances;
+  }
+  
+  unref() {
+    return --this.instances;
+  }
+  
+  getSrvAddress() {
+    return this.networkConnection.srvAddress;
+  }
+  
+  getDstAddress() {
+    return this.networkConnection.dstAddress;
+  }
+  
+  logEngine(message, group, guid, depth=3) {
+    this.networkConnection.connection.logEngine(message, group, guid, depth);
+  }
+  
+  logDebug(message, group, guid, depth=3) {
+    this.networkConnection.connection.logDebug(message, group, guid, depth);
+  }
+    
+  logError(errOrMsg, guid, depth=3) {
+    this.networkConnection.connection.logError(errOrMsg, guid, depth);
+  }
+  
+  isLogIp() {
+    return this.networkConnection.connection.isLogIp();
+  }
+  
+  logIp(log, group, guid, depth=3) {
+    this.networkConnection.connection.logIp(log, group, guid, depth);
+  }
+  
+  isLogGui(group) {
+    return this.networkConnection.connection.isLogGui(group);
+  }
+  
+  logGui(log, group, guid, depth=3) {
+    this.networkConnection.connection.logGui(log, group, guid, depth);
+  }
+  
+  logWarning(message, group, guid, depth=3) {
+    this.networkConnection.connection.logWarning(message, group, guid, depth);
+  }
+  
+  logTestData(message, group, guid, depth=3) {
+    this.networkConnection.connection.logTestData(message, group, guid, depth);
+  }
+}
+
+
+module.exports = NetworkConnectionShared;