bpmn-elements 6.0.1 → 8.0.1

package/dist/src/definition/Definition.js

@@ -20,79 +20,52 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const kConsuming = Symbol.for('consuming');
+const kCounters = Symbol.for('counters');
+const kExec = Symbol.for('execution');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kStateMessage = Symbol.for('stateMessage');
+const kStatus = Symbol.for('status');
+const kStopped = Symbol.for('stopped');
 var _default = Definition;
 exports.default = _default;
 
 function Definition(context, options) {
+  if (!(this instanceof Definition)) return new Definition(context, options);
   if (!context) throw new Error('No context');
   const {
     id,
     name,
     type = 'definition'
   } = context;
-  let environment = context.environment;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  let environment;
 
   if (options) {
-    environment = environment.clone(options);
-    context = context.clone(environment);
+    environment = this.environment = context.environment.clone(options);
+    this.context = context.clone(environment);
+  } else {
+    environment = this.environment = context.environment;
+    this.context = context;
   }
 
-  const logger = environment.Logger(type.toLowerCase());
-  let execution, executionId, processes, executableProcesses, postponedMessage, stateMessage, stopped, consumingRunQ;
-  let status;
-  let counters = {
+  this[kCounters] = {
     completed: 0,
     discarded: 0
   };
-  const definitionApi = {
-    id,
-    name,
-    type,
-    logger,
-    context,
-
-    get counters() {
-      return { ...counters
-      };
-    },
-
-    get executionId() {
-      return executionId;
-    },
-
-    get status() {
-      return status;
-    },
-
-    get execution() {
-      return execution;
-    },
-
-    get isRunning() {
-      if (!consumingRunQ) return false;
-      return !!status;
-    },
-
-    get environment() {
-      return environment;
-    },
-
-    run,
-    getApi,
-    getState,
-    getActivityById,
-    getElementById,
-    getPostponed,
-    getProcesses,
-    getExecutableProcesses,
-    getProcessById,
-    sendMessage,
-    recover,
-    resume,
-    shake,
-    signal,
-    cancelActivity,
-    stop
+  this[kStopped] = false;
+  this[kExec] = {};
+
+  const onBrokerReturn = this._onBrokerReturnFn.bind(this);
+
+  this[kMessageHandlers] = {
+    onBrokerReturn,
+    onApiMessage: this._onApiMessage.bind(this),
+    onRunMessage: this._onRunMessage.bind(this),
+    onExecutionMessage: this._onExecutionMessage.bind(this)
   };
   const {
     broker,
@@ -101,479 +74,560 @@ function Definition(context, options) {
     waitFor,
     emit,
     emitFatal
-  } = (0, _EventBroker.DefinitionBroker)(definitionApi, onBrokerReturn);
-  definitionApi.on = on;
-  definitionApi.once = once;
-  definitionApi.waitFor = waitFor;
-  definitionApi.emit = emit;
-  definitionApi.emitFatal = emitFatal;
-  const runQ = broker.getQueue('run-q');
-  const executionQ = broker.getQueue('execution-q');
-  Object.defineProperty(definitionApi, 'broker', {
-    enumerable: true,
-    get: () => broker
-  });
-  Object.defineProperty(definitionApi, 'stopped', {
-    enumerable: true,
-    get: () => execution && execution.stopped
-  });
-  return definitionApi;
-
-  function run(optionsOrCallback, optionalCallback) {
-    const [runOptions, callback] = (0, _shared.getOptionsAndCallback)(optionsOrCallback, optionalCallback);
+  } = (0, _EventBroker.DefinitionBroker)(this, onBrokerReturn);
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+  this.emit = emit;
+  this.emitFatal = emitFatal;
+  this.logger = environment.Logger(type.toLowerCase());
+}
+
+const proto = Definition.prototype;
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+
+  get() {
+    return { ...this[kCounters]
+    };
+  }
 
-    if (definitionApi.isRunning) {
-      const err = new Error('definition is already running');
-      if (callback) return callback(err);
-      throw err;
-    }
+});
+Object.defineProperty(proto, 'execution', {
+  enumerable: true,
 
-    addConsumerCallbacks(callback);
-    executionId = (0, _shared.getUniqueId)(id);
-    const content = createMessage({ ...runOptions,
-      executionId
-    });
-    broker.publish('run', 'run.enter', content);
-    broker.publish('run', 'run.start', (0, _messageHelper.cloneContent)(content));
-    broker.publish('run', 'run.execute', (0, _messageHelper.cloneContent)(content));
-    logger.debug(`<${executionId} (${id})> run`);
-    activateRunConsumers();
-    return definitionApi;
+  get() {
+    return this[kExec].execution;
   }
 
-  function resume(callback) {
-    if (definitionApi.isRunning) {
-      const err = new Error('cannot resume running definition');
-      if (callback) return callback(err);
-      throw err;
-    }
+});
+Object.defineProperty(proto, 'executionId', {
+  enumerable: true,
 
-    stopped = false;
-    if (!status) return definitionApi;
-    addConsumerCallbacks(callback);
-    logger.debug(`<${executionId} (${id})> resume`);
-    const content = createMessage({
-      executionId
-    });
-    broker.publish('run', 'run.resume', content, {
-      persistent: false
-    });
-    activateRunConsumers();
-    return definitionApi;
+  get() {
+    return this[kExec].executionId;
   }
 
-  function recover(state) {
-    if (definitionApi.isRunning) throw new Error('cannot recover running definition');
-    if (!state) return definitionApi;
-    stopped = state.stopped;
-    status = state.status;
-    executionId = state.executionId;
-
-    if (state.counters) {
-      counters = { ...counters,
-        ...state.counters
-      };
-    }
+});
+Object.defineProperty(proto, 'isRunning', {
+  enumerable: true,
 
-    environment.recover(state.environment);
+  get() {
+    if (!this[kConsuming]) return false;
+    return !!this.status;
+  }
 
-    if (state.execution) {
-      execution = (0, _DefinitionExecution.default)(definitionApi, context).recover(state.execution);
-    }
+});
+Object.defineProperty(proto, 'status', {
+  enumerable: true,
 
-    broker.recover(state.broker);
-    return definitionApi;
+  get() {
+    return this[kStatus];
   }
 
-  function shake(startId) {
-    let result = {};
-    let bps;
+});
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
 
-    if (startId) {
-      const startActivity = getActivityById(startId);
-      if (!startActivity) return;
-      const bp = getProcessById(startActivity.parent.id);
-      if (!bp) return;
-      bps = [bp];
-    } else bps = getProcesses();
+  get() {
+    return this[kStopped];
+  }
 
-    bps.forEach(shakeProcess);
-    return result;
+});
 
-    function shakeProcess(shakeBp) {
-      let shovel;
+proto.run = function run(optionsOrCallback, optionalCallback) {
+  const [runOptions, callback] = (0, _shared.getOptionsAndCallback)(optionsOrCallback, optionalCallback);
 
-      if (!shakeBp.isRunning) {
-        shovel = shakeBp.broker.createShovel('shaker', {
-          exchange: 'event',
-          pattern: '*.shake#'
-        }, {
-          broker,
-          exchange: 'event'
-        });
-      }
+  if (this.isRunning) {
+    const err = new Error('definition is already running');
+    if (callback) return callback(err);
+    throw err;
+  }
 
-      const shakeResult = shakeBp.shake(startId);
-      if (shovel) shakeBp.broker.closeShovel('shaker');
-      result = { ...result,
-        ...shakeResult
-      };
-    }
+  if (callback) {
+    addConsumerCallbacks(this, callback);
   }
 
-  function activateRunConsumers() {
-    consumingRunQ = true;
-    broker.subscribeTmp('api', `definition.*.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: '_definition-api'
-    });
-    runQ.assertConsumer(onRunMessage, {
-      exclusive: true,
-      consumerTag: '_definition-run'
-    });
+  const exec = this[kExec];
+  exec.executionId = (0, _shared.getUniqueId)(this.id);
+
+  const content = this._createMessage({ ...runOptions
+  });
+
+  const broker = this.broker;
+  broker.publish('run', 'run.enter', content);
+  broker.publish('run', 'run.start', (0, _messageHelper.cloneContent)(content));
+  broker.publish('run', 'run.execute', (0, _messageHelper.cloneContent)(content));
+  this.logger.debug(`<${this.executionId} (${this.id})> run`);
+
+  this._activateRunConsumers();
+
+  return this;
+};
+
+proto.resume = function resume(callback) {
+  if (this.isRunning) {
+    const err = new Error('cannot resume running definition');
+    if (callback) return callback(err);
+    throw err;
   }
 
-  function deactivateRunConsumers() {
-    broker.cancel('_definition-api');
-    broker.cancel('_definition-run');
-    broker.cancel('_definition-execution');
-    consumingRunQ = false;
+  this[kStopped] = false;
+  if (!this.status) return this;
+
+  if (callback) {
+    addConsumerCallbacks(this, callback);
   }
 
-  function stop() {
-    if (!definitionApi.isRunning) return;
-    getApi().stop();
+  this.logger.debug(`<${this.executionId} (${this.id})> resume`);
+
+  const content = this._createMessage();
+
+  this.broker.publish('run', 'run.resume', content, {
+    persistent: false
+  });
+
+  this._activateRunConsumers();
+
+  return this;
+};
+
+proto.recover = function recover(state) {
+  if (this.isRunning) throw new Error('cannot recover running definition');
+  if (!state) return this;
+  this[kStopped] = !!state.stopped;
+  this[kStatus] = state.status;
+  const exec = this[kExec];
+  exec.executionId = state.executionId;
+
+  if (state.counters) {
+    this[kCounters] = { ...this[kCounters],
+      ...state.counters
+    };
   }
 
-  function addConsumerCallbacks(callback) {
-    if (!callback) return;
-    broker.off('return', onBrokerReturn);
-    clearConsumers();
-    broker.subscribeOnce('event', 'definition.stop', cbLeave, {
-      consumerTag: '_definition-callback-stop'
-    });
-    broker.subscribeOnce('event', 'definition.leave', cbLeave, {
-      consumerTag: '_definition-callback-leave'
-    });
-    broker.subscribeOnce('event', 'definition.error', cbError, {
-      consumerTag: '_definition-callback-error'
-    });
-
-    function cbLeave(_, message) {
-      clearConsumers();
-      return callback(null, getApi(message));
-    }
+  this.environment.recover(state.environment);
 
-    function cbError(_, message) {
-      clearConsumers();
-      reset();
-      const err = (0, _Errors.makeErrorFromMessage)(message);
-      return callback(err);
-    }
+  if (state.execution) {
+    exec.execution = new _DefinitionExecution.default(this, this.context).recover(state.execution);
+  }
 
-    function clearConsumers() {
-      broker.cancel('_definition-callback-stop');
-      broker.cancel('_definition-callback-leave');
-      broker.cancel('_definition-callback-error');
-      broker.on('return', onBrokerReturn);
+  this.broker.recover(state.broker);
+  return this;
+};
+
+proto.shake = function shake(startId) {
+  let result = {};
+  const broker = this.broker;
+  let bps;
+
+  if (startId) {
+    const startActivity = this.getActivityById(startId);
+    if (!startActivity) return;
+    const bp = this.getProcessById(startActivity.parent.id);
+    if (!bp) return;
+    bps = [bp];
+  } else bps = this.getProcesses();
+
+  bps.forEach(shakeProcess);
+  return result;
+
+  function shakeProcess(shakeBp) {
+    let shovel;
+
+    if (!shakeBp.isRunning) {
+      shovel = shakeBp.broker.createShovel('shaker', {
+        exchange: 'event',
+        pattern: '*.shake#'
+      }, {
+        broker,
+        exchange: 'event'
+      });
     }
+
+    const shakeResult = shakeBp.shake(startId);
+    if (shovel) shakeBp.broker.closeShovel('shaker');
+    result = { ...result,
+      ...shakeResult
+    };
   }
+};
+
+proto.getState = function getState() {
+  return this._createMessage({
+    status: this.status,
+    stopped: this.stopped,
+    counters: this.counters,
+    environment: this.environment.getState(),
+    execution: this.execution && this.execution.getState(),
+    broker: this.broker.getState(true)
+  });
+};
+
+proto.getProcesses = function getProcesses() {
+  const execution = this.execution;
+  if (execution) return execution.getProcesses();
+  return this.context.getProcesses();
+};
+
+proto.getExecutableProcesses = function getExecutableProcesses() {
+  const execution = this.execution;
+  if (execution) return execution.getExecutableProcesses();
+  return this.context.getExecutableProcesses();
+};
+
+proto.getRunningProcesses = function getRunningProcesses() {
+  const execution = this.execution;
+  if (!execution) return [];
+  return execution.getRunningProcesses();
+};
+
+proto.getProcessById = function getProcessById(processId) {
+  return this.getProcesses().find(p => p.id === processId);
+};
+
+proto.getActivityById = function getActivityById(childId) {
+  const bps = this.getProcesses();
+
+  for (const bp of bps) {
+    const child = bp.getActivityById(childId);
+    if (child) return child;
+  }
+
+  return null;
+};
+
+proto.getElementById = function getElementById(elementId) {
+  return this.context.getActivityById(elementId);
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  const execution = this.execution;
+  if (!execution) return [];
+  return execution.getPostponed(...args);
+};
+
+proto.getApi = function getApi(message) {
+  const execution = this.execution;
+  if (execution) return execution.getApi(message);
+  message = message || this[kStateMessage];
+  if (!message) throw new Error('Definition is not running');
+  return (0, _Api.DefinitionApi)(this.broker, message);
+};
+
+proto.signal = function signal(message) {
+  return this.getApi().signal(message, {
+    delegate: true
+  });
+};
+
+proto.cancelActivity = function cancelActivity(message) {
+  return this.getApi().cancel(message, {
+    delegate: true
+  });
+};
+
+proto.sendMessage = function sendMessage(message) {
+  const messageContent = {
+    message
+  };
+  let messageType = 'message';
+  const reference = message && message.id && this.getElementById(message.id);
 
-  function createMessage(override) {
-    return {
-      id,
-      type,
-      name,
-      ...override
+  if (reference && reference.resolve) {
+    const resolvedReference = reference.resolve(this._createMessage({
+      message
+    }));
+    messageType = resolvedReference.messageType || messageType;
+    messageContent.message = { ...message,
+      ...resolvedReference
     };
   }
 
-  function onBrokerReturn(message) {
-    if (message.properties.type === 'error') {
-      deactivateRunConsumers();
-      const err = (0, _Errors.makeErrorFromMessage)(message);
-      throw err;
-    }
+  return this.getApi().sendApiMessage(messageType, messageContent, {
+    delegate: true
+  });
+};
+
+proto.stop = function stop() {
+  if (!this.isRunning) return;
+  this.getApi().stop();
+};
+
+proto._activateRunConsumers = function activateRunConsumers() {
+  this[kConsuming] = true;
+  const broker = this.broker;
+  const {
+    onApiMessage,
+    onRunMessage
+  } = this[kMessageHandlers];
+  broker.subscribeTmp('api', `definition.*.${this.executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: '_definition-api'
+  });
+  broker.getQueue('run-q').assertConsumer(onRunMessage, {
+    exclusive: true,
+    consumerTag: '_definition-run'
+  });
+};
+
+proto._deactivateRunConsumers = function deactivateRunConsumers() {
+  const broker = this.broker;
+  broker.cancel('_definition-api');
+  broker.cancel('_definition-run');
+  broker.cancel('_definition-execution');
+  this[kConsuming] = false;
+};
+
+proto._createMessage = function createMessage(override) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    executionId: this.executionId,
+    ...override
+  };
+};
+
+proto._onRunMessage = function onRunMessage(routingKey, message) {
+  const {
+    content,
+    fields
+  } = message;
+
+  if (routingKey === 'run.resume') {
+    return this._onResumeMessage(message);
   }
 
-  function onRunMessage(routingKey, message) {
-    const {
-      content,
-      ack,
-      fields
-    } = message;
+  const exec = this[kExec];
+  this[kStateMessage] = message;
 
-    if (routingKey === 'run.resume') {
-      return onResumeMessage();
-    }
+  switch (routingKey) {
+    case 'run.enter':
+      {
+        this.logger.debug(`<${this.executionId} (${this.id})> enter`);
+        this[kStatus] = 'entered';
+        if (fields.redelivered) break;
+        exec.execution = undefined;
 
-    stateMessage = message;
-
-    switch (routingKey) {
-      case 'run.enter':
-        {
-          logger.debug(`<${executionId} (${id})> enter`);
-          status = 'entered';
-          if (fields.redelivered) break;
-          execution = undefined;
-          publishEvent('enter', content);
-          break;
-        }
+        this._publishEvent('enter', content);
 
-      case 'run.start':
-        {
-          logger.debug(`<${executionId} (${id})> start`);
-          status = 'start';
-          publishEvent('start', content);
-          break;
-        }
+        break;
+      }
 
-      case 'run.execute':
-        {
-          status = 'executing';
-          const executeMessage = (0, _messageHelper.cloneMessage)(message);
+    case 'run.start':
+      {
+        this.logger.debug(`<${this.executionId} (${this.id})> start`);
+        this[kStatus] = 'start';
 
-          if (fields.redelivered && !execution) {
-            executeMessage.fields.redelivered = undefined;
-          }
+        this._publishEvent('start', content);
 
-          postponedMessage = message;
-          executionQ.assertConsumer(onExecutionMessage, {
-            exclusive: true,
-            consumerTag: '_definition-execution'
-          });
-          execution = execution || (0, _DefinitionExecution.default)(definitionApi, context);
+        break;
+      }
 
-          if (executeMessage.fields.redelivered) {
-            publishEvent('resume', content);
-          }
+    case 'run.execute':
+      {
+        this[kStatus] = 'executing';
+        const executeMessage = (0, _messageHelper.cloneMessage)(message);
 
-          return execution.execute(executeMessage);
+        if (fields.redelivered && !exec.execution) {
+          executeMessage.fields.redelivered = undefined;
         }
 
-      case 'run.end':
-        {
-          if (status === 'end') break;
-          counters.completed++;
-          logger.debug(`<${executionId} (${id})> completed`);
-          status = 'end';
-          broker.publish('run', 'run.leave', content);
-          publishEvent('end', content);
-          break;
-        }
+        this[kExecuteMessage] = message;
+        this.broker.getQueue('execution-q').assertConsumer(this[kMessageHandlers].onExecutionMessage, {
+          exclusive: true,
+          consumerTag: '_definition-execution'
+        });
+        exec.execution = exec.execution || new _DefinitionExecution.default(this, this.context);
 
-      case 'run.discarded':
-        {
-          if (status === 'discarded') break;
-          counters.discarded++;
-          status = 'discarded';
-          broker.publish('run', 'run.leave', content);
-          break;
+        if (executeMessage.fields.redelivered) {
+          this._publishEvent('resume', content);
         }
 
-      case 'run.error':
-        {
-          publishEvent('error', (0, _messageHelper.cloneContent)(content, {
-            error: fields.redelivered ? (0, _Errors.makeErrorFromMessage)(message) : content.error
-          }), {
-            mandatory: true
-          });
-          break;
-        }
+        return exec.execution.execute(executeMessage);
+      }
 
-      case 'run.leave':
-        {
-          ack();
-          status = undefined;
-          deactivateRunConsumers();
-          publishEvent('leave');
-          break;
-        }
-    }
+    case 'run.end':
+      {
+        if (this[kStatus] === 'end') break;
+        this[kCounters].completed++;
+        this.logger.debug(`<${this.executionId} (${this.id})> completed`);
+        this[kStatus] = 'end';
+        this.broker.publish('run', 'run.leave', content);
 
-    ack();
+        this._publishEvent('end', content);
 
-    function onResumeMessage() {
-      message.ack();
+        break;
+      }
 
-      switch (stateMessage.fields.routingKey) {
-        case 'run.enter':
-        case 'run.start':
-        case 'run.discarded':
-        case 'run.end':
-        case 'run.leave':
-          break;
+    case 'run.error':
+      {
+        this._publishEvent('error', { ...content,
+          error: fields.redelivered ? (0, _Errors.makeErrorFromMessage)(message) : content.error
+        }, {
+          mandatory: true
+        });
 
-        default:
-          return;
+        break;
       }
 
-      if (!stateMessage.fields.redelivered) return;
-      logger.debug(`<${id}> resume from ${status}`);
-      return broker.publish('run', stateMessage.fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
-    }
-  }
+    case 'run.discarded':
+      {
+        if (this[kStatus] === 'discarded') break;
+        this[kCounters].discarded++;
+        this[kStatus] = 'discarded';
+        this.broker.publish('run', 'run.leave', content);
+        break;
+      }
 
-  function onExecutionMessage(routingKey, message) {
-    const {
-      content,
-      properties
-    } = message;
-    const messageType = properties.type;
-    message.ack();
-
-    switch (messageType) {
-      case 'stopped':
-        {
-          deactivateRunConsumers();
-          return publishEvent('stop');
-        }
+    case 'run.leave':
+      {
+        message.ack();
+        this[kStatus] = undefined;
 
-      case 'error':
-        {
-          broker.publish('run', 'run.error', content);
-          broker.publish('run', 'run.discarded', content);
-          break;
-        }
+        this._deactivateRunConsumers();
 
-      default:
-        {
-          broker.publish('run', 'run.end', content);
-        }
-    }
+        this._publishEvent('leave', this._createMessage());
 
-    if (postponedMessage) {
-      const ackMessage = postponedMessage;
-      postponedMessage = null;
-      ackMessage.ack();
-    }
+        return;
+      }
   }
 
-  function publishEvent(action, content = {}, msgOpts) {
-    broker.publish('event', `definition.${action}`, execution ? execution.createMessage(content) : content, {
-      type: action,
-      ...msgOpts
-    });
-  }
+  message.ack();
+};
 
-  function getState() {
-    return createMessage({
-      executionId,
-      status,
-      stopped,
-      counters: { ...counters
-      },
-      environment: environment.getState(),
-      execution: execution && execution.getState(),
-      broker: broker.getState(true)
-    });
-  }
+proto._onResumeMessage = function onResumeMessage(message) {
+  message.ack();
+  const stateMessage = this[kStateMessage];
 
-  function getProcesses() {
-    if (!processes) loadProcesses();
-    return processes;
-  }
+  switch (stateMessage.fields.routingKey) {
+    case 'run.discarded':
+    case 'run.end':
+    case 'run.leave':
+      break;
 
-  function getExecutableProcesses() {
-    if (!processes) loadProcesses();
-    return executableProcesses;
+    default:
+      return;
   }
 
-  function getProcessById(processId) {
-    return getProcesses().find(p => p.id === processId);
-  }
+  if (!stateMessage.fields.redelivered) return;
 
-  function loadProcesses() {
-    if (processes) return processes;
-    executableProcesses = context.getExecutableProcesses() || [];
-    processes = context.getProcesses() || [];
-    logger.debug(`<${id}> found ${processes.length} processes`);
-  }
+  this._debug(`resume from ${this.status}`);
 
-  function getActivityById(childId) {
-    let child;
-    const siblings = getProcesses();
+  return this.broker.publish('run', stateMessage.fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
+};
 
-    for (let i = 0; i < siblings.length; i++) {
-      child = siblings[i].getActivityById(childId);
-      if (child) return child;
-    }
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  const {
+    content,
+    properties
+  } = message;
+  const messageType = properties.type;
+  message.ack();
+
+  switch (messageType) {
+    case 'stopped':
+      {
+        return this._onStop();
+      }
 
-    return child;
-  }
+    case 'error':
+      {
+        this.broker.publish('run', 'run.error', content);
+        this.broker.publish('run', 'run.discarded', content);
+        break;
+      }
 
-  function getElementById(elementId) {
-    return context.getActivityById(elementId);
+    default:
+      {
+        this.broker.publish('run', 'run.end', content);
+      }
   }
 
-  function getPostponed(...args) {
-    if (!execution) return [];
-    return execution.getPostponed(...args);
-  }
+  const executeMessage = this[kExecuteMessage];
+  this[kExecuteMessage] = null;
+  executeMessage.ack();
+};
 
-  function getApi(message) {
-    if (execution) return execution.getApi(message);
-    if (!message || !stateMessage) throw new Error('Definition is not running');
-    return (0, _Api.DefinitionApi)(broker, message || stateMessage);
-  }
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  if (message.properties.type === 'stop') {
+    const execution = this.execution;
 
-  function signal(message) {
-    return getApi().signal(message, {
-      delegate: true
-    });
+    if (!execution || execution.completed) {
+      this._onStop();
+    }
   }
+};
 
-  function cancelActivity(message) {
-    return getApi().cancel(message, {
-      delegate: true
-    });
-  }
+proto._publishEvent = function publishEvent(action, content, msgOpts) {
+  const execution = this.execution;
+  this.broker.publish('event', `definition.${action}`, execution ? execution._createMessage(content) : (0, _messageHelper.cloneContent)(content), {
+    type: action,
+    ...msgOpts
+  });
+};
 
-  function sendMessage(message) {
-    const messageContent = {
-      message
-    };
-    let messageType = 'message';
-    const reference = message && message.id && getElementById(message.id);
-
-    if (reference && reference.resolve) {
-      const resolvedReference = reference.resolve(createMessage({
-        message
-      }));
-      messageType = resolvedReference.messageType || messageType;
-      messageContent.message = { ...message,
-        ...resolvedReference
-      };
-    }
+proto._onStop = function onStop() {
+  this[kStopped] = true;
+
+  this._deactivateRunConsumers();
 
-    return getApi().sendApiMessage(messageType, messageContent, {
-      delegate: true
-    });
+  return this._publishEvent('stop', this._createMessage());
+};
+
+proto._onBrokerReturnFn = function onBrokerReturn(message) {
+  if (message.properties.type === 'error') {
+    this._deactivateRunConsumers();
+
+    const err = (0, _Errors.makeErrorFromMessage)(message);
+    throw err;
   }
+};
 
-  function onApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
+proto._reset = function reset() {
+  this[kExec].executionId = undefined;
 
-    switch (messageType) {
-      case 'stop':
-        {
-          if (execution && !execution.completed) return;
-          onStop();
-          break;
-        }
-    }
+  this._deactivateRunConsumers();
+
+  this.broker.purgeQueue('run-q');
+  this.broker.purgeQueue('execution-q');
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.id}> ${msg}`);
+};
+
+function addConsumerCallbacks(definition, callback) {
+  const broker = definition.broker;
+  clearConsumers();
+  broker.subscribeOnce('event', 'definition.stop', cbLeave, {
+    consumerTag: '_definition-callback-stop'
+  });
+  broker.subscribeOnce('event', 'definition.leave', cbLeave, {
+    consumerTag: '_definition-callback-leave'
+  });
+  broker.subscribeOnce('event', 'definition.error', cbError, {
+    consumerTag: '_definition-callback-error'
+  });
+
+  function cbLeave(_, message) {
+    clearConsumers();
+    return callback(null, definition.getApi(message));
   }
 
-  function onStop() {
-    stopped = true;
-    deactivateRunConsumers();
-    return publishEvent('stop');
+  function cbError(_, message) {
+    clearConsumers();
+
+    definition._reset();
+
+    return callback((0, _Errors.makeErrorFromMessage)(message));
   }
 
-  function reset() {
-    executionId = undefined;
-    deactivateRunConsumers();
-    runQ.purge();
-    executionQ.purge();
+  function clearConsumers() {
+    broker.cancel('_definition-callback-stop');
+    broker.cancel('_definition-callback-leave');
+    broker.cancel('_definition-callback-error');
   }
 }