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

package/project/server/engine/actor/actor-mixins/verify-mixin-mandatory.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+const ContentUndefined = require('../../data/content-undefined');
+
+
+const VerifyMixinMandatory = {
+  VERIFY_MANDATORY(expectedKey, actualValue, index1, index2) {
+    const expected = this._getVerificationData(expectedKey);
+    const mandatoryText = `Mandatory['${expectedKey}']`;
+    if(undefined === expected) {
+      this.logVerifyFailure(() => `${mandatoryText} is not set.`, '13ab504d-0d33-43c7-94f8-7cac8f009895');
+      throw new Error('verify__asdf1234');
+    }
+    else {
+      this._verify(mandatoryText, expected, actualValue, index1, index2);
+    }
+  },
+  *VERIFY_CONTENT_MANDATORY(expectedKey, actualSize, actualContent) {
+    const expected = this._getVerificationData(expectedKey);
+    const mandatoryText = `Mandatory Content['${expectedKey}']`;
+    if(undefined === expected) {
+      this.logVerifyFailure(() => `${mandatoryText} is not set.`, '133a74d9-0c8b-4899-80f4-86c88d88dba8');
+      throw new Error('verify__asdf1234');
+    }
+    else if('value' !== expected.type || 'string' !== expected.valueType) {
+      this.logVerifyFailure(() => `${mandatoryText} the value must be the content key of type string`, '9665350f-de80-4bd2-8e3d-6809ca2c7c55');
+      throw new Error('verify__asdf1234');
+    }
+    else {
+      const expectedContent = yield* this.getContentByName(expected.value);
+      if(expectedContent instanceof ContentUndefined) {
+        this.logVerifyFailure(() => `${mandatoryText} is not set.`, 'e1e040eb-8b5b-4ef6-a169-bfd9d3a823ed');
+        throw new Error('verify__asdf1234');
+      }
+      let result = this._verifyValue(expectedContent.size, actualSize, expected.operation, `Mandatory Content['${expectedKey}' is '${expected.value}'] size:`);
+      result = this._verifyContent(expectedContent, actualContent, expected.operation, `Mandatory Content['${expectedKey}' is '${expected.value}'] buffer`) && result;
+      if(!result) {
+        throw new Error('verify__asdf1234');
+      }
+    }
+  }
+};
+
+
+module.exports = VerifyMixinMandatory;

package/project/server/engine/actor/actor-mixins/verify-mixin-optional.js

@@ -0,0 +1,44 @@
+
+'use strict';
+
+const ContentUndefined = require('../../data/content-undefined');
+
+
+const VerifyMixinOptional = {
+  VERIFY_OPTIONAL(expectedKey, actualValue, index1, index2) {
+    const expectedValue = this._getVerificationData(expectedKey);
+    const optionalText = `Optional verification key '${expectedKey}'`;
+    if(undefined === expectedValue) {
+      this.logVerifySuccess(() => `${optionalText} is not set`, '6f0a8906-62da-46e5-a8a4-566679ddf507'); 
+    }
+    else {
+      this._verify(optionalText, expectedValue, actualValue, index1, index2);
+    }
+  },
+  *VERIFY_CONTENT_OPTIONAL(expectedKey, actualSize, actualContent) {
+    const expected = this._getVerificationData(expectedKey);
+    const optionalText = `Optional Content['${expectedKey}']`;
+    if(undefined === expected) {
+      this.logVerifySuccess(() => `Optional verification key '${expectedKey}' is not set`, 'c7c94cb0-ca5d-4267-a084-70013174b424');
+    }
+    else if('value' !== expected.type || 'string' !== expected.valueType) {
+      this.logVerifyFailure(() => `${optionalText} the value must be the content key of type string`, '671d4bd1-f9e8-47c0-946f-cb03e652c7ac');
+      throw new Error('verify__asdf1234');
+    }
+    else {
+      const expectedContent = yield* this.getContentByName(expected.value);
+      if(expectedContent instanceof ContentUndefined) {
+        this.logVerifyFailure(() => `${optionalText} is not set.`, '6943d1a8-4dbf-44e3-ac36-1eb326e33478');
+        throw new Error('verify__asdf1234');
+      }
+      let result = this._verifyValue(expectedContent.size, actualSize, expected.operation, `Optional Content['${expectedKey}' is '${expected.value}'] size:`);
+      result = this._verifyContent(expectedContent, actualContent, expected.operation, `Optional Content['${expectedKey}' is '${expected.value}'] buffer`) && result;
+      if(!result) {
+        throw new Error('verify__asdf1234');
+      }
+    }
+  }
+};
+
+
+module.exports = VerifyMixinOptional;

package/project/server/engine/actor/actor-mixins/verify-mixin-value.js

@@ -0,0 +1,71 @@
+
+'use strict';
+
+
+const VerifyMixinValue = {
+  _calculateExpectedValueType(value) {
+    if(Array.isArray(value)) {
+      const valueTypes = value.map((val) => {
+        return `[${this._calculateExpectedValueType(val)}]`;
+      });
+      return valueTypes[0]; // TODO: What to do if the types differ?
+    }
+    else {
+      if('string' === typeof value) {
+        return 'string';
+      }
+      else if('number' === typeof value) {
+        return 'number';
+      }
+      else if('boolean' === typeof value) {
+        return 'boolean';
+      }
+      else if('object' === typeof value) {
+        return 'object';
+      }
+      else {
+        return 'unknown';
+      }
+    }
+  },
+  _calculateExpected(expectedValue, operation) {
+    if(!Array.isArray(expectedValue)) {
+      return {
+        type: 'value',
+        value: expectedValue,
+        operation: operation,
+        valueType: this._calculateExpectedValueType(expectedValue)
+      };
+    }
+    else {
+      const valueTypes = [];
+      const operations = [];
+      expectedValue.forEach((val) => {
+        valueTypes.push(`${this._calculateExpectedValueType(val)}`);
+        operations.push(operation);
+      });
+      return {
+        type: 'array',
+        value: expectedValue,
+        operation: operations,
+        valueType: valueTypes
+      };
+    }
+  },
+  VERIFY_VALUE(expectedValue, actualValue, description, operation = '===') {
+    this._verify(!description ? 'Value' : `${description}. Value`, this._calculateExpected(expectedValue, operation), actualValue);
+  },
+  VERIFY_VALUE_INDEX(expectedValueArray, actualValueArray, index, description, operation = '===') {
+    this._verify(!description ? 'Value' : `${description}. Value`, this._calculateExpected(expectedValueArray, operation), actualValueArray, index);
+  },
+  VERIFY_CONTENT_VALUE(expectedContent, actualSize, actualContent, description, operation = '===') {
+    let result = this._verifyValue(expectedContent.size, actualSize, operation, `Content size:`);
+    result = this._verifyContent(expectedContent, actualContent, operation, `Content buffer`) && result;
+    if(!result) {
+      throw new Error('verify__asdf1234');
+    }
+  }
+};
+
+
+module.exports = VerifyMixinValue;

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

@@ -0,0 +1,32 @@
+
+'use strict';
+
+const Actor = require('./actor');
+const StackMixinClient = require('./actor-mixins/stack-mixin-client');
+const StackMixin = require('./actor-mixins/stack-mixin');
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+class ActorOriginating extends Actor {
+  constructor(actorParts) {
+    super(ActorTypeConst.ORIG, actorParts);
+    this.src = [];
+    this.srcDst = [];
+    this.srcResolved = [];
+    this.srcDstResolved = [];
+    this.initStackMixin();
+  }
+  
+  init(uniqueTcId, actorData, instanceIndex, cbMessage, executionContext, tcData, config, slowAwaitTime, nodes, cb) {
+    if('' === actorData.execution) {
+      actorData.execution = 'serial';
+    }
+    return super.init(uniqueTcId, actorData, instanceIndex, cbMessage, executionContext, tcData, config, slowAwaitTime, nodes, cb);
+  }
+}
+
+Object.assign(ActorOriginating.prototype, StackMixinClient);
+Object.assign(ActorOriginating.prototype, StackMixin);
+
+
+module.exports = ActorOriginating;

package/project/server/engine/actor/actor-part-mixins/part-asynch-mixin.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+
+const PartAsynchMixin = {
+  *all(array) {
+    yield* this.parent.all(array);
+  },
+  *asyncMethod(method) {
+    yield* this.parent.asyncMethod(method);
+  },
+  handlePendingIdSuccess(pendingId, value) {
+    this.parent.handlePendingIdSuccess(pendingId, value);
+  },
+  handlePendingIdError(pendingId, err) {
+    this.parent.handlePendingIdError(pendingId, err);
+  },
+  handlePendingId(pendingId, err, value) {
+    this.parent.handlePendingId(pendingId, err, value);
+  }
+};
+
+
+module.exports = PartAsynchMixin;

package/project/server/engine/actor/actor-part-mixins/part-logger-mixin.js

@@ -0,0 +1,39 @@
+
+'use strict';
+
+
+const PartLoggerMixin = {
+  createLogMessage(message, inners, data, dataBuffers) {
+    this.parent.createLogMessage(message, inners, data, dataBuffers);
+  },
+  logEngine(message, group, guid, depth=0) {
+    this.parent.logEngine(message, group, guid, depth + 1);
+  },
+  logDebug(message, group, guid, depth=0) {
+    this.parent.logDebug(message, group, guid, depth + 1);
+  },
+  logError(errOrMsg, guid, depth=0) {
+    this.parent.logError(errOrMsg, guid, depth + 1);
+  },
+  logWarning(message, group, guid, depth=0) {
+    this.parent.logWarning(message, group, guid, depth + 1);
+  },
+  logIp(log, group, guid, depth=0) {
+    this.parent.logIp(log, group, guid, depth + 1);
+  },
+  logGui(message, group, guid, depth=0) {
+    this.parent.logGui(message, group, guid, depth + 1);
+  },
+  logVerifySuccess(message, guid, depth=0) {
+    this.parent.logVerifySuccess(message, guid, depth + 1);
+  },
+  logVerifyFailure(message, guid, depth=0) {
+    this.parent.logVerifyFailure(message, guid, depth + 1);
+  },
+  logTestData(message, group, guid, depth=0) {
+    this.parent.logTestData(message, group, guid, depth + 1);
+  }
+};
+
+
+module.exports = PartLoggerMixin;

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

@@ -0,0 +1,33 @@
+
+'use strict';
+
+
+const SharedRuntimeDataMixin = {
+  setSharedData(key, value) {
+    this.parent.setSharedData(key, value);
+  },
+  getSharedData(key, defaultValue) {
+    return this.parent.getSharedData(key, defaultValue);
+  },
+  *waitForSharedData(key) {
+    yield* this.parent.waitForSharedData(key);
+  },
+  *waitForSharedDataValue(key, value) {
+    yield* this.parent.waitForSharedDataValue(key, value);
+  },
+  getSharedDataActor(key, name, index) {
+    return this.parent.getSharedDataActor(key, name, index);
+  },
+  setSharedDataActor(key, value, name, index) {
+    this.parent.getSharedDataActor(key, value, name, index);
+  },
+  setSharedDataExecution(key, value) {
+    this.parent.setSharedDataExecution(key, value);
+  },
+  getSharedDataExecution(key, defaultValue) {
+    this.parent.getSharedDataExecution(key, defaultValue);
+  }
+};
+
+
+module.exports = SharedRuntimeDataMixin;

package/project/server/engine/actor/actor-part-mixins/part-timer-mixin.js

@@ -0,0 +1,12 @@
+
+'use strict';
+
+
+const PartTimerMixin = {
+  *asyncMethod(method) {
+    yield* this.parent.asyncMethod(method);
+  }
+};
+
+
+module.exports = PartTimerMixin;

package/project/server/engine/actor/actor-part-mixins/part-verify-mixin-mandatory.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+const PartVerifyMixinMandatory = {
+  VERIFY_MANDATORY(expectedKey, actualValue, index1, index2) {
+    this.parent.VERIFY_MANDATORY(expectedKey, actualValue, index1, index2);
+  },
+  *VERIFY_CONTENT_MANDATORY(expectedKey, actualSize, actualContent) {
+    yield* this.parent.VERIFY_CONTENT_MANDATORY(expectedKey, actualSize, actualContent);
+  }
+};
+
+
+module.exports = PartVerifyMixinMandatory;

package/project/server/engine/actor/actor-part-mixins/part-verify-mixin-optional.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+const PartVerifyMixinOptional = {
+  VERIFY_OPTIONAL(expectedKey, actualValue) {
+    this.parent.VERIFY_OPTIONAL(expectedKey, actualValue);
+  },
+  *VERIFY_CONTENT_OPTIONAL(expectedKey, actualSize, actualContent) {
+    yield* this.parent.VERIFY_CONTENT_OPTIONAL(expectedKey, actualSize, actualContent);
+  }
+};
+
+
+module.exports = PartVerifyMixinOptional;

package/project/server/engine/actor/actor-part-mixins/part-verify-mixin-value.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+const PartVerifyMixinValue = {
+  VERIFY_VALUE(expectedValue, actualValue, description, operation = '===') {
+    this.parent.VERIFY_VALUE(expectedValue, actualValue, description, operation);
+  },
+  VERIFY_CONTENT_VALUE(expectedContent, actualSize, actualContent, description, operation = '===') {
+    this.parent.VERIFY_CONTENT_VALUE(expectedContent, actualSize, actualContent, description, operation);
+  }
+};
+
+
+module.exports = PartVerifyMixinValue;

package/project/server/engine/actor/actor-part-post.js

@@ -0,0 +1,37 @@
+
+'use strict';
+
+const PartAsynchMixin = require('./actor-part-mixins/part-asynch-mixin');
+const PartLoggerMixin = require('./actor-part-mixins/part-logger-mixin');
+const PartSharedRuntimeDataMixin = require('./actor-part-mixins/part-shared-runtime-data-mixin');
+const PartTimerMixin = require('./actor-part-mixins/part-timer-mixin');
+const PartVerifyMixinMandatory = require('./actor-part-mixins/part-verify-mixin-mandatory');
+const PartVerifyMixinOptional = require('./actor-part-mixins/part-verify-mixin-optional');
+const PartVerifyMixinValue = require('./actor-part-mixins/part-verify-mixin-value');
+
+
+class ActorPartPost {
+  constructor(parent) {
+    this.parent = parent;
+    this.index = 0;
+    this.type = 1;       // Because the ActorPartPost is exported through actor-api the instanceof will not work
+    this.name = this.constructor.name;
+  }
+  
+  init(parent, index) {
+    this.parent = parent;
+    this.index = index;
+    return this;
+  }
+}
+
+Object.assign(ActorPartPost.prototype, PartAsynchMixin);
+Object.assign(ActorPartPost.prototype, PartLoggerMixin);
+Object.assign(ActorPartPost.prototype, PartSharedRuntimeDataMixin);
+Object.assign(ActorPartPost.prototype, PartTimerMixin);
+Object.assign(ActorPartPost.prototype, PartVerifyMixinMandatory);
+Object.assign(ActorPartPost.prototype, PartVerifyMixinOptional);
+Object.assign(ActorPartPost.prototype, PartVerifyMixinValue);
+
+
+module.exports = ActorPartPost;

package/project/server/engine/actor/actor-part-pre.js

@@ -0,0 +1,37 @@
+
+'use strict';
+
+const PartAsynchMixin = require('./actor-part-mixins/part-asynch-mixin');
+const PartLoggerMixin = require('./actor-part-mixins/part-logger-mixin');
+const PartSharedRuntimeDataMixin = require('./actor-part-mixins/part-shared-runtime-data-mixin');
+const PartTimerMixin = require('./actor-part-mixins/part-timer-mixin');
+const PartVerifyMixinMandatory = require('./actor-part-mixins/part-verify-mixin-mandatory');
+const PartVerifyMixinOptional = require('./actor-part-mixins/part-verify-mixin-optional');
+const PartVerifyMixinValue = require('./actor-part-mixins/part-verify-mixin-value');
+
+
+class ActorPartPre {
+  constructor(parent) {
+    this.parent = parent;
+    this.index = 0;
+    this.type = 0;         // Because the ActorPartPre is exported through actor-api the instanceof will not work
+    this.name = this.constructor.name;
+  }
+  
+  init(parent, index) {
+    this.parent = parent;
+    this.index = index;
+    return this;
+  }
+}
+
+Object.assign(ActorPartPre.prototype, PartAsynchMixin);
+Object.assign(ActorPartPre.prototype, PartLoggerMixin);
+Object.assign(ActorPartPre.prototype, PartSharedRuntimeDataMixin);
+Object.assign(ActorPartPre.prototype, PartTimerMixin);
+Object.assign(ActorPartPre.prototype, PartVerifyMixinMandatory);
+Object.assign(ActorPartPre.prototype, PartVerifyMixinOptional);
+Object.assign(ActorPartPre.prototype, PartVerifyMixinValue);
+
+
+module.exports = ActorPartPre;

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

@@ -0,0 +1,79 @@
+
+'use strict';
+
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+
+
+class ActorPending {
+  constructor(actor) {
+    this.actor = actor;
+    this.pendingIds = new Map();
+    this.innerCancel = null;
+  }
+  
+  setPending(cbCancel) {
+    const pendingId = GuidGenerator.create();
+    this.actor.logEngine(() => `PENDING START: '${pendingId}'`, 'actor-pending', 'e8aa34cc-a49a-4827-969e-79140fb34ca6');
+    this.pendingIds.set(pendingId, cbCancel);
+    return pendingId;
+  }
+  
+  deletePending(pendingId) {
+    this.pendingIds.delete(pendingId);
+    return 0 === this.pendingIds.size;
+  }
+  
+  pendingSuccess(pendingId, value) {
+    this.actor.logEngine(() => `PENDING SUCCESS: '${pendingId}'`, 'actor-pending', '69c56938-9fac-4f21-8c32-ab0ba3997437');
+    this.actor.process.nextTick((self, pendingId, value) => {
+      if(self.pendingIds.has(pendingId)) {
+        if(self.deletePending(pendingId)) {
+            self.actor.next(value);
+        }
+      }
+      else {
+        self.actor.logWarning(() => `No matching pendingId on success response. pendingId: '${pendingId}'`, 'core', 'd06dfd28-fdda-468a-99f5-c9b335614e5d');
+      }
+    }, this, pendingId, value);
+  }
+  
+  pendingError(pendingId, err) {
+    this.actor.logEngine(() => `PENDING ERROR: '${pendingId}'`, 'actor-pending', '8d3d6e06-4277-48e5-a54f-394ec527dec3');
+    this.actor.process.nextTick((self, pendingId, err) => {
+      if(self.pendingIds.has(pendingId)) {
+        self.pendingIds.clear();
+          self.actor.next(undefined, err);
+      }
+      else {
+        self.actor.logWarning(() => `No matching pendingId on error response. pendingId: '${pendingId}'`, 'core', 'a1ccb550-7007-4eac-b020-af30799935be');
+      }
+    }, this, pendingId, err);
+  }
+  
+  hasPendings() {
+    return 0 !== this.pendingIds.size;
+  }
+  
+  clear() {
+    this.pendingIds.forEach((cbPendingCancel, pendingId) => {
+      cbPendingCancel && cbPendingCancel();
+      this.actor.logEngine(() => `PENDING CANCEL: '${pendingId}' - ${cbPendingCancel ? '' : 'No cancel method implemented.'}`, 'actor-pending', 'f91be9d3-da8e-4096-ad97-1c803dd907d8');
+    });
+    this.pendingIds.clear();
+    if(this.cancel) {
+      this.cancel();
+      this.cancel = null;
+    }
+  }
+  
+  setInnerCancel(cancel) {
+    this.cancel = cancel;
+  }
+  
+  removeInnerCancel() {
+    this.cancel = null;
+  }
+}
+
+
+module.exports = ActorPending;

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

@@ -0,0 +1,38 @@
+
+'use strict';
+
+const Actor = require('./actor');
+const StackMixinClient = require('./actor-mixins/stack-mixin-client');
+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 ActorProxy extends Actor {
+  constructor(actorParts) {
+    super(ActorTypeConst.PROXY, actorParts);
+    this.src = [];
+    this.srcDst = [];
+    this.srvDst = [];
+    this.srv = [];
+    this.srcResolved = [];
+    this.srcDstResolved = [];
+    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(ActorProxy.prototype, StackMixinClient);
+Object.assign(ActorProxy.prototype, StackMixinServer);
+Object.assign(ActorProxy.prototype, StackMixin);
+
+
+module.exports = ActorProxy;

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

@@ -0,0 +1,36 @@
+
+'use strict';
+
+const ActorState = require('../actor-state');
+const ActorResultConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-result-const');
+
+
+class ActorResults {
+  constructor() {
+    this.actorStateResult = [
+      ActorResultConst.NA,
+      ActorResultConst.NA,
+      ActorResultConst.NA,
+      ActorResultConst.NA,
+      ActorResultConst.NA
+    ];
+  }
+  
+  getActorResultId() {
+    return Math.max(...this.actorStateResult);
+  }
+  
+  getResultId(actorStateId) {
+    return this.actorStateResult[actorStateId];
+  }
+  
+  setResultId(actorStateId, resultId) {
+    if(resultId > this.actorStateResult[actorStateId]) {
+      this.actorStateResult[actorStateId] = resultId;
+    }
+    return this.actorStateResult[actorStateId];
+  }
+}
+
+
+module.exports = ActorResults;

package/project/server/engine/actor/actor-state-timeout.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const HighResolutionTimestamp = require('z-abs-corelayer-server/server/high-resolution-timestamp');
+
+
+class ActorStateTimeout {
+  constructor(process, timeout) {
+    this.setTimeout = process ? process.setTimeout.bind(process) : setTimeout;
+    this.clearTimeout = process ? process.clearTimeout.bind(process) : clearTimeout;
+    this.timeout = timeout;
+    this.timeoutCancelId = null;
+  }
+  
+  start(cb) {
+    if(this.timeout > 0) {
+      this.timeoutCancelId = this.setTimeout(() => {
+        this.timeoutCancelId = null;
+        cb();
+      }, this.timeout);
+    }
+  }
+  
+  stop() {
+    if(this.timeout > 0) {
+      if(null !== this.timeoutCancelId) {
+        this.clearTimeout(this.timeoutCancelId);
+      }
+      this.timeoutCancelId = null;
+    }
+  }
+}
+
+
+module.exports = ActorStateTimeout;

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

@@ -0,0 +1,38 @@
+
+'use strict';
+
+const Actor = require('./actor');
+const StackMixinClient = require('./actor-mixins/stack-mixin-client');
+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 ActorSut extends Actor {
+  constructor(actorParts) {
+    super(ActorTypeConst.SUT, actorParts);
+    this.src = [];
+    this.srcDst = [];
+    this.srvDst = [];
+    this.srv = [];
+    this.srcResolved = [];
+    this.srcDstResolved = [];
+    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(ActorSut.prototype, StackMixinClient);
+Object.assign(ActorSut.prototype, StackMixinServer);
+Object.assign(ActorSut.prototype, StackMixin);
+
+
+module.exports = ActorSut;