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

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

@@ -0,0 +1,185 @@
+
+'use strict';
+
+const ActorStateMachineData = require('./actor-state-machine-data');
+const ActorStateMachineExec = require('./actor-state-machine-exec');
+const ActorStateMachinePre = require('./actor-state-machine-pre');
+const ActorStateMachinePost = require('./actor-state-machine-post');
+const ActorResultConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-result-const');
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+class ActorStateMachine {
+  static RUN_NONE = 0;
+  static RUN_DATA_PRE = 1;
+  static RUN_DATA_EXEC = 2;
+  static RUN_DATA_PRE_EXEC = 3;
+  static RUN_DATA_POST = 4;
+  static RUN_DATA_PRE_POST = 5;
+  static RUN_DATA_EXEC_POST = 6;
+  static RUN_DATA_PRE_EXEC_POST = 7;
+  
+  constructor() {
+    this.actorStateMachineData = null;
+    this.actorStateMachinePre = null;
+    this.actorStateMachineExec = null;
+    this.actorStateMachinePost = null;
+    this.kindOfRun = 0;
+    this.cbDone = null;
+    this.tcSettings = null;
+  }
+    
+  init(tc, uniqueTcId, executionContext, actors, debug, cbMessage) {
+    this.actorStateMachinePre = null;
+    this.actorStateMachineExec = null;
+    this.actorStateMachinePost = null;
+    this.kindOfRun = 0;
+    this.cbDone = null;
+    this.tcSettings = tc.tc.settings;
+    this.actorStateMachineData = new ActorStateMachineData(tc, uniqueTcId, executionContext, cbMessage, actors.preActors, actors.execActors, actors.postActors, debug);
+    if(0 !== actors.preActors.actors.length) {
+      this.actorStateMachinePre = new ActorStateMachinePre(tc, uniqueTcId, executionContext, cbMessage, actors.preActors, debug);
+      this.kindOfRun += 1;
+    }
+    if(0 !== actors.execActors.actors.length) {
+      this.actorStateMachineExec = new ActorStateMachineExec(tc, uniqueTcId, executionContext, cbMessage, actors.execActors, debug);
+      this.kindOfRun += 2;
+    }
+    if(0 !== actors.postActors.actors.length) {
+      this.actorStateMachinePost = new ActorStateMachinePost(tc, uniqueTcId, executionContext, cbMessage, actors.postActors, debug);
+      this.kindOfRun += 4;
+    }
+  }
+  
+  run(done, cbDone) {
+    this.cbDone = cbDone;
+    switch(this.kindOfRun) {
+      case ActorStateMachine.RUN_NONE:
+        this._calculateSumResult(done, ActorResultConst.NONE, ActorResultConst.NONE, ActorResultConst.NONE);
+        break;
+      case ActorStateMachine.RUN_DATA_PRE:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachinePre.run(dataResultId, (resultIdPre) => {
+            this._calculateSumResult(done, resultIdPre, ActorResultConst.NONE, ActorResultConst.NONE);
+          });
+        });
+        break;
+      case ActorStateMachine.RUN_DATA_EXEC:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachineExec.run(dataResultId, (resultIdExec) => {
+            this._calculateSumResult(done, ActorResultConst.NONE, resultIdExec, ActorResultConst.NONE);
+          });
+        });
+        break;
+      case ActorStateMachine.RUN_DATA_PRE_EXEC:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachinePre.run(dataResultId, (resultIdPre) => {
+            this.actorStateMachineExec.run(Math.max(dataResultId, resultIdPre), (resultIdExec) => {
+              this._calculateSumResult(done, resultIdPre, resultIdExec, ActorResultConst.NONE);
+            });
+          });
+        }); 
+        break;
+      case ActorStateMachine.RUN_DATA_POST:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachinePost.run(dataResultId, (resultIdPost) => {
+            this._calculateSumResult(done, ActorResultConst.NONE, ActorResultConst.NONE, resultIdPost);
+          });
+        });
+        break;
+      case ActorStateMachine.RUN_DATA_PRE_POST:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachinePre.run(dataResultId, (resultIdPre) => {
+            this.actorStateMachinePost.run(Math.max(dataResultId, resultIdPre), (resultIdPost) => {
+              this._calculateSumResult(done, resultIdPre, ActorResultConst.NONE, resultIdPost);
+            });
+          });
+        });
+        break;
+      case ActorStateMachine.RUN_DATA_EXEC_POST:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachineExec.run(dataResultId, (resultIdExec) => {
+            this.actorStateMachinePost.run(Math.max(dataResultId, resultIdExec), (resultIdPost) => {
+              this._calculateSumResult(done, ActorResultConst.NONE, resultIdExec, resultIdPost);
+            });
+          });
+        });
+        break;
+      case ActorStateMachine.RUN_DATA_PRE_EXEC_POST:
+        this.actorStateMachineData.data((dataResultId) => {
+          this.actorStateMachinePre.run(dataResultId, (resultIdPre) => {
+            this.actorStateMachineExec.run(Math.max(dataResultId, resultIdPre), (resultIdExec) => {
+              this.actorStateMachinePost.run(Math.max(dataResultId, resultIdPre, resultIdExec), (resultIdPost) => {
+                this._calculateSumResult(done, resultIdPre, resultIdExec, resultIdPost);
+              });
+            });
+          });
+        });
+        break;
+    }
+  }
+  
+  runCommentOut(done, cbDone) {
+    this.cbDone = cbDone;
+    this._calculateSumResult(done, ActorResultConst.NONE, ActorResultConst.NONE, ActorResultConst.NONE);
+  }
+  
+  stop(done) {
+    let pendings = 0;
+    if(null !== this.actorStateMachineData) {
+      ++pendings;
+      this.actorStateMachineData.stop(() => {
+        if(0 === --pendings) {
+          done();
+        }
+      });
+    }
+    if(null !== this.actorStateMachinePre) {
+      ++pendings;
+      this.actorStateMachinePre.stop(() => {
+        if(0 === --pendings) {
+          done();
+        }
+      });
+    }
+    if(null !== this.actorStateMachineExec) {
+      ++pendings;
+      this.actorStateMachineExec.stop(() => {
+        if(0 === --pendings) {
+          done();
+        }
+      });
+    }
+    if(null !== this.actorStateMachinePost) {
+      ++pendings;
+      this.actorStateMachinePost.stop(() => {
+        if(0 === --pendings) {
+          done();
+        }
+      });
+    }
+    if(0 === pendings) {
+      done();
+    }
+  }
+ 
+  _calculateSumResult(cbDone, resultIdPre, resultIdExec, resultIdPost, tcResultId = -1) {
+    this.cbDone((commentOut, last) => {
+      if(undefined !== this.tcSettings && 1 === this.tcSettings.length && !commentOut) {
+        if(ActorResultConst.getTableNameResultIds(this.tcSettings[0].preResult, true) === resultIdPre && ActorResultConst.getTableNameResultIds(this.tcSettings[0].execResult, true) === resultIdExec && ActorResultConst.getTableNameResultIds(this.tcSettings[0].postResult, true) === resultIdPost) {
+          return cbDone(ActorResultConst.SUCCESS, resultIdPre, resultIdExec, resultIdPost, last);
+        }
+        else {
+          return cbDone(ActorResultConst.FAILURE, resultIdPre, resultIdExec, resultIdPost, last);
+        }
+      }
+      else {
+        const resultId = -1 === tcResultId ? Math.max(resultIdPre, resultIdExec, resultIdPost) : tcResultId;
+        return cbDone(resultId, resultIdPre, resultIdExec, resultIdPost, last);
+      }
+    });
+  }
+}
+
+
+module.exports = ActorStateMachine;

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

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const ActorStateConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-state-const');
+
+
+class ActorState {
+  constructor(actor) {
+    this.actor = actor;
+    this.currentActorStateId = ActorStateConst.DATA;
+  }
+  
+  set(actorStateId) {
+    this.currentActorStateId = actorStateId;
+  }
+  
+  setNext() {
+    this.currentActorStateId += 1;
+  }
+  
+  getActorStateId() {
+    return this.currentActorStateId;
+  }
+  
+  getName() {
+    return ActorStateConst.actorStateNames[this.currentActorStateId];
+  }
+  
+  getNameFromState(actorStateId) {
+    return ActorStateConst.actorStateNames[actorStateId];
+  }
+}
+
+
+module.exports = ActorState;

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

@@ -0,0 +1,68 @@
+
+const WebWorkerThreads = require('webworker-threads');
+
+
+class ActorWorker {
+  constructor() {
+    this.threadsIdle = [];
+    this.threadsWorking = new Map();
+    this._createThreadPool(15);
+    this.jobQueue = [];
+  }
+  
+  load() {
+    
+  }
+  
+  doData(cmd) {
+    this._addJob(cmd);
+  }
+  
+  doInitServer(cmd) {
+    this._addJob(cmd);
+  }
+  
+  doInitClient(cmd) {
+    this._addJob(cmd);
+  }
+
+  doRun(cmd) {
+    this._addJob(cmd);
+  }
+  
+  doExit(cmd) {
+    this._addJob(cmd);
+  }
+  
+  _createThreadPool(nbrOfThreads) {
+    for(let i = 0; i < nbrOfThreads; ++i) {
+      let thread = WebWorkerThreads.create();
+      this.threadsIdle.push(thread);
+      thread.load('C:\\Users\\A\\Documents\\ActorBase\\Actor\\dist\\serverWorkers\\serverWorkerActor\\server-worker-actor-bundle.js');
+      thread.on('response', (data) => {
+        let response = JSON.parse(data);
+        let thread = this.threadsWorking.get(response.threadId);
+        if(0 === this.jobQueue.length) {
+          this.threadsIdle.push(thread);
+          this.threadsWorking.delete(response.threadId);
+        }
+        else {
+          thread.emit('message', this.jobQueue.pop());
+        }
+      });
+    }
+  }
+  
+  _addJob(msg) {
+    if(0 !== this.threadsIdle.length) {
+      let thread = this.threadsIdle.pop();
+      this.threadsWorking.set(thread.id, thread);
+      thread.emit('message', msg);
+    }
+    else {
+      this.jobQueue.push(msg);
+    }
+  }
+}
+
+module.exports = new ActorWorker();

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

@@ -0,0 +1,49 @@
+
+'use strict';
+
+const ActorPhaseConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-phase-const');
+
+
+class ActorsPhase {
+  constructor(phaseId) {
+    this.phaseId = phaseId;
+    this.phaseName = ActorPhaseConst.getName(phaseId);
+    this.actors = [];
+    this.notStartedActors = new Map();
+  }
+  
+  add(actor) {
+    this.actors.push(actor);
+  }
+  
+  addFront(actor) {
+    this.actors.splice(0, 0, actor);
+  }
+  
+  setIndex() {
+    this.actors.forEach((actor) => {
+      this.notStartedActors.set(actor.getIndexFromPhase(this.phaseId), actor);
+    });
+  }
+  
+  getNextActors(actorDoneIndices) {
+    const foundActors = [];
+    this.notStartedActors.forEach((actor) => {
+      const found = undefined !== actor.getDependencies(this.phaseId).find((dependentActorIndex) => {
+        return undefined !== actorDoneIndices.find((actorDoneIndex) => {
+          return actorDoneIndex === dependentActorIndex;
+        });
+      });
+      if(found) {
+        foundActors.push(actor);
+      }
+    });
+    foundActors.forEach((actor) => {
+      this.notStartedActors.delete(actor.getIndex());
+    });
+    return foundActors;
+  }
+}
+
+
+module.exports = ActorsPhase;

package/project/server/engine/actors.js

@@ -0,0 +1,317 @@
+
+'use strict';
+
+const ActorsPhase = require('./actors-phase');
+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 Logger = require('z-abs-corelayer-server/server/log/logger');
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const MemoryCacheArray = require('z-abs-corelayer-cs/clientServer/memory/memory-cache-array');
+const MemoryCacheMap = require('z-abs-corelayer-cs/clientServer/memory/memory-cache-map');
+const FactoryFunction = require('z-abs-corelayer-cs/clientServer/factory/factory-function');
+const Module = require('module');
+const Path = require('path');
+
+
+class Actors {
+  static REPLACE_CONDITION = "(VERIFY_MANDATORY|VERIFY_OPTIONAL|VERIFY_VALUE|VERIFY_CONTENT_VALUE|VERIFY_CONTENT_MANDATORY|VERIFY_CONTENT_OPTIONAL|this.delay|this.delay|this.async\\(|this.callback\\(|this.setSharedData\\(|this.setSharedDataActor\\(|this.waitForSharedData\\(|this.waitForSharedDataActor\\(|this.setSharedExecutionData\\(|this.waitForSharedExecutionData\\(|this.getContent|this.getContentByName|this.closeConnection|this.createConnection|this.createServer|this.([^ ]*)Connection.send\\(|this.([^ ]*)Connection.sendLine\\(|this.([^ ]*)Connection.sendObject\\(|this.([^ ]*)Connection.sendHeader\\(|this.([^ ]*)Connection.sendRequestLine\\(|this.([^ ]*)Connection.sendHeaders\\(|this.([^ ]*)Connection.sendBody\\(|this.([^ ]*)Connection.receive\\(|this.([^ ]*)Connection.receiveLine\\(|this.([^ ]*)Connection.receiveObject\\(|this.([^ ]*)Connection.receiveSize\\(|this.([^ ]*)Connection.receiveHeader\\(|this.([^ ]*)Connection.receiveBody\\(|this.([^ ]*)Connection.accept\\(|this.([^ ]*)Connection.close\\(|this.([^ ]*)Connection.sendText\\(|this.([^ ]*)Connection.receiveText\\()";
+  static REPLACE_HANDLE = "\r\n  switch(parameters[0]) {\r\n    case 'VERIFY_MANDATORY':\r\n    case 'VERIFY_OPTIONAL':\r\n    case 'VERIFY_VALUE':\r\n    case 'VERIFY_CONTENT_VALUE':\r\n      return `this.${match}`;\r\n    case 'VERIFY_CONTENT_MANDATORY':\r\n    case 'VERIFY_CONTENT_OPTIONAL':\r\n      return `yield* this.${match}`;\r\n    case 'this.delay': \r\n    case 'this.async(': \r\n    case 'this.callback(': \r\n    case 'this.setSharedData(': \r\n    case 'this.setSharedDataActor(': \r\n    case 'this.waitForSharedData(': \r\n    case 'this.waitForSharedDataActor(': \r\n    case 'this.setSharedExecutionData(': \r\n    case 'this.waitForSharedExecutionData(': \r\n        case 'this.getContent': \r\n    case 'this.getContentByName': \r\n    case 'this.closeConnection': \r\n      return `yield* ${match}`;\r\n    case 'this.createConnection': \r\n    case 'this.createServer': \r\n      return `yield ${match}`;\r\n    case `this.${parameters[1]}Connection.send(`:\r\n    case `this.${parameters[2]}Connection.sendLine(`:\r\n    case `this.${parameters[3]}Connection.sendObject(`:\r\n    case `this.${parameters[4]}Connection.sendHeader(`:\r\n    case `this.${parameters[5]}Connection.sendRequestLine(`:\r\n    case `this.${parameters[6]}Connection.sendHeaders(`:\r\n    case `this.${parameters[7]}Connection.sendBody(`:\r\n    case `this.${parameters[8]}Connection.receive(`:\r\n    case `this.${parameters[9]}Connection.receiveLine(`:\r\n    case `this.${parameters[10]}Connection.receiveObject(`:\r\n    case `this.${parameters[11]}Connection.receiveSize(`:\r\n    case `this.${parameters[12]}Connection.receiveHeader(`:\r\n    case `this.${parameters[13]}Connection.receiveBody(`:\r\n    case `this.${parameters[14]}Connection.accept(`:\r\n    case `this.${parameters[15]}Connection.close(`:\r\n      case `this.${parameters[16]}Connection.sendText(`:\r\n      case `this.${parameters[17]}Connection.receiveText(`:\r\n      return `yield ${match}`;\r\n    default:\r\n      ddb.writeln('Error:', parameters[0]);\r\n      return match;\r\n  };\r\n";
+  static replaceCondition = new RegExp(Actors.REPLACE_CONDITION, 'g');
+  static replaceHandle = new Function('match', 'parameters', Actors.REPLACE_HANDLE);
+  
+  constructor(uniqueTcId, tc, executionContext, tcData, debug, config, slowAwaitTime, cbMessage) {
+    this.uniqueTcId = uniqueTcId;
+    this.tc = tc;
+    this.executionContext = executionContext;
+    this.tcData = tcData;
+    this.debug = debug;
+    this.config = config;
+    this.slowAwaitTime = slowAwaitTime;
+    this.cbMessage = cbMessage;
+    this.preActors = new ActorsPhase(ActorPhaseConst.PRE);
+    this.execActors = new ActorsPhase(ActorPhaseConst.EXEC);
+    this.postActors = new ActorsPhase(ActorPhaseConst.POST);
+    this.actors = MemoryCacheArray.create(MemoryCacheArray.TYPE_OBJECT);
+    this.nodes = MemoryCacheArray.create(MemoryCacheArray.TYPE_OBJECT);
+    this.results = MemoryCacheArray.create(MemoryCacheArray.TYPE_BOOLEAN);
+    this.instanceIndices = MemoryCacheMap.create(MemoryCacheMap.TYPE_STRING_INT);
+    this.actorFactories = new Map();
+  }
+  
+  destructor() {
+    MemoryCacheArray.destructor(MemoryCacheArray.TYPE_OBJECT, this.actors);
+    MemoryCacheArray.destructor(MemoryCacheArray.TYPE_OBJECT, this.nodes);
+    MemoryCacheArray.destructor(MemoryCacheArray.TYPE_BOOLEAN, this.results);
+    MemoryCacheMap.destructor(MemoryCacheMap.TYPE_STRING_INT, this.instanceIndices);
+  }
+  
+  loadActors(cb) {
+    const actors = this.tc.actors;
+    const size = actors.length;
+    if(0 === size) {
+      process.nextTick((self, cb) => {
+        this._calculateIndices();
+        cb(true);
+      }, this, cb);
+    }
+    for(let i = 0; i < size; ++i) {
+      process.nextTick((self, actors, FactoryFunction, instanceIndices, ActorTypeConst, results, cb) => {
+        const actorData = actors[i];
+        const actor = FactoryFunction.create((self, actorData) => {
+          return !actorData.inlineCode ? self._loadFromFile(actorData) : self._loadFromString(actorData);
+        }, self, actorData);
+        if(actor) {
+          let instanceIndex = 0;
+          const actorName = actorData.name.substr(actorData.name.lastIndexOf('.') + 1);
+          if(instanceIndices.has(actorName)) {
+            instanceIndex = instanceIndices.get(actorName) + 1;
+          }
+          else {
+            instanceIndex = 1;
+          }
+          instanceIndices.set(actorName, instanceIndex);     
+          if(actorData.type !== ActorTypeConst.getName(actor.inheritedType)) {
+            results.push(false);
+            if(size === results.length) {
+              self._actorsLoaded(results, cb);
+            }
+          }
+          else {
+            actor.init(self.uniqueTcId, actorData, instanceIndex, self.cbMessage, self.executionContext, self.tcData, self.config, self.slowAwaitTime, self.nodes, (result) => {
+              self._addActor(actor);
+              results.push(result);
+              if(size === results.length) {
+                self._actorsLoaded(results, cb);
+              }
+            });
+          }
+        }
+        else {
+          results.push(false);
+          if(size === results.length) {
+            self._actorsLoaded(results, cb);
+          }
+        }
+      }, this, actors, FactoryFunction, this.instanceIndices, ActorTypeConst, this.results, cb);
+    }
+  }
+  
+  _actorsLoaded(results, cb) {
+    const result = results.every((result) => {
+      return result;
+    });
+    if(result) {
+      this._calculateIndices();
+      this._calculatDependencies(this.preActors.actors, ActorPhaseConst.PRE);
+      this._calculatDependencies(this.execActors.actors, ActorPhaseConst.EXEC);
+      this._calculatDependencies(this.postActors.actors, ActorPhaseConst.POST);
+    }
+    cb(result); 
+  }
+  
+  _calculateIndices() {
+    this.preActors.actors.forEach((actor) => {
+      this.nodes.push({
+        actor: actor,
+        name: actor.logName,
+        phaseId: ActorPhaseConst.PRE,
+        typeId: actor.typeId,
+        index: -1,
+        columnIndex: -1
+      });
+    });
+    this.execActors.actors.forEach((actor) => {
+      this.nodes.push({
+        actor: actor,
+        name: actor.logName,
+        phaseId: ActorPhaseConst.EXEC,
+        typeId: actor.typeId,
+        index: -1,
+        columnIndex: -1
+      });
+    });
+    if(0 !== this.executionContext.stageData.stagedSutNodes.length) {
+      this.executionContext.stageData.stagedSutNodes.forEach((stagedSutNode) => {
+        this.nodes.push({
+          name: stagedSutNode.name,
+          phaseId: ActorPhaseConst.EXEC,
+          typeId: ActorTypeConst.REAL_SUT,
+          index: -1,
+          columnIndex: -1,
+          criteriaType: stagedSutNode.criteriaType,
+          criteria: stagedSutNode.criteria
+        });
+      });
+    }
+    else {
+      this.nodes.push({
+        name: this.executionContext.stageData.stagedSut,
+        phaseId: ActorPhaseConst.EXEC,
+        typeId: ActorTypeConst.REAL_SUT,
+        index: -1,
+        columnIndex: -1
+      });
+    }
+    this.postActors.actors.forEach((actor) => {
+      this.nodes.push({
+        actor: actor,
+        name: actor.logName,
+        phaseId: ActorPhaseConst.POST,
+        typeId: actor.typeId,
+        index: -1,
+        columnIndex: -1
+      });
+    });
+    this._sortActors(this.nodes);
+    let orderIndex = 0;
+    let columnIndex = 0;
+    this.nodes.forEach((node, index) => {
+      if(ActorTypeConst.REAL_SUT !== node.typeId) {
+        node.actor.setIndex(index);
+        node.actor.setOrderIndex(orderIndex++);
+        this.actors.push(node.actor);
+      }
+      node.index = index;
+    });
+    this.nodes = this.nodes.filter((node) => {
+      return !(ActorTypeConst.COND === node.typeId && ActorPhaseConst.POST === node.phaseId);
+    });
+    this.nodes.forEach((node, index) => {
+      node.columnIndex = index;
+      if(ActorTypeConst.REAL_SUT !== node.typeId) {
+        node.actor.setColumnIndex(index);
+      }
+    });
+    this.preActors.setIndex();
+    this.execActors.setIndex();
+    this.postActors.setIndex();
+  }
+  
+  _calculatDependencies(actors, phaseId) {
+    let previusActors = [];
+    actors.forEach((actor) => {
+      if(0 === previusActors.length) {
+        actor.setDependency(-1, phaseId);
+      }
+      else {
+        if('serial' === actor.getSequence()) {
+          this._dependOnPrevious(previusActors, actor, phaseId);
+        }
+        else if('parallel' === actor.getSequence()) {
+          this._dependOnPreviousDependencies(previusActors, actor, phaseId);
+        }
+      }
+      previusActors.push(actor);
+    });
+  }
+  
+  _dependOnPrevious(previusActors, actor, phaseId) {
+    let index = -1;
+    for(let i = previusActors.length - 1; i >= 0; --i) {
+      index = previusActors[i].getIndexFromPhase(phaseId);
+      break;
+   }
+   actor.setDependency(index, phaseId);
+  }
+  
+  _dependOnPreviousDependencies(previusActors, actor, phaseId) {
+    let indices = [-1];
+    for(let i = previusActors.length - 1; i >= 0; --i) {
+      indices = previusActors[i].getDependenciesFromPhase(phaseId);
+      break;
+    }
+    indices.forEach((index) => {
+      actor.setDependency(index, phaseId);
+    });
+  }
+  
+  _addActor(actor) {
+    if(ActorTypeConst.COND === actor.typeId) {
+      this.preActors.add(actor);
+      this.postActors.addFront(actor);
+    }
+    else {
+      switch(actor.phaseId) {
+        case ActorPhaseConst.PRE:
+          this.preActors.add(actor);
+          break;
+        case ActorPhaseConst.EXEC:
+          this.execActors.add(actor);
+          break;
+        case ActorPhaseConst.POST:
+          this.postActors.add(actor);
+          break;
+      }      
+    }
+  }
+  
+  _compareActors(a, b) {
+    if(a < b) {
+      return -1;
+    }
+    else if(b < a) {
+      return 1;
+    }
+    else {
+      return 0;
+    }
+  }
+  
+  _sortActors(actors) {
+    actors.sort((a, b) => {
+      const phase = this._compareActors(a.phaseId, b.phaseId);
+      if(0 !== phase) {
+        return phase;
+      }
+      else if(ActorPhaseConst.EXEC === a.phaseId) {
+        const result = this._compareActors(a.typeId, b.typeId);
+        return result;
+      }
+      else {
+        return 0;
+      }
+    });
+  }
+  
+  _loadFromFile(actorData) {
+    let actorFactory = this.actorFactories.get(actorData.name);
+    if(!actorFactory) {
+      const path = actorData.name.split('.');
+      const file = `${ActorPathDist.getActorFile(path.join(Path.sep))}.js`;
+      actorFactory = require(file);
+      this.actorFactories.set(actorData.name, actorFactory);
+    }
+    try {
+      return new actorFactory();
+    }
+    catch(err) {
+      LOG_ERROR(Logger.ERROR.CATCH, `Could not create the Actor: '${actorData.name}'. File: '${file}'`, err, err.stack);
+    }
+    return null;
+  }
+  
+  _loadFromString(actorData) {
+    let actorFactory = this.actorFactories.get(actorData.name);
+    if(!actorFactory) {
+      const path = actorData.name.split('.');
+      const fileName = `${ActorPathDist.getActorFile(path.join(Path.sep))}.js`;
+      const paths = Module._nodeModulePaths(Path.dirname(''));
+      const parent = module.parent;
+  	  const m = new Module('', parent);
+      m.filename = fileName;
+  	  m.paths = [].concat([]).concat(paths).concat([]);
+      const code = actorData.inlineCode.replace(Actors.replaceCondition, (...parameters) => {
+        const match = parameters.shift();
+        return Actors.replaceHandle(match, parameters);
+      });
+  	  m._compile(code, m.filename);
+  	  const actorFactory = m.exports;
+      this.actorFactories.set(actorData.name, actorFactory);
+  	  parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
+    }
+	  return new actorFactory();
+  }
+}
+
+
+module.exports = Actors;

package/project/server/engine/data/content-audio.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentAudio extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.size = contentData.size;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentAudio;