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

package/project/server/engine/actor/actor-terminating.js

@@ -0,0 +1,32 @@
+
+'use strict';
+
+const Actor = require('./actor');
+const StackMixinServer = require('./actor-mixins/stack-mixin-server');
+const StackMixin = require('./actor-mixins/stack-mixin');
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+class ActorTerminating extends Actor {
+  constructor(actorParts, expectInterrupt) {
+    super(ActorTypeConst.TERM, actorParts, expectInterrupt);
+    this.srvDst = [];
+    this.srv = [];
+    this.srvDstResolved = [];
+    this.srvResolved = [];
+    this.initStackMixin();
+  }
+  
+  init(uniqueTcId, actorData, instanceIndex, cbMessage, executionContext, tcData, config, slowAwaitTime, nodes, cb) {
+    if('' === actorData.execution) {
+      actorData.execution = 'parallel';
+    }
+    return super.init(uniqueTcId, actorData, instanceIndex, cbMessage, executionContext, tcData, config, slowAwaitTime, nodes, cb);
+  }
+}
+
+Object.assign(ActorTerminating.prototype, StackMixinServer);
+Object.assign(ActorTerminating.prototype, StackMixin);
+
+
+module.exports = ActorTerminating;

package/project/server/engine/actor/actor.js

@@ -0,0 +1,553 @@
+
+'use strict';
+
+const ActorState = require('../actor-state');
+const Address = require('../../address/address');
+const ActorResults = require('./actor-results');
+const ActorStateTimeout = require('./actor-state-timeout');
+const AsynchMixin = require('./actor-mixins/asynch-mixin');
+const ContentMixin = require('./actor-mixins/content-mixin');
+const LoggerMixin = require('./actor-mixins/logger-mixin');
+const SharedDataMixin = require('./actor-mixins/shared-data-mixin');
+const SharedExecutionDataMixin = require('./actor-mixins/shared-execution-data-mixin');
+const TimerMixin = require('./actor-mixins/timer-mixin');
+const TestDataMixin = require('./actor-mixins/test-data-mixin');
+const VerifyMixinBase = require('./actor-mixins/verify-mixin-base');
+const VerifyMixinMandatory = require('./actor-mixins/verify-mixin-mandatory');
+const VerifyMixinOptional = require('./actor-mixins/verify-mixin-optional');
+const VerifyMixinValue = require('./actor-mixins/verify-mixin-value');
+const ActorPending = require('./actor-pending');
+const MessageTestCaseDebugActorIndex = require('z-abs-funclayer-engine-server/server/communication/messages/messages-w-to-s/message-test-case-debug-actor-index');
+const ActorPhaseConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-phase-const');
+const ActorResultConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-result-const');
+const ActorStateConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-state-const');
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+class Actor {
+  static instanceId = 0;
+  
+  constructor(inheritedType, actorParts, expectInterrupt=false) { 
+    this.uniqueTcId = 0n;
+    this.inheritedType = inheritedType; 
+    this.expectInterrupt = expectInterrupt;
+    this.name = '';
+    this.index = -1;
+    this.orderIndex = -1;
+    this.columnIndex = -1;
+    this.logName = '';
+    this.logFileName = '';
+    this.instanceIndex = 0;
+    this.node = '';
+    this.dependentOnIndices = [];
+    this.type = '';
+    this.execution = '';
+    this.phaseId = -1;
+    this.currentPhaseId = -1;
+    this.typeId = 0;
+    this.cbMessage = null;
+    this.actorState = null;
+    this.actorResults = null;
+    this.cbActorStateDone = null;
+    this.executionContext = null;
+    this.tcData = null;
+    this.config = null;
+    this.slowAwaitTime = -1;
+    this.testDataActor = new Map();
+    this.verificationActor = new Map();
+    this.nodes = [];
+    this.currentGenerator = null;
+    this.done = false;
+    this.interrupted = false;
+    this.debug = false;
+    this.stateTimeout = null;
+    if(actorParts) {
+      let partIndex = 0;
+      if(Array.isArray(actorParts)) {
+        for(let i = 0; i < actorParts.length; ++i) {
+          const actorPart = new actorParts[i]().init(this, ++partIndex);
+          if(0 === actorPart.type) {
+            if(undefined === this.preActorParts) {
+              this.preActorParts = [actorPart];
+            }
+            else {
+              this.preActorParts.push(actorPart);
+            }
+          }
+          else {
+            if(undefined === this.postActorParts) {
+              this.postActorParts = [actorPart];
+            }
+            else {
+              this.postActorParts.push(actorPart);
+            }
+          }
+        }
+      }
+      else {
+        const actorPart = new actorParts().init(this, ++partIndex);
+        if(0 === actorPart.type) {
+          this.preActorParts = [actorPart];
+        }
+        else {
+          this.postActorParts = [actorPart];
+        }
+      }
+    }
+    this._next = null;
+    this._debugData = null;
+    this.process = process;
+    this.actorPending = new ActorPending(this);
+    this.initLoggerMixin();
+  }
+  
+  init(uniqueTcId, actorData, instanceIndex, cbMessage, executionContext, tcData, config, slowAwaitTime, nodes, cb) {
+    this.uniqueTcId = uniqueTcId;
+    this.name = actorData.name;
+    this.index = -1;
+    this.instanceIndex = instanceIndex;
+    this.node = actorData.node;
+    this.logName = `${this.name.substr(this.name.lastIndexOf('.') + 1)}[${this.instanceIndex}]`;
+    this.logFileName = `${actorData.name.replace(/\./g, '/')}.js`;
+    this.type = actorData.type;
+    this.typeId = ActorTypeConst.getId(actorData.type);
+    this.execution = actorData.execution;
+    this.cbMessage = cbMessage;
+    this.executionContext = executionContext;
+    this.tcData = tcData;
+    this.config = config;
+    this.slowAwaitTime = slowAwaitTime;
+    this.nodes = nodes;
+    this.actorState = new ActorState(this);
+    this.actorResults = new ActorResults();
+    if(undefined === actorData.phase || '' === actorData.phase) {
+      if(ActorTypeConst.COND === this.typeId) {
+        this.phaseId = ActorPhaseConst.PRE;
+      }
+      else {
+        this.phaseId = ActorPhaseConst.EXEC;
+      }
+    }
+    else {
+      this.phaseId = ActorPhaseConst.getId(actorData.phase);
+    }
+    this._setTestDataActor('actor-name', this.logName, 'The name of the Actor.');
+    this._setTestDatasActor(actorData.testData);
+    this._setVerificationsActor(actorData.verification);
+    this._getAddresses(actorData);
+    process.nextTick(cb, this.typeId === this.inheritedType);
+  }
+  
+  executeInit(debug, process) {
+    this.process = process;
+    this.debug = debug;
+    if(debug) {
+      this._next = this.next;
+      this.next = (value, err) => {
+        if(this.debug && this.executionContext.executingActorIndex !== this.orderIndex) {
+          this._debugData = {value, err};
+          this.executionContext.setExecutingActorIndex(this.orderIndex);
+          this.process.stall();
+          this.cbMessage(new MessageTestCaseDebugActorIndex(this.orderIndex), null, this.debug);
+        }
+        else {
+          return this._next(value, err);
+        }
+      }
+    }
+    this.loadLoggerMixin();
+    this.stateTimeout = new ActorStateTimeout(!debug ? null : process, !debug ? this.getTestDataNumber('tc-state-timeout', 5000) : this.getTestDataNumber('tc-state-debug-timeout', 90000));
+  }
+    
+  debugContinue() {
+    const _debugData = this._debugData;
+    this._debugData = null;
+    this.process.unstall();
+    this._next(_debugData.value, _debugData.err);
+  }
+  
+  setDependency(actorIndex) {
+    this.dependentOnIndices.push(actorIndex);
+  }
+  
+  getDependencies() {
+    return this.dependentOnIndices;
+  }
+  
+  getDependenciesFromPhase(phaseId) {
+    return this.dependentOnIndices;
+  }
+  
+  getName() {
+    return this.name;
+  }
+  
+  getPhaseLogNameState() {
+    return `${ActorPhaseConst.getName(this.currentPhaseId)}.${this.logName}.${this.getState().getName()}`;
+  }
+  
+  getIndex() {
+    return this.index;
+  }
+  
+  getIndexFromPhase(phaseId) {
+    return this.index;
+  }
+  
+  setIndex(index) {
+    this.index = index;
+  }
+  
+  getOrderIndex() {
+    return this.orderIndex;
+  }
+  
+  getOrderIndexFromPhase(phaseId) {
+    return this.orderIndex;
+  }
+  
+  setOrderIndex(index) {
+    this.orderIndex = index;
+  }
+  
+  setColumnIndex(index) {
+    this.columnIndex = index;
+  }
+  
+  getInstanceIndex() {
+    return this.instanceIndex;
+  }
+    
+  getSequence() {
+    return this.execution;
+  }
+  
+  getState() {
+    return this.actorState;
+  }
+  
+  getStateId() {
+    return this.actorState.getActorStateId();
+  }
+  
+  getStateName() {
+    return this.actorState.getName();
+  }
+  
+  getActorResultId() {
+    return this.actorResults.getActorResultId();
+  }
+  
+  setActorResultId(resultId) {
+    return this.actorResults.setResultId(this.actorState.getActorStateId(), resultId);
+  }
+  
+  getResultId() {
+    return this.actorResults.getResultId(this.actorState.getActorStateId());
+  }
+  
+  getStateResultId(state) {
+    return this.actorResults.getResultId(state);
+  }
+  
+  isSuccess() {
+    return ActorResultConst.SUCCESS >= this.getActorResultId();
+  }
+  
+  getResultName() {
+    return ActorResultConst.getName(this.actorResults.getResultId(this.actorState.getActorStateId()));
+  }
+  
+  getStateResultName(state) {
+    return ActorResultConst.getName(this.getStateResultId(state));
+  }
+  
+  setCurrentPhase(phaseId) {
+    this.currentPhaseId = phaseId;
+  }
+    
+  _getAddresses(actorData) {
+    switch(this.typeId) {
+      case ActorTypeConst.ORIG:
+      case ActorTypeConst.COND:
+        this._getAddress(this.src, null, actorData.src, Address.CLIENT);
+        this._getAddress(this.srcDst, null, actorData.dst, Address.SUT);
+        break;
+      case ActorTypeConst.TERM:
+      case ActorTypeConst.INTER:
+        this._getAddress(this.srvDst, null, actorData.dst, Address.SUT);
+        this._getAddress(this.srv, null, actorData.srv, Address.SERVER);
+        break;
+      case ActorTypeConst.PROXY:
+      case ActorTypeConst.SUT:
+        this._getAddress(this.src, null, actorData.src, Address.CLIENT);
+        this._getAddress(this.srcDst, this.srvDst, actorData.dst, Address.SUT);
+        this._getAddress(this.srv, null, actorData.srv, Address.SERVER);
+        break;
+    };
+  }
+  
+  _getAddress(addressesLeft, addressesRight, addressData, addressType) {
+    if(addressData) {
+      if(/^[\[{]/.test(addressData.trim())) {
+        const parsedAddressData = JSON.parse(addressData);
+        if(Array.isArray(parsedAddressData)) {
+          parsedAddressData.forEach((address) => {
+            if(!Array.isArray(address)) {
+              this._getAddress(addressesLeft, null, address, addressType);
+            }
+            else {
+              if(2 === address.length) {
+                this._getAddress(addressesLeft, null, address[0], addressType);
+                this._getAddress(addressesLeft, null, address[1], addressType);
+              }
+              else {
+                this.logError("Address length must be 2.", '6523a606-e5fe-428b-86ab-6bbd5a118863');
+              }
+            }
+          });
+        }
+        else if(typeof parsedAddressData === 'object') {
+          addressesLeft.push({
+            type: Address.IS_HARD_CODED,
+            value: new Address('hard coded', parsedAddressData.host, parsedAddressData.family, parsedAddressData.port, addressType, parsedAddressData.page, parsedAddressData.incognitoBrowser, parsedAddressData.uri)
+          });
+        }
+      }
+      else {
+        addressesLeft.push({
+          type: Address.IS_GENERATED,
+          value: addressData
+        });
+      }
+    }
+  }
+  
+  setPending(cbCancel) {
+    return this.actorPending.setPending(cbCancel);
+  }
+  
+  deletePending(pendingId) {
+    return this.actorPending.deletePending(pendingId);
+  }
+  
+  pendingSuccess(pendingId, value) {
+    this.actorPending.pendingSuccess(pendingId, value);
+  }
+  
+  pendingError(pendingId, err) {
+    this.actorPending.pendingError(pendingId, err);
+  }
+  
+  setCbActorStateDone(cbDone) {
+    this.cbActorStateDone = cbDone;
+  }
+  
+  actorStateDone(resultId) {
+    this.stateTimeout.stop();
+    if(ActorStateConst.EXIT === this.getStateId()) {
+      this._unlockAddresses(ActorResultConst.N_EXEC !== resultId && ActorResultConst.ERROR !== resultId && ActorResultConst.TIMEOUT !== resultId);
+    }
+    return this.cbActorStateDone(this, resultId);
+  }
+  
+  next(value, err) {
+    let result = null;
+    if(this.done) {
+      this.done = false;
+      this.actorStateDone(ActorResultConst.SUCCESS);
+    }
+    try {
+      if(err) {
+        this.actorPending.clear();
+        if('internal_error_interrupted' === err.message) {
+          this.interrupted = true;
+          this.currentGenerator = null;
+          this.actorStateDone(ActorResultConst.INTERRUPT);
+          return;
+        }
+        else if('internal_error_timeout' === err.message) {
+          this.currentGenerator = null;
+          this.actorStateDone(ActorResultConst.TIMEOUT);
+          return;
+        }
+        else if('internal_error_expected_interrupted' === err.message) {
+          this.currentGenerator = null;
+          this.actorStateDone(ActorResultConst.E_INTERRUPT);
+          return;
+        }
+        else if('internal_error_network_end' === err.message) {
+          this.logError('Receiving on a closed connection with no more data.', '77c6fdf8-7ae8-4b37-a7ab-7afe873d39bb');
+          this.setActorResultId(ActorResultConst.ERROR);
+          result = this.currentGenerator.next();
+          return;
+        }
+        else if('internal_error_worker' === err.message) {
+          this.setActorResultId(ActorResultConst.ERROR);
+          result = this.currentGenerator.next();
+          return;
+        }
+        else {
+          result = this.currentGenerator.throw(err);
+        }
+      }
+      else {
+        result = this.currentGenerator.next(value);
+      }
+    }
+    catch(e) {
+      this.actorPending.clear();
+      this.done = false;
+      if('verify__asdf1234' === e.message) {
+        this.actorStateDone(ActorResultConst.FAILURE);
+        return;
+      }
+      else {
+        this.logError(e, '4d4f2872-b0e0-4d2f-bdfb-4dd89a981aac');
+        this.actorStateDone(ActorResultConst.ERROR);
+        return;
+      }
+    }
+    if(result.done) {
+      if(this.actorPending.hasPendings()) {
+        this.logWarning('A pending without a yield.', 'core', '508421db-9d8c-46a3-83fa-bf7b977b1b9e');
+        this.done = true;
+      }
+      else {
+        this.done = false;
+        if(ActorStateConst.EXIT !== this.getStateId()) {
+          this.actorStateDone(ActorResultConst.SUCCESS);
+        }
+        else {
+          this._awaitClosePendingConnections(() => {
+            this.actorStateDone(ActorResultConst.SUCCESS);
+          });
+        }
+      }
+    }
+    else if(!this.actorPending.hasPendings()) {
+      this.logWarning('A yield without a pending.', 'core', '5a8aed39-766d-4134-a11b-d5609089de2d');
+      this.process.nextTick(this.next.bind(this));
+    }
+  }
+  
+  *partsRun() {
+    if(undefined !== this.preActorParts) {
+      for(let pre = 0; pre < this.preActorParts.length; ++pre) {
+        yield* this.preActorParts[pre].run();
+      }
+    }
+    if(undefined !== this.run) {
+      yield* this.run();
+    }
+    if(undefined !== this.postActorParts) {
+      for(let post = 0; post < this.postActorParts.length; ++post) {
+        yield* this.postActorParts[post].run();
+      }
+    } 
+  }
+  
+  executeState(generator) {
+    this.currentGenerator = generator;
+    this.process.nextTick((self, ActorResultConst) => {
+      if(self.currentGenerator) {
+        if(ActorResultConst.INTERRUPT !== self.actorResults.actorStateResult[self.actorState.getActorStateId()]) {
+          self.stateTimeout.start(self.doTimeout.bind(self));
+          self.next();
+        }
+      }
+    }, this, ActorResultConst);
+    return true;
+  }
+  
+  hasState() {
+    switch(this.getStateId()) {
+      case ActorStateConst.DATA:
+        return undefined !== this.data;
+      case ActorStateConst.INIT_SERVER:
+        return undefined !== this.initServer;
+      case ActorStateConst.INIT_CLIENT:
+        return undefined !== this.initClient;
+      case ActorStateConst.RUN:
+        return undefined !== this.run || undefined !== this.preActorParts || undefined !== this.postActorParts;
+      case ActorStateConst.EXIT:
+        return undefined !== this.exit;
+    }
+  }
+  
+  doData() {
+    this.logEngine('actor state: data', 'actor-state', 'c4675385-9403-4838-9d55-933cd551fd08');
+    if(undefined === this.data) {
+      return false;
+    }
+    return this.executeState(this.data());
+  }
+  
+  doInitServer() {
+    this.logEngine('actor state: initServer', 'actor-state', '5f9bfd4a-1d42-4a23-964d-5df3cabefa60');
+    if(undefined === this.initServer) {
+      return false;
+    }
+    return this.executeState(this.initServer());
+  }
+  
+  doInitClient() {
+    this.logEngine('actor state: initClient', 'actor-state', '381af64c-258a-452a-aed3-fe8857cdad9d');
+    if(undefined === this.initClient) {
+      return false;
+    }
+    return this.executeState(this.initClient());
+  }
+  
+  doRun() {
+    this.logEngine('actor state: run', 'actor-state', '7106fc36-a732-43ad-9cf0-e1b03a8a10b6');
+    if(undefined === this.preActorParts && undefined === this.postActorParts) {
+      if(undefined !== this.run) {
+        return this.executeState(this.run());
+      }
+    }
+    else {
+      return this.executeState(this.partsRun());
+    }
+    return false;
+  }
+  
+  doExit() {
+    this.logEngine('actor state: exit', 'actor-state', '25b81886-fb3c-41d3-9262-92c7f9a21c35');
+    if(undefined === this.exit) {
+      return false;
+    }
+    return this.executeState(this.exit(this.interrupted));
+  }
+  
+  doInterrupt(throwOrCancel) {
+    this.logWarning('Interrupt', 'core', '7941f7ad-8717-452b-a45d-c83b7babe0f1');
+    if(throwOrCancel) {
+      this.next(undefined, new Error('internal_error_interrupted'));
+    }
+  }
+  
+  doTimeout() {
+    this.logWarning('Timeout', 'core', '1184e77d-8cb2-41af-9964-c2eba3185bf9');
+    this.next(undefined, new Error('internal_error_timeout'));
+  }
+  
+  doExpectedInterrupt() {
+    this.next(undefined, new Error('internal_error_expected_interrupted'));
+  }
+}
+
+Object.assign(Actor.prototype, AsynchMixin);
+Object.assign(Actor.prototype, ContentMixin);
+Object.assign(Actor.prototype, SharedDataMixin);
+Object.assign(Actor.prototype, SharedExecutionDataMixin);
+Object.assign(Actor.prototype, LoggerMixin);
+Object.assign(Actor.prototype, TimerMixin);
+Object.assign(Actor.prototype, VerifyMixinBase);
+Object.assign(Actor.prototype, VerifyMixinMandatory);
+Object.assign(Actor.prototype, VerifyMixinOptional);
+Object.assign(Actor.prototype, VerifyMixinValue);
+Object.assign(Actor.prototype, TestDataMixin);
+
+
+module.exports = Actor;

package/project/server/engine/actor-phase.js

@@ -0,0 +1,26 @@
+
+'use strict';
+
+// TODO: remove
+class ActorPhase {
+  constructor(tabNames) {
+    this.PRE = 0;
+    this.EXEC = 1;
+    this.POST = 2;
+    this.NAME_PRE = 'pre';
+    this.NAME_EXEC = 'exec';
+    this.NAME_POST = 'post';
+    this.phaseIds = new Map([[this.NAME_PRE, this.PRE], [this.NAME_EXEC, this.EXEC], [this.NAME_POST, this.POST], ['pre, post', this.PRE]]);
+    this.phaseNames = [this.NAME_PRE, this.NAME_EXEC, this.NAME_POST];
+  }
+  
+  getName(phaseId) {
+    return this.phaseNames[phaseId];
+  }
+  
+  getId(phaseName) {
+    return this.phaseIds.get(phaseName);
+  }
+}
+
+module.exports = new ActorPhase();