bpmn-elements 6.0.1 → 8.0.1

package/src/definition/Definition.js

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