bpmn-elements 6.0.1 → 8.0.1

package/dist/src/definition/DefinitionExecution.js

@@ -5,507 +5,809 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = DefinitionExecution;
 
+var _getPropertyValue = _interopRequireDefault(require("../getPropertyValue"));
+
 var _Api = require("../Api");
 
-var _messageHelper = require("../messageHelper");
+var _shared = require("../shared");
 
-var _getPropertyValue = _interopRequireDefault(require("../getPropertyValue"));
+var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function DefinitionExecution(definition) {
-  const {
-    id,
-    type,
-    broker,
-    logger,
-    environment
-  } = definition;
-  const processes = definition.getProcesses();
-  const processIds = processes.map(({
-    id: childId
-  }) => childId);
-  let executableProcesses = definition.getExecutableProcesses();
-  const postponed = [];
+const kActivated = Symbol.for('activated');
+const kProcessesQ = Symbol.for('processesQ');
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kParent = Symbol.for('definition');
+const kProcesses = Symbol.for('processes');
+const kStatus = Symbol.for('status');
+const kStopped = Symbol.for('stopped');
+
+function DefinitionExecution(definition, context) {
+  const broker = definition.broker;
+  this[kParent] = definition;
+  this.id = definition.id;
+  this.type = definition.type;
+  this.broker = broker;
+  const environment = this.environment = definition.environment;
+  this.context = context;
+  const processes = context.getProcesses();
+  const ids = [];
+  const executable = [];
+
+  for (const bp of processes) {
+    bp.environment.assignVariables(environment.variables);
+    bp.environment.assignSettings(environment.settings);
+    ids.push(bp.id);
+    if (bp.isExecutable) executable.push(bp);
+  }
+
+  this[kProcesses] = {
+    processes,
+    running: [],
+    ids,
+    executable,
+    postponed: []
+  };
   broker.assertExchange('execution', 'topic', {
     autoDelete: false,
     durable: true
   });
-  let activityQ,
-      status = 'init',
-      executionId,
-      stopped,
-      activated,
-      initMessage,
-      completed = false;
-  const definitionExecution = {
-    id,
-    type,
-    broker,
+  this.executionId = undefined;
+  this[kCompleted] = false;
+  this[kStopped] = false;
+  this[kActivated] = false;
+  this[kStatus] = 'init';
+  this[kProcessesQ] = undefined;
+  this[kMessageHandlers] = {
+    onApiMessage: this._onApiMessage.bind(this),
+    onCallActivity: this._onCallActivity.bind(this),
+    onCancelCallActivity: this._onCancelCallActivity.bind(this),
+    onChildEvent: this._onChildEvent.bind(this),
+    onDelegateMessage: this._onDelegateMessage.bind(this),
+    onMessageOutbound: this._onMessageOutbound.bind(this),
+    onProcessMessage: this._onProcessMessage.bind(this)
+  };
+}
 
-    get environment() {
-      return environment;
-    },
+const proto = DefinitionExecution.prototype;
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
 
-    get executionId() {
-      return executionId;
-    },
+  get() {
+    return this[kStopped];
+  }
 
-    get completed() {
-      return completed;
-    },
+});
+Object.defineProperty(proto, 'completed', {
+  enumerable: true,
 
-    get status() {
-      return status;
-    },
+  get() {
+    return this[kCompleted];
+  }
 
-    get stopped() {
-      return stopped;
-    },
+});
+Object.defineProperty(proto, 'status', {
+  enumerable: true,
 
-    get postponedCount() {
-      return postponed.length;
-    },
+  get() {
+    return this[kStatus];
+  }
 
-    get isRunning() {
-      if (activated) return true;
-      return false;
-    },
+});
+Object.defineProperty(proto, 'processes', {
+  enumerable: true,
 
-    processes,
-    createMessage,
-    getApi,
-    getState,
-    getPostponed,
-    execute,
-    resume,
-    recover,
-    stop
-  };
-  return definitionExecution;
-
-  function execute(executeMessage) {
-    if (!executeMessage) throw new Error('Definition execution requires message');
-    const {
-      content,
-      fields
-    } = executeMessage;
-    if (!content || !content.executionId) throw new Error('Definition execution requires execution id');
-    const isRedelivered = fields.redelivered;
-    executionId = content.executionId;
-    initMessage = (0, _messageHelper.cloneMessage)(executeMessage, {
-      executionId,
-      state: 'start'
-    });
-    stopped = false;
-    activityQ = broker.assertQueue(`execute-${executionId}-q`, {
-      durable: true,
-      autoDelete: false
-    });
+  get() {
+    return this[kProcesses].running;
+  }
 
-    if (isRedelivered) {
-      return resume();
-    }
+});
+Object.defineProperty(proto, 'postponedCount', {
+  get() {
+    return this[kProcesses].postponed.length;
+  }
 
-    if (content.processId) {
-      const startWithProcess = definition.getProcessById(content.processId);
-      if (startWithProcess) executableProcesses = [startWithProcess];
-    }
+});
+Object.defineProperty(proto, 'isRunning', {
+  get() {
+    return this[kActivated];
+  }
 
-    logger.debug(`<${executionId} (${id})> execute definition`);
-    activate();
-    start();
-    return true;
+});
+
+proto.execute = function execute(executeMessage) {
+  if (!executeMessage) throw new Error('Definition execution requires message');
+  const content = executeMessage.content;
+  const executionId = this.executionId = content.executionId;
+  if (!executionId) throw new Error('Definition execution requires execution id');
+  this[kExecuteMessage] = (0, _messageHelper.cloneMessage)(executeMessage, {
+    executionId,
+    state: 'start'
+  });
+  this[kStopped] = false;
+  this[kProcessesQ] = this.broker.assertQueue(`execute-${executionId}-q`, {
+    durable: true,
+    autoDelete: false
+  });
+
+  if (executeMessage.fields.redelivered) {
+    return this.resume();
   }
 
-  function resume() {
-    logger.debug(`<${executionId} (${id})> resume`, status, 'definition execution');
-    if (completed) return complete('completed');
-    activate();
-    postponed.splice(0);
-    activityQ.consume(onProcessMessage, {
-      prefetch: 1000,
-      consumerTag: `_definition-activity-${executionId}`
-    });
-    if (completed) return complete('completed');
+  const {
+    running,
+    executable
+  } = this[kProcesses];
 
-    switch (status) {
-      case 'init':
-        return start();
+  if (content.processId) {
+    const startWithProcess = this.getProcessById(content.processId);
 
-      case 'executing':
-        {
-          if (!postponed.length) return complete('completed');
-          break;
-        }
+    if (startWithProcess) {
+      executable.splice(0);
+      executable.push(startWithProcess);
     }
-
-    processes.forEach(p => p.resume());
   }
 
-  function start() {
-    if (!processes.length) {
-      return publishCompletionMessage('completed');
-    }
+  this._debug('execute definition');
+
+  running.push(...executable);
+
+  this._activate(executable);
 
-    if (!executableProcesses.length) {
-      return complete('error', {
-        error: new Error('No executable process')
-      });
+  this._start();
+
+  return true;
+};
+
+proto.resume = function resume() {
+  this._debug(`resume ${this[kStatus]} definition execution`);
+
+  if (this[kCompleted]) return this._complete('completed');
+  const {
+    running,
+    postponed
+  } = this[kProcesses];
+
+  this._activate(running);
+
+  postponed.splice(0);
+  this[kProcessesQ].consume(this[kMessageHandlers].onProcessMessage, {
+    prefetch: 1000,
+    consumerTag: `_definition-activity-${this.executionId}`
+  });
+  if (this[kCompleted]) return;
+
+  for (const bp of running) bp.resume();
+};
+
+proto.recover = function recover(state) {
+  if (!state) return this;
+  this.executionId = state.executionId;
+  this[kStopped] = state.stopped;
+  this[kCompleted] = state.completed;
+  this[kStatus] = state.status;
+
+  this._debug(`recover ${this[kStatus]} definition execution`);
+
+  const running = this[kProcesses].running;
+  running.splice(0);
+  const ids = [];
+
+  for (const bpState of state.processes) {
+    const bpid = bpState.id;
+    let bp;
+
+    if (ids.indexOf(bpid) > -1) {
+      bp = this.context.getNewProcessById(bpid);
+    } else {
+      bp = this.getProcessById(bpid);
     }
 
-    status = 'start';
-    executableProcesses.forEach(p => p.init());
-    executableProcesses.forEach(p => p.run());
-    postponed.splice(0);
-    activityQ.assertConsumer(onProcessMessage, {
-      prefetch: 1000,
-      consumerTag: `_definition-activity-${executionId}`
-    });
+    if (!bp) return;
+    ids.push(bpid);
+    bp.recover(bpState);
+    running.push(bp);
   }
 
-  function recover(state) {
-    if (!state) return definitionExecution;
-    executionId = state.executionId;
-    stopped = state.stopped;
-    completed = state.completed;
-    status = state.status;
-    logger.debug(`<${executionId} (${id})> recover`, status, 'definition execution');
-    state.processes.forEach(processState => {
-      const instance = definition.getProcessById(processState.id);
-      if (!instance) return;
-      instance.recover(processState);
-    });
-    return definitionExecution;
+  return this;
+};
+
+proto.stop = function stop() {
+  this.getApi().stop();
+};
+
+proto.getProcesses = function getProcesses() {
+  const {
+    running,
+    processes
+  } = this[kProcesses];
+  const result = running.slice();
+
+  for (const bp of processes) {
+    if (!result.find(runningBp => bp.id === runningBp.id)) result.push(bp);
   }
 
-  function stop() {
-    getApi().stop();
+  return result;
+};
+
+proto.getProcessById = function getProcessById(processId) {
+  return this.getProcesses().find(bp => bp.id === processId);
+};
+
+proto.getProcessesById = function getProcessesById(processId) {
+  return this.getProcesses().filter(bp => bp.id === processId);
+};
+
+proto.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
+  const running = this[kProcesses].running;
+  return running.find(bp => bp.executionId === processExecutionId);
+};
+
+proto.getRunningProcesses = function getRunningProcesses() {
+  const running = this[kProcesses].running;
+  return running.filter(bp => bp.executionId);
+};
+
+proto.getExecutableProcesses = function getExecutableProcesses() {
+  return this[kProcesses].executable.slice();
+};
+
+proto.getState = function getState() {
+  return {
+    executionId: this.executionId,
+    stopped: this[kStopped],
+    completed: this[kCompleted],
+    status: this[kStatus],
+    processes: this[kProcesses].running.map(bp => bp.getState())
+  };
+};
+
+proto.getApi = function getApi(apiMessage) {
+  if (!apiMessage) apiMessage = this[kExecuteMessage] || {
+    content: this._createMessage()
+  };
+  const content = apiMessage.content;
+
+  if (content.executionId !== this.executionId) {
+    return this._getProcessApi(apiMessage);
   }
 
-  function activate() {
-    broker.subscribeTmp('api', '#', onApiMessage, {
-      noAck: true,
-      consumerTag: '_definition-api-consumer'
-    });
-    processes.forEach(p => {
-      p.broker.subscribeTmp('message', 'message.outbound', onMessageOutbound, {
-        noAck: true,
-        consumerTag: '_definition-outbound-message-consumer'
-      });
-      p.broker.subscribeTmp('event', 'activity.signal', onDelegateMessage, {
-        noAck: true,
-        consumerTag: '_definition-signal-consumer',
-        priority: 200
-      });
-      p.broker.subscribeTmp('event', 'activity.message', onDelegateMessage, {
-        noAck: true,
-        consumerTag: '_definition-message-consumer',
-        priority: 200
-      });
-      p.broker.subscribeTmp('event', '#', onEvent, {
-        noAck: true,
-        consumerTag: '_definition-activity-consumer',
-        priority: 100
-      });
-    });
-    activated = true;
-
-    function onEvent(routingKey, originalMessage) {
-      const message = (0, _messageHelper.cloneMessage)(originalMessage);
-      const content = message.content;
-      const parent = content.parent = content.parent || {};
-      const isDirectChild = processIds.indexOf(content.id) > -1;
-
-      if (isDirectChild) {
-        parent.executionId = executionId;
-      } else {
-        content.parent = (0, _messageHelper.pushParent)(parent, {
-          id,
-          type,
-          executionId
-        });
-      }
+  const api = (0, _Api.DefinitionApi)(this.broker, apiMessage);
+  const postponed = this[kProcesses].postponed;
+  const self = this;
 
-      broker.publish('event', routingKey, content, { ...message.properties,
-        mandatory: false
-      });
-      if (!isDirectChild) return;
-      activityQ.queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), message.properties);
-    }
+  api.getExecuting = function getExecuting() {
+    return postponed.reduce((result, msg) => {
+      const bpApi = self._getProcessApi(msg);
+
+      if (bpApi) result.push(bpApi);
+      return result;
+    }, []);
+  };
+
+  return api;
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  const running = this[kProcesses].running;
+  return running.reduce((result, p) => {
+    result = result.concat(p.getPostponed(...args));
+    return result;
+  }, []);
+};
+
+proto._start = function start() {
+  const {
+    ids,
+    executable,
+    postponed
+  } = this[kProcesses];
+
+  if (!ids.length) {
+    return this._complete('completed');
   }
 
-  function deactivate() {
-    broker.cancel('_definition-api-consumer');
-    broker.cancel(`_definition-activity-${executionId}`);
-    processes.forEach(p => {
-      p.broker.cancel('_definition-outbound-message-consumer');
-      p.broker.cancel('_definition-activity-consumer');
-      p.broker.cancel('_definition-signal-consumer');
-      p.broker.cancel('_definition-message-consumer');
+  if (!executable.length) {
+    return this._complete('error', {
+      error: new Error('No executable process')
     });
-    activated = false;
   }
 
-  function onProcessMessage(routingKey, message) {
-    const content = message.content;
-    const isRedelivered = message.fields.redelivered;
-    const {
-      id: childId,
-      type: activityType,
-      executionId: childExecutionId
-    } = content;
-    if (isRedelivered && message.properties.persistent === false) return;
-
-    switch (routingKey) {
-      case 'execution.stop':
-        {
-          if (childExecutionId === executionId) {
-            message.ack();
-            return onStopped();
-          }
+  this[kStatus] = 'start';
 
-          break;
-        }
+  for (const bp of executable) bp.init();
 
-      case 'process.leave':
-        {
-          return onChildCompleted();
-        }
-    }
-
-    stateChangeMessage(true);
+  for (const bp of executable) bp.run();
 
-    switch (routingKey) {
-      case 'process.discard':
-      case 'process.enter':
-        status = 'executing';
-        break;
+  postponed.splice(0);
+  this[kProcessesQ].assertConsumer(this[kMessageHandlers].onProcessMessage, {
+    prefetch: 1000,
+    consumerTag: `_definition-activity-${this.executionId}`
+  });
+};
 
-      case 'process.error':
-        {
-          processes.slice().forEach(p => {
-            if (p.id !== childId) p.stop();
-          });
-          complete('error', {
-            error: content.error
-          });
-          break;
-        }
-    }
+proto._activate = function activate(processList) {
+  this.broker.subscribeTmp('api', '#', this[kMessageHandlers].onApiMessage, {
+    noAck: true,
+    consumerTag: '_definition-api-consumer'
+  });
 
-    function stateChangeMessage(postponeMessage = true) {
-      const previousMsg = popPostponed(childId);
-      if (previousMsg) previousMsg.ack();
-      if (postponeMessage) postponed.push(message);
-    }
+  for (const bp of processList) this._activateProcess(bp);
 
-    function popPostponed(postponedId) {
-      const idx = postponed.findIndex(msg => msg.content.id === postponedId);
+  this[kActivated] = true;
+};
 
-      if (idx > -1) {
-        return postponed.splice(idx, 1)[0];
-      }
-    }
-
-    function onChildCompleted() {
-      stateChangeMessage(false);
-      if (isRedelivered) return message.ack();
-      logger.debug(`<${executionId} (${id})> left <${childId}> (${activityType}), pending runs ${postponed.length}`);
+proto._activateProcess = function activateProcess(bp) {
+  const handlers = this[kMessageHandlers];
+  bp.broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
+    noAck: true,
+    consumerTag: '_definition-outbound-message-consumer'
+  });
+  bp.broker.subscribeTmp('event', 'activity.signal', handlers.onDelegateMessage, {
+    noAck: true,
+    consumerTag: '_definition-signal-consumer',
+    priority: 200
+  });
+  bp.broker.subscribeTmp('event', 'activity.message', handlers.onDelegateMessage, {
+    noAck: true,
+    consumerTag: '_definition-message-consumer',
+    priority: 200
+  });
+  bp.broker.subscribeTmp('event', 'activity.call', handlers.onCallActivity, {
+    noAck: true,
+    consumerTag: '_definition-call-consumer',
+    priority: 200
+  });
+  bp.broker.subscribeTmp('event', 'activity.call.cancel', handlers.onCancelCallActivity, {
+    noAck: true,
+    consumerTag: '_definition-call-cancel-consumer',
+    priority: 200
+  });
+  bp.broker.subscribeTmp('event', '#', handlers.onChildEvent, {
+    noAck: true,
+    consumerTag: '_definition-activity-consumer',
+    priority: 100
+  });
+};
+
+proto._onChildEvent = function onChildEvent(routingKey, originalMessage) {
+  const message = (0, _messageHelper.cloneMessage)(originalMessage);
+  const content = message.content;
+  const parent = content.parent = content.parent || {};
+  const isDirectChild = this[kProcesses].ids.indexOf(content.id) > -1;
+
+  if (isDirectChild) {
+    parent.executionId = this.executionId;
+  } else {
+    content.parent = (0, _messageHelper.pushParent)(parent, this);
+  }
 
-      if (!postponed.length) {
+  this.broker.publish('event', routingKey, content, { ...message.properties,
+    mandatory: false
+  });
+  if (!isDirectChild) return;
+  this[kProcessesQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), message.properties);
+};
+
+proto._deactivate = function deactivate() {
+  this.broker.cancel('_definition-api-consumer');
+  this.broker.cancel(`_definition-activity-${this.executionId}`);
+
+  for (const bp of this[kProcesses].running) this._deactivateProcess(bp);
+
+  this[kActivated] = false;
+};
+
+proto._deactivateProcess = function deactivateProcess(bp) {
+  bp.broker.cancel('_definition-outbound-message-consumer');
+  bp.broker.cancel('_definition-activity-consumer');
+  bp.broker.cancel('_definition-signal-consumer');
+  bp.broker.cancel('_definition-message-consumer');
+  bp.broker.cancel('_definition-call-consumer');
+  bp.broker.cancel('_definition-call-cancel-consumer');
+};
+
+proto._onProcessMessage = function onProcessMessage(routingKey, message) {
+  const content = message.content;
+  const isRedelivered = message.fields.redelivered;
+  const {
+    id: childId,
+    inbound
+  } = content;
+  if (isRedelivered && message.properties.persistent === false) return;
+
+  switch (routingKey) {
+    case 'execution.stop':
+      {
         message.ack();
-        complete('completed');
+        return this._onStopped(message);
       }
-    }
 
-    function onStopped() {
-      logger.debug(`<${executionId} (${id})> stop definition execution (stop process executions ${postponed.length})`);
-      activityQ.close();
-      deactivate();
-      processes.slice().forEach(p => {
-        p.stop();
-      });
-      stopped = true;
-      return broker.publish('execution', `execution.stopped.${executionId}`, { ...initMessage.content,
-        ...content
-      }, {
-        type: 'stopped',
-        persistent: false
-      });
-    }
+    case 'process.leave':
+      {
+        return this._onProcessCompleted(message);
+      }
   }
 
-  function onApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
-    const delegate = message.properties.delegate;
+  this._stateChangeMessage(message, true);
 
-    if (delegate && id === message.content.id) {
-      const referenceId = (0, _getPropertyValue.default)(message, 'content.message.id');
+  switch (routingKey) {
+    case 'process.enter':
+      this[kStatus] = 'executing';
+      break;
 
-      for (const bp of processes) {
-        if (bp.isRunning) continue;
+    case 'process.discarded':
+      {
+        if (inbound && inbound.length) {
+          const calledFrom = inbound[0];
 
-        if (bp.getStartActivities({
-          referenceId,
-          referenceType: messageType
-        }).length) {
-          logger.debug(`<${executionId} (${id})> start <${bp.id}>`);
-          bp.run();
+          this._getProcessApi({
+            content: calledFrom
+          }).cancel({
+            executionId: calledFrom.executionId
+          });
         }
+
+        break;
       }
-    }
 
-    if (delegate) {
-      for (const bp of processes) {
-        bp.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
+    case 'process.end':
+      {
+        if (inbound && inbound.length) {
+          const calledFrom = inbound[0];
+
+          this._getProcessApi({
+            content: calledFrom
+          }).signal({
+            executionId: calledFrom.executionId,
+            output: { ...content.output
+            }
+          });
+        } else {
+          Object.assign(this.environment.output, content.output);
+        }
+
+        break;
       }
-    }
 
-    if (executionId !== message.content.executionId) return;
+    case 'process.error':
+      {
+        if (inbound && inbound.length) {
+          const calledFrom = inbound[0];
+
+          this._getProcessApi({
+            content: calledFrom
+          }).sendApiMessage('error', {
+            executionId: calledFrom.executionId,
+            error: content.error
+          }, {
+            mandatory: true,
+            type: 'error'
+          });
+        } else {
+          for (const bp of this[kProcesses].running.slice()) {
+            if (bp.id !== childId) bp.stop();
+          }
+
+          this._complete('error', {
+            error: content.error
+          });
+        }
 
-    switch (messageType) {
-      case 'stop':
-        activityQ.queueMessage({
-          routingKey: 'execution.stop'
-        }, (0, _messageHelper.cloneContent)(message.content), {
-          persistent: false
-        });
         break;
-    }
+      }
   }
+};
 
-  function getState() {
-    return {
-      executionId,
-      stopped,
-      completed,
-      status,
-      processes: processes.map(p => p.getState())
-    };
-  }
+proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
+  let previousMsg;
+  const postponed = this[kProcesses].postponed;
+  const idx = postponed.findIndex(msg => msg.content.executionId === message.content.executionId);
 
-  function getPostponed(...args) {
-    return processes.reduce((result, p) => {
-      result = result.concat(p.getPostponed(...args));
-      return result;
-    }, []);
+  if (idx > -1) {
+    previousMsg = postponed.splice(idx, 1)[0];
   }
 
-  function complete(completionType, content, options) {
-    deactivate();
-    logger.debug(`<${executionId} (${id})> definition execution ${completionType} in ${Date.now() - initMessage.properties.timestamp}ms`);
-    if (!content) content = createMessage();
-    completed = true;
-    if (status !== 'terminated') status = completionType;
-    broker.deleteQueue(activityQ.name);
-    return broker.publish('execution', `execution.${completionType}.${executionId}`, { ...initMessage.content,
-      output: environment.output,
-      ...content,
-      state: completionType
-    }, {
-      type: completionType,
-      mandatory: completionType === 'error',
-      ...options
-    });
+  if (previousMsg) previousMsg.ack();
+  if (postponeMessage) postponed.push(message);
+};
+
+proto._onProcessCompleted = function onProcessCompleted(message) {
+  this._stateChangeMessage(message, false);
+
+  if (message.fields.redelivered) return message.ack();
+  const {
+    id,
+    executionId,
+    type,
+    inbound
+  } = message.content;
+
+  this._debug(`left <${executionId} (${id})> (${type}), pending runs ${this.postponedCount}`);
+
+  if (inbound && inbound.length) {
+    const bp = this._removeProcessByExecutionId(executionId);
+
+    this._deactivateProcess(bp);
   }
 
-  function onMessageOutbound(routingKey, message) {
-    const content = message.content;
-    const {
-      target,
-      source
-    } = content;
-    logger.debug(`<${executionId} (${id})> conveying message from <${source.processId}.${source.id}> to`, target.id ? `<${target.processId}.${target.id}>` : `<${target.processId}>`);
-    const targetProcess = getProcessById(target.processId);
-    targetProcess.sendMessage(message);
+  if (!this.postponedCount) {
+    message.ack();
+
+    this._complete('completed');
   }
+};
 
-  function onDelegateMessage(routingKey, executeMessage) {
-    const content = executeMessage.content;
-    const messageType = executeMessage.properties.type;
-    const delegateMessage = executeMessage.content.message;
-    const reference = definition.getElementById(delegateMessage.id);
-    const message = reference && reference.resolve(executeMessage);
-    logger.debug(`<${executionId} (${id})>`, reference ? `${messageType} <${delegateMessage.id}>` : `anonymous ${messageType}`, `event received from <${content.parent.id}.${content.id}>. Delegating.`);
-    getApi().sendApiMessage(messageType, {
-      message: message,
-      originalMessage: content.message
-    }, {
-      delegate: true,
-      type: messageType
-    });
-    broker.publish('event', `definition.${messageType}`, createMessage({
-      message: message && (0, _messageHelper.cloneContent)(message)
-    }), {
-      type: messageType
+proto._onStopped = function onStopped(message) {
+  const running = this[kProcesses].running;
+
+  this._debug(`stop definition execution (stop process executions ${running.length})`);
+
+  this[kProcessesQ].close();
+
+  for (const bp of running.slice()) bp.stop();
+
+  this._deactivate();
+
+  this[kStopped] = true;
+  return this.broker.publish('execution', `execution.stopped.${this.executionId}`, (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, { ...message.content
+  }), {
+    type: 'stopped',
+    persistent: false
+  });
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+  const delegate = message.properties.delegate;
+
+  if (delegate && this.id === message.content.id) {
+    const referenceId = (0, _getPropertyValue.default)(message, 'content.message.id');
+
+    this._startProcessesByMessage({
+      referenceId,
+      referenceType: messageType
     });
   }
 
-  function getProcessById(processId) {
-    return processes.find(p => p.id === processId);
+  if (delegate) {
+    for (const bp of this[kProcesses].running.slice()) {
+      bp.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
+    }
   }
 
-  function publishCompletionMessage(completionType, content) {
-    deactivate();
-    logger.debug(`<${executionId} (${id})> ${completionType}`);
-    if (!content) content = createMessage();
-    return broker.publish('execution', `execution.${completionType}.${executionId}`, content, {
-      type: completionType
+  if (this.executionId !== message.content.executionId) return;
+
+  if (messageType === 'stop') {
+    this[kProcessesQ].queueMessage({
+      routingKey: 'execution.stop'
+    }, (0, _messageHelper.cloneContent)(message.content), {
+      persistent: false
     });
   }
+};
 
-  function createMessage(content = {}) {
-    return {
-      id,
-      type,
-      executionId,
-      status,
-      ...content
-    };
-  }
+proto._startProcessesByMessage = function startProcessesByMessage(reference) {
+  const {
+    processes: bps,
+    running
+  } = this[kProcesses];
+  if (bps.length < 2) return;
+
+  for (const bp of bps) {
+    if (bp.isExecutable) continue;
+    if (!bp.getStartActivities(reference).length) continue;
 
-  function getApi(apiMessage) {
-    if (!apiMessage) apiMessage = initMessage || {
-      content: createMessage()
-    };
-    const content = apiMessage.content;
+    if (!bp.executionId) {
+      this._debug(`start <${bp.id}> by <${reference.referenceId}> (${reference.referenceType})`);
 
-    if (content.executionId !== executionId) {
-      return getProcessApi(apiMessage);
+      this._activateProcess(bp);
+
+      running.push(bp);
+      bp.init();
+      bp.run();
+      if (reference.referenceType === 'message') return;
+      continue;
     }
 
-    const api = (0, _Api.DefinitionApi)(broker, apiMessage);
+    this._debug(`start new <${bp.id}> by <${reference.referenceId}> (${reference.referenceType})`);
+
+    const targetProcess = this.context.getNewProcessById(bp.id);
 
-    api.getExecuting = function getExecuting() {
-      return postponed.reduce((result, msg) => {
-        if (msg.content.executionId === content.executionId) return result;
-        result.push(getApi(msg));
-        return result;
-      }, []);
-    };
+    this._activateProcess(targetProcess);
 
-    return api;
+    running.push(targetProcess);
+    targetProcess.init();
+    targetProcess.run();
+    if (reference.referenceType === 'message') return;
   }
+};
 
-  function getProcessApi(message) {
-    const content = message.content;
-    let api = getApiByProcessId(content.id);
-    if (api) return api;
-    if (!content.parent) return;
-    api = getApiByProcessId(content.parent.id);
-    if (api) return api;
-    if (!content.parent.path) return;
+proto._onMessageOutbound = function onMessageOutbound(routingKey, message) {
+  const content = message.content;
+  const {
+    target,
+    source
+  } = content;
+
+  this._debug(`conveying message from <${source.processId}.${source.id}> to`, target.id ? `<${target.processId}.${target.id}>` : `<${target.processId}>`);
 
-    for (let i = 0; i < content.parent.path.length; i++) {
-      api = getApiByProcessId(content.parent.path[i].id);
-      if (api) return api;
+  const targetProcesses = this.getProcessesById(target.processId);
+  if (!targetProcesses.length) return;
+  let targetProcess, found;
+
+  for (const bp of targetProcesses) {
+    if (!bp.executionId) {
+      targetProcess = bp;
+      continue;
     }
 
-    function getApiByProcessId(parentId) {
-      const processInstance = getProcessById(parentId);
-      if (!processInstance) return;
-      return processInstance.getApi(message);
+    bp.sendMessage(message);
+    found = true;
+  }
+
+  if (found) return;
+  targetProcess = targetProcess || this.context.getNewProcessById(target.processId);
+
+  this._activateProcess(targetProcess);
+
+  this[kProcesses].running.push(targetProcess);
+  targetProcess.init();
+  targetProcess.run();
+  targetProcess.sendMessage(message);
+};
+
+proto._onCallActivity = function onCallActivity(routingKey, message) {
+  const content = message.content;
+  const {
+    calledElement,
+    id: fromId,
+    executionId: fromExecutionId,
+    name: fromName,
+    parent: fromParent
+  } = content;
+  if (!calledElement) return;
+  const bpExecutionId = `${(0, _shared.brokerSafeId)(calledElement)}_${fromExecutionId}`;
+
+  if (content.isRecovered) {
+    if (this.getProcessByExecutionId(bpExecutionId)) return;
+  }
+
+  const targetProcess = this.context.getNewProcessById(calledElement, {
+    settings: {
+      calledFrom: (0, _messageHelper.cloneContent)({
+        id: fromId,
+        name: fromName,
+        executionId: content.executionId,
+        parent: content.parent
+      })
     }
+  });
+  if (!targetProcess) return;
+
+  this._debug(`call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
+
+  this._activateProcess(targetProcess);
+
+  this[kProcesses].running.push(targetProcess);
+  targetProcess.init(bpExecutionId);
+  targetProcess.run({
+    inbound: [(0, _messageHelper.cloneContent)(content)]
+  });
+};
+
+proto._onCancelCallActivity = function onCancelCallActivity(routingKey, message) {
+  const {
+    calledElement,
+    id: fromId,
+    executionId: fromExecutionId,
+    parent: fromParent
+  } = message.content;
+  if (!calledElement) return;
+  const bpExecutionId = `${(0, _shared.brokerSafeId)(calledElement)}_${fromExecutionId}`;
+  const targetProcess = this.getProcessByExecutionId(bpExecutionId);
+  if (!targetProcess) return;
+
+  this._debug(`cancel call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
+
+  targetProcess.getApi().discard();
+};
+
+proto._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage) {
+  const content = executeMessage.content;
+  const messageType = executeMessage.properties.type;
+  const delegateMessage = executeMessage.content.message;
+  const reference = this.context.getActivityById(delegateMessage.id);
+  const message = reference && reference.resolve(executeMessage);
+
+  this._debug(`<${reference ? `${messageType} ${delegateMessage.id}>` : `anonymous ${messageType}`} event received from <${content.parent.id}.${content.id}>. Delegating.`);
+
+  this.getApi().sendApiMessage(messageType, {
+    source: {
+      id: content.id,
+      executionId: content.executionId,
+      type: content.type,
+      parent: (0, _messageHelper.cloneParent)(content.parent)
+    },
+    message,
+    originalMessage: content.message
+  }, {
+    delegate: true,
+    type: messageType
+  });
+  this.broker.publish('event', `definition.${messageType}`, this._createMessage({
+    message: message && (0, _messageHelper.cloneContent)(message)
+  }), {
+    type: messageType
+  });
+};
+
+proto._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
+  const running = this[kProcesses].running;
+  const idx = running.findIndex(p => p.executionId === processExecutionId);
+  if (idx === -1) return;
+  return running.splice(idx, 1)[0];
+};
+
+proto._complete = function complete(completionType, content, options) {
+  this._deactivate();
+
+  const stateMessage = this[kExecuteMessage];
+
+  this._debug(`definition execution ${completionType} in ${Date.now() - stateMessage.properties.timestamp}ms`);
+
+  if (!content) content = this._createMessage();
+  this[kCompleted] = true;
+  this[kStatus] = completionType;
+  this.broker.deleteQueue(this[kProcessesQ].name);
+  return this.broker.publish('execution', `execution.${completionType}.${this.executionId}`, { ...stateMessage.content,
+    output: { ...this.environment.output
+    },
+    ...content,
+    state: completionType
+  }, {
+    type: completionType,
+    mandatory: completionType === 'error',
+    ...options
+  });
+};
+
+proto._createMessage = function createMessage(content = {}) {
+  return {
+    id: this.id,
+    type: this.type,
+    executionId: this.executionId,
+    status: this[kStatus],
+    ...content
+  };
+};
+
+proto._getProcessApi = function getProcessApi(message) {
+  const content = message.content;
+
+  let api = this._getProcessApiByExecutionId(content.executionId, message);
+
+  if (api) return api;
+  if (!content.parent) return;
+  api = this._getProcessApiByExecutionId(content.parent.executionId, message);
+  if (api) return api;
+  if (!content.parent.path) return;
+
+  for (const pp of content.parent.path) {
+    api = this._getProcessApiByExecutionId(pp.executionId, message);
+    if (api) return api;
   }
-}
+};
+
+proto._getProcessApiByExecutionId = function getProcessApiByExecutionId(parentExecutionId, message) {
+  const processInstance = this.getProcessByExecutionId(parentExecutionId);
+  if (!processInstance) return;
+  return processInstance.getApi(message);
+};
+
+proto._debug = function debug(logMessage) {
+  this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
+};