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

package/project/server/engine/actor/actor-mixins/shared-data-mixin.js

@@ -0,0 +1,109 @@
+
+'use strict';
+
+const CancelObject = require('../../../stack/stacks/cancel-object');
+
+
+const SharedDataMixin = {
+  *setSharedData(key, value) {
+    const sharedDataobject = this.tcData.sharedRuntimeData.set(key, value);
+    this._handlePendings(key, sharedDataobject);
+    const cancelObject = new CancelObject();
+    const pendingId = this.setPending(() => {
+      cancelObject.set();
+    });
+    process.nextTick((self, cancelObject, pendingId, value) => {
+      if(!cancelObject.cancel) {
+        self.handlePendingIdSuccess(pendingId, value);
+      }
+    }, this, cancelObject, pendingId, value);
+    return yield;
+  },
+  setSharedDataSync(key, value) {
+    const sharedDataobject = this.tcData.sharedRuntimeData.set(key, value);
+    this._handlePendings(key, sharedDataobject);
+    return value;
+  },
+  getSharedData(key, defaultValue) {
+    const sharedData = this.tcData.sharedRuntimeData.get(key);
+    if(undefined !== sharedData) {
+      return sharedData.value;
+    }
+    else {
+      return defaultValue;
+    }
+  },
+  *waitForSharedData(key, expectedValue) {
+    const value = this.tcData.sharedRuntimeData.wait(key, this, expectedValue, () => {
+      const cancelObject = new CancelObject();
+      const pendingId = this.setPending(() => {
+        cancelObject.set();
+      });
+      return {
+        id: pendingId,
+        cancelObject: cancelObject
+      };
+    });
+    if(null !== value) {
+      return value;
+    }
+    else {
+      return yield;
+    }
+  },
+  *setSharedDataActor(key, value, name, index) {
+    if(undefined === name) {
+      return yield* this.setSharedData(`${this.name}[${this.instanceIndex}].${key}`, value);
+    }
+    else {
+      return yield* this.setSharedData(`${name}[${index}].${key}`, value);
+    }
+  },
+  setSharedDataActorSync(key, value, name, index) {
+    if(undefined === name) {
+      return this.setSharedDataSync(`${this.name}[${this.instanceIndex}].${key}`, value);
+    }
+    else {
+      return this.setSharedDataSync(`${name}[${index}].${key}`, value);
+    }
+  },
+  getSharedDataActor(key, name, index) {
+    if(undefined === name) {
+      return this.getSharedData(`${this.name}[${this.instanceIndex}].${key}`);
+    }
+    else {
+      return this.getSharedData(`${name}[${index}].${key}`);
+    }
+  },
+  *waitForSharedDataActor(key, expectedValue) {
+    if(undefined === name) {
+      yield* this.waitForSharedData(`${this.name}[${this.instanceIndex}].${key}`, expectedValue);
+    }
+    else {
+      yield* this.waitForSharedData(`${name}[${index}].${key}`, expectedValue);
+    }
+  },
+  _handlePendings(key, sharedDataobject) {
+    let found = true;
+    while(found) {
+      const index = sharedDataobject.pendings.findIndex((pending) => {
+        return undefined === pending.expectedValue ? true : sharedDataobject.value === pending.expectedValue;
+      });
+      if(-1 !== index) {
+        const sharedPendingData = sharedDataobject.pendings[index];
+        sharedDataobject.pendings.splice(index, 1);
+        process.nextTick((sharedPendingData, sharedDataobject) => {
+          if(!sharedPendingData.cancelObject.cancel) {
+            sharedPendingData.actor.handlePendingIdSuccess(sharedPendingData.pendingId, sharedDataobject.value);
+          }
+        }, sharedPendingData, sharedDataobject);
+      }
+      else {
+        return;
+      }
+    }
+  }
+};
+
+
+module.exports = SharedDataMixin;

package/project/server/engine/actor/actor-mixins/shared-execution-data-mixin.js

@@ -0,0 +1,57 @@
+
+'use strict';
+
+const CancelObject = require('../../../stack/stacks/cancel-object');
+
+
+const SharedExecutionDataMixin = {
+  *setSharedExecutionData(key, value) {
+    const sharedDataobject = this.executionContext.sharedRuntimeData.set(key, value);
+    this._handlePendings(key, sharedDataobject);
+    const cancelObject = new CancelObject();
+    const pendingId = this.setPending(() => {
+      cancelObject.set();
+    });
+    process.nextTick((self, cancelObject, pendingId, value) => {
+      if(!cancelObject.cancel) {
+        self.handlePendingIdSuccess(pendingId, value);
+      }
+    }, this, cancelObject, pendingId, value);
+    return yield;
+  },
+  setSharedExecutionDataSync(key, value) {
+    const sharedDataobject = this.executionContext.sharedRuntimeData.set(key, value);
+    this._handlePendings(key, sharedDataobject);
+    return value;
+  },
+  getSharedExecutionData(key, defaultValue) {
+    const sharedData = this.executionContext.sharedRuntimeData.get(key);
+    if(undefined !== sharedData) {
+      return sharedData.value;
+    }
+    else {
+      return defaultValue;
+    }
+  },
+  *waitForSharedExecutionData(key, expectedValue) {
+    const value = this.executionContext.sharedRuntimeData.wait(key, this, expectedValue, () => {
+      const cancelObject = new CancelObject();
+      const pendingId = this.setPending(() => {
+        cancelObject.set();
+      });
+      return {
+        id: pendingId,
+        cancelObject: cancelObject
+      };
+    });
+    if(null !== value) {
+      return value;
+    }
+    else {
+      return yield;
+    }
+  }
+};
+
+
+module.exports = SharedExecutionDataMixin;

package/project/server/engine/actor/actor-mixins/stack-mixin-client.js

@@ -0,0 +1,157 @@
+
+'use strict';
+
+const Address = require('../../../address/address');
+const MessageSelector = require('../../../stack/stacks/message-selector');
+const NetworkType = require('../../../stack/network/network-type');
+const ActorPhaseConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-phase-const');
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+const StackMixinClient = {
+  createConnection(stackName, connectionInstanceData, options) {
+    const optionsConnection = {
+      connectionOptions: null,
+      transportLayer: {
+        transportType: null,
+        transportProperties: null
+      },
+      messageSelector: null,
+      connectionWorker: null,
+      stackContentCache: this.executionContext.stackContentCache
+    };
+    let dstIndex = 0;
+    let srcIndex = 0;
+    let reuse = false;
+    this.getTransportLayerData(optionsConnection, options);
+    if(undefined !== options) {
+      if(undefined != options.dstIndex) {
+        dstIndex = options.dstIndex;
+      }
+      if(undefined !== options.srcIndex) {
+        srcIndex = options.srcIndex;
+      }
+      if(undefined !== options.reuse) {
+        reuse = options.reuse;
+      }
+      else {
+        reuse = this.getTestDataBoolean(`${stackName}-reuse`, reuse);
+      }
+      if(undefined !== options.messageSelector) {
+        if('function' === typeof options.messageSelector) {
+          optionsConnection.messageSelector = new MessageSelector();
+          optionsConnection.messageSelector.onSelect = options.messageSelector;
+        }
+        else if('object' === typeof options.messageSelector) {
+          optionsConnection.messageSelector = options.messageSelector;
+        }
+      }
+      if(undefined !== options.connectionWorker) {
+        optionsConnection.connectionWorker = options.connectionWorker;
+      }
+      if(undefined !== options.connectionOptions) {
+        optionsConnection.connectionOptions = options.connectionOptions;
+      }
+    }
+    else {
+      reuse = this.getTestDataBoolean(`${stackName}-reuse`, reuse);
+    }
+    const srcAddress = this.getSrcAddress(srcIndex, optionsConnection);
+    const srcDstAddress = this.getSrcDstAddress(dstIndex, optionsConnection);
+    this.executionContext.clientManager.getConnection(stackName, connectionInstanceData, this, reuse, srcAddress, srcDstAddress, optionsConnection);
+  },
+  switchProtocol(stackName, currentConnection, upgradedConnection) {
+    return this.executionContext.clientManager.switchProtocol(stackName, currentConnection, upgradedConnection, this);
+  },
+  resolveSrcAddress(srcIndex) {
+    const addressData = this.src[srcIndex];
+    if(Address.IS_GENERATED === addressData.type) {
+      return this._getStackAddress((addressName) => {
+        const srcAddress = this.executionContext.addresses.getSrc(addressName);
+        if(srcAddress) {
+          return srcAddress;
+        }
+        else if('DEFAULT_SRC' === addressName) {
+          return new Address(addressName, null, null, null, 'client', 'default-page', null);
+          }
+        else {
+          return null;
+        }
+      }, addressData.value);
+    }
+    else {
+      return addressData.value;
+    }
+  },
+  setSrcAddress(srcIndex, address) {
+    this.srcResolved[srcIndex] = address;
+  },
+  setSrcAddressPost(srcIndex, address) {
+    this.srcResolvedPost[srcIndex] = address;
+  },
+  getSrcAddress(srcIndex=0, options=null) {
+    if(srcIndex < this.src.length) {
+      if(ActorTypeConst.COND === this.typeId && ActorPhaseConst.POST === this.currentPhaseId) {
+        return this.srcResolvedPost[srcIndex];
+      }
+      else {
+        return this.srcResolved[srcIndex];
+      }
+    }
+    else if(srcIndex >= this.src.length) {
+      const transportType = options ? options.transportLayer.transportType : NetworkType.TCP;
+      const srcAddress = this.executionContext.addressManager.getDefaultSrc(this.uniqueTcId, transportType, this.executionContext.clientManager.actors.get(this));
+      this.logWarning(() => `There is no client src address name. Default client src address will be used. ${srcAddress.host}:${srcAddress.port} - name: ${srcAddress.addressName}`, 'core', '26e8e0eb-aee4-49ec-a099-cc80f02631de', 1);
+      return srcAddress;
+    }
+  },
+  resolveSrcDstAddress(dstIndex) {
+    const addressData = this.srcDst[dstIndex];
+    if(Address.IS_GENERATED === addressData.type) {
+      return this._getStackAddress((addressName) => {
+        if(!Array.isArray(addressName)) {
+          return this.executionContext.addresses.getDst(addressName);
+        }
+        else {
+          const addresses = [];
+          for(let i = 0; i < addressName.length; ++i) {
+            const address = this.executionContext.addresses.getDst(addressName[i]);
+            if(undefined === address) {
+              return;
+            }
+            addresses.push(address);
+          }
+          return addresses;
+        }
+      }, addressData.value);
+    }
+    else {
+      return addressData.value;
+    }
+  },
+  setSrcDstAddress(dstIndex, address) {
+    this.srcDstResolved[dstIndex] = address;
+  },  
+  setSrcDstAddressPost(dstIndex, address) {
+    this.srcDstResolvedPost[dstIndex] = address;
+  },
+  getSrcDstAddress(dstIndex=0, options=null) {
+    if(dstIndex < this.srcDst.length) {
+      if(ActorTypeConst.COND === this.typeId && ActorPhaseConst.POST === this.currentPhaseId) {
+        return this.srcDstResolvedPost[dstIndex];
+      }
+      else {
+        return this.srcDstResolved[dstIndex];
+      }
+    }
+    else if(dstIndex >= this.srcDst.length) {
+      const transportType = options ? options.transportLayer.transportType : NetworkType.TCP;
+      const dstAddress = this.executionContext.addressManager.getDefaultDst(this.uniqueTcId, transportType, this.executionContext.clientManager.actors.get(this));
+      this.logWarning(() => `There is no client dst address name. Default client dst address will be used. ${dstAddress.host}:${dstAddress.port} - name: ${dstAddress.addressName}`, 'core', 'e72cf3a4-465f-4acc-a845-09e8d2690451', 1);
+      return dstAddress;
+    }
+  }
+};
+
+
+module.exports = StackMixinClient;

package/project/server/engine/actor/actor-mixins/stack-mixin-server.js

@@ -0,0 +1,123 @@
+
+'use strict';
+
+const Address = require('../../../address/address');
+const MessageSelector = require('../../../stack/stacks/message-selector');
+const NetworkType = require('../../../stack/network/network-type');
+
+
+const StackMixinServer = {
+  createServer(stackName, connectionInstanceData, options) {
+    const optionsConnection = {
+      connectionOptions: null,
+      transportLayer: {
+        transportType: null,
+        transportProperties: null
+      },
+      messageSelector: null,
+      connectionWorker: null,
+      stackContentCache: this.executionContext.stackContentCache
+    };
+    let srvIndex = 0;
+    let dstIndex = 0;
+    let srvOptionsAddress = undefined;
+    let dstOptionsAddress = undefined;
+    this.getTransportLayerData(optionsConnection, options);
+    if(undefined !== options) {
+      if(undefined !== options.srvIndex) {
+        srvIndex = options.srvIndex;
+      }
+      if(undefined !== options.dstIndex) {
+        dstIndex = options.dstIndex;
+      }
+      if(undefined !== options.messageSelector) {
+        if('function' === typeof options.messageSelector) {
+          optionsConnection.messageSelector = new MessageSelector();
+          optionsConnection.messageSelector.onSelect = options.messageSelector;
+        }
+        else if('object' === typeof options.messageSelector) {
+          if(!options.messageSelector.interceptor || (options.messageSelector.interceptor && 'inter' === this.type)) {
+            optionsConnection.messageSelector = options.messageSelector;
+          }
+          else {
+            throw new Error('MessageSelector with interceptor == true can only be used by ActorInterception.');
+          }
+        }
+      }
+      if(undefined !== options.connectionOptions) {
+        optionsConnection.connectionOptions = options.connectionOptions;
+      }
+      if(undefined !== options.port && undefined !== options.host && undefined !== options.family) {
+        srvOptionsAddress = new Address('anonymous-(options)', options.host, options.family, options.port, 'server');
+      }
+    }
+    const srvAddress = undefined === srvOptionsAddress ? this.getSrvAddress(srvIndex, optionsConnection) : srvOptionsAddress;
+    const srvDstAddress = this.getSrvDstAddress(dstIndex, optionsConnection);
+    this.executionContext.serverManager.getServer(stackName, connectionInstanceData, this, srvAddress, srvDstAddress, optionsConnection);
+  },
+  switchProtocol(stackName, currentConnection, upgradedConnection) {
+    return this.executionContext.serverManager.switchProtocol(stackName, currentConnection, upgradedConnection, this);
+  },
+  resolveSrvAddress(srvIndex) {
+    if(srvIndex < this.srv.length) {
+      const addressData = this.srv[srvIndex];
+      if(Address.IS_GENERATED === addressData.type) {
+        return this._getStackAddress((addressName) => {
+          return this.executionContext.addresses.getSrv(addressName);
+        }, addressData.value);
+      }
+      else {
+        return addressData.value;
+      }
+    }
+  },
+  setSrvAddress(srvIndex, address) {
+    this.srvResolved[srvIndex] = address;
+  },
+  getSrvAddress(srvIndex=0, options=null) {
+    if(srvIndex < this.srv.length) {
+      return this.srvResolved[srvIndex];
+    }
+    else if(srvIndex >= this.srv.length) {
+      const transportType = options ? options.transportLayer.transportType : NetworkType.TCP;
+      const srvAddress = this.executionContext.addressManager.getDefaultSrv(this.uniqueTcId, transportType, this.executionContext.serverManager.actors.get(this));
+      this.logWarning(() => `There is no server srv address name. Default server srv address will be used. ${srvAddress.host}:${srvAddress.port} - name: ${srvAddress.addressName}`, 'core', 'cfbf1f3e-9ae5-48a1-bbf3-203500e5fadd', 1);
+      return srvAddress;
+    }
+  },
+  resolveSrvDstAddress(dstIndex) {
+    if(dstIndex < this.srvDst.length) {
+      const addressData = this.srvDst[dstIndex];
+      if(Address.IS_GENERATED === addressData.type) {
+        return this._getStackAddress((addressName) => {
+          return this.executionContext.addresses.getDst(addressName);
+        }, addressData.value);
+      }
+      else {
+        return addressData.value;
+      }
+    }
+  },
+  setSrvDstAddress(dstIndex, address) {
+    this.srvDstResolved[dstIndex] = address;
+  },
+  getSrvDstAddress(dstIndex=0, options=null) {
+    if(dstIndex < this.srvDst.length) {
+      return this.srvDstResolved[dstIndex];
+    }
+    else if(dstIndex >= this.srvDst.length) {
+      const transportType = options ? options.transportLayer.transportType : NetworkType.MC;
+      if(NetworkType.MC === transportType) {
+        const dstAddress = this.executionContext.addressManager.getDefaultDst(this.uniqueTcId, NetworkType.MC, this.executionContext.serverManager.actors.get(this));
+        this.logWarning(() => `There is no server dst address name. Default server dst address will be used. ${dstAddress.host}:${dstAddress.port} - name: ${dstAddress.addressName}`, 'core', 'f607cdd9-4182-4d32-9347-e29222685b63', 1);
+        return dstAddress;
+      }
+      else {
+        return null;
+      }
+    }    
+  }
+};
+
+
+module.exports = StackMixinServer;

package/project/server/engine/actor/actor-mixins/stack-mixin.js

@@ -0,0 +1,128 @@
+
+'use strict';
+
+const ConnectionInstance = require('../../../stack/stacks/connection-instance');
+const NetworkType = require('../../../stack/network/network-type');
+
+
+const StackMixin = {
+  initStackMixin() {
+    this._connectedConnections = new Set();
+    this._closePendingConnections = new Set();
+    this._closePendingsCb = null;
+    this.addressLocks = new Set();
+  },
+  lockAddress(address, cb) {
+    //console.log('LOCK;', `${address.addressName} - ${address.host}:${address.port}`, this.logName);
+    this.executionContext.addressManager.lock(this.uniqueTcId, address, () => {
+      this.addressLocks.add(address);
+      cb();
+    });
+  },
+  unlockAddress(address) {
+    if(address) {
+      //console.log('UNLOCK;', `${address.addressName} - ${address.host}:${address.port}`, this.logName);
+      if(this.addressLocks.has(address)) {
+        this.addressLocks.delete(address);
+        this.executionContext.addressManager.unlock(this.uniqueTcId, address);
+      }
+      else {
+        this.executionContext.addressManager.releaseDefaultAddressUnicast(this.uniqueTcId, address)
+      }
+    }
+  },
+  _unlockAddresses(showWarning) {
+    if(0 !== this.addressLocks.size) {
+      if(showWarning) {
+        this.logWarning(`Actor ${this.logName} has address locks.`, 'core', 'e13d2b3c-2340-4ffa-a4c7-268f2b7a79ac');
+      }
+      this.addressLocks.forEach((addressData, address) => {
+        //console.log('*** UNLOCK;', `${address.host}:${address.port}`, this.logName);
+        this.executionContext.addressManager.unlock(this.uniqueTcId, address);
+      });
+      this.addressLocks.clear();
+    }
+  },
+  addConnectedConnection(connection) {
+    this._connectedConnections.add(connection);
+  },
+  removeConnectedConnection(connection) {
+    this._connectedConnections.delete(connection);
+  },
+  hasConnectedConnection() {
+    return 0 !== this._connectedConnections.size;
+  },
+  addClosePendingConnection(connection) {
+    this._closePendingConnections.add(connection);
+  },
+  removeClosePendingConnection(connection) {
+    if(this._closePendingConnections.delete(connection)) {
+      if(this._closePendingsCb) {
+        if(0 === this._closePendingConnections.size) {
+          const cb = this._closePendingsCb;
+          this._closePendingsCb = null;
+          this.process.nextTick(cb);
+        }
+      }
+    }
+  },
+  _awaitClosePendingConnections(cb) {
+    if(0 === this._closePendingConnections.size) {
+      this.process.nextTick(cb);
+    }
+    else {
+      this._closePendingsCb = cb;
+    }
+  },
+  awakeYield() {
+    const pendingId = this.setPending(null);
+    this.pendingSuccess(pendingId, null);    
+  },
+  create() {
+    return new ConnectionInstance(this.awakeYield.bind(this));
+  },
+  *closeConnection(connection) {
+    yield connection.close(false);
+  },
+  _getStackAddress(cbGetAddresses, addressName) {
+    const srvAddress = cbGetAddresses(addressName);
+    if(!srvAddress) {
+      if('' === addressName) {
+        throw new Error(`There are no default address name.`);
+      }
+      else {
+        throw new Error(`There are no address with address name '${addressName}'. Have you forgot to stage or define the address?`);
+      }
+    }
+    return srvAddress;
+  },
+  getTransportLayerData(optionsConnection, options) {
+    const transportLayer = optionsConnection.transportLayer;
+    if(options) {
+      if(options.networkType) {
+        transportLayer.transportType = options.networkType;
+      }
+      if(options.transportProperties) {
+        transportLayer.transportProperties = new Map(options.transportProperties);
+      }
+    }
+    if(!transportLayer.transportType) {
+      transportLayer.transportType = this.getTestDataNumber('transport-type', 'default', {
+        default: NetworkType.DEFAULT,
+        tcp: NetworkType.TCP,
+        udp: NetworkType.UDP,
+        mc: NetworkType.MC,
+        tls: NetworkType.TLS
+      });
+    }
+    if(!transportLayer.transportProperties) {
+      const transportProperties = this.getTestDataArrayStrings('transport-properties', []);
+      if(0 < transportProperties.length) {
+        transportLayer.transportProperties = new Map(transportProperties);
+      }
+    }
+  }
+};
+
+
+module.exports = StackMixin;