bpmn-elements 7.0.0 → 8.1.0

package/src/eventDefinitions/MessageEventDefinition.js

@@ -2,11 +2,11 @@ import getPropertyValue from '../getPropertyValue';
 import {brokerSafeId} from '../shared';
 import {cloneContent, shiftParent} from '../messageHelper';
 
-const completedSymbol = Symbol.for('completed');
-const messageQSymbol = Symbol.for('messageQ');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const referenceElementSymbol = Symbol.for('referenceElement');
-const referenceInfoSymbol = Symbol.for('referenceInfo');
+const kCompleted = Symbol.for('completed');
+const kMessageQ = Symbol.for('messageQ');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kReferenceElement = Symbol.for('referenceElement');
+const kReferenceInfo = Symbol.for('referenceInfo');
 
 export default function MessageEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, isThrowing} = activity;
@@ -26,12 +26,12 @@ export default function MessageEventDefinition(activity, eventDefinition) {
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = this[referenceElementSymbol] = reference.id && activity.getActivityById(reference.id);
+  const referenceElement = this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
   if (!isThrowing) {
-    this[completedSymbol] = false;
+    this[kCompleted] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[messageQSymbol] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
     broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true});
   }
 }
@@ -40,7 +40,7 @@ const proto = MessageEventDefinition.prototype;
 
 Object.defineProperty(proto, 'executionId', {
   get() {
-    const message = this[executeMessageSymbol];
+    const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
@@ -50,24 +50,24 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.executeCatch = function executeCatch(executeMessage) {
-  this[executeMessageSymbol] = executeMessage;
-  this[completedSymbol] = false;
+  this[kExecuteMessage] = executeMessage;
+  this[kCompleted] = false;
 
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
   const parentExecutionId = parent && parent.executionId;
 
-  const info = this[referenceInfoSymbol] = this._getReferenceInfo(executeMessage);
+  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
   this._debug(`expect ${info.description}`);
 
   const broker = this.broker;
   const onCatchMessage = this._onCatchMessage.bind(this);
-  this[messageQSymbol].consume(onCatchMessage, {
+  this[kMessageQ].consume(onCatchMessage, {
     noAck: true,
     consumerTag: `_api-message-${executionId}`,
   });
 
-  if (this[completedSymbol]) return;
+  if (this[kCompleted]) return;
 
   const onApiMessage = this._onApiMessage.bind(this);
   broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
@@ -115,10 +115,10 @@ proto.executeThrow = function executeThrow(executeMessage) {
 };
 
 proto._onCatchMessage = function onCatchMessage(routingKey, message) {
-  if (getPropertyValue(message, 'content.message.id') !== this[referenceInfoSymbol].message.id) return;
+  if (getPropertyValue(message, 'content.message.id') !== this[kReferenceInfo].message.id) return;
 
   const {type, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(this[executeMessageSymbol].content, {
+  this.broker.publish('event', 'activity.consumed', cloneContent(this[kExecuteMessage].content, {
     message: {...message.content.message},
   }), {
     correlationId,
@@ -136,9 +136,9 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       return this._complete('got signal with', message.content.message, {correlationId});
     }
     case 'discard': {
-      this[completedSymbol] = true;
+      this[kCompleted] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
     }
     case 'stop': {
       return this._stop();
@@ -147,13 +147,13 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
 };
 
 proto._complete = function complete(verb, output, options) {
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
 
   this._stop();
-  this._debug(`${verb} ${this[referenceInfoSymbol].description}`);
+  this._debug(`${verb} ${this[kReferenceInfo].description}`);
 
   const broker = this.broker;
-  const executeContent = this[executeMessageSymbol].content;
+  const executeContent = this[kExecuteMessage].content;
   const catchContent = cloneContent(executeContent, {
     message: {...output},
     executionId: executeContent.parent.executionId,
@@ -174,11 +174,11 @@ proto._stop = function stop() {
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-parent-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);
-  this[messageQSymbol].purge();
+  this[kMessageQ].purge();
 };
 
 proto._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[referenceElementSymbol];
+  const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
       message: {...this.reference},

package/src/eventDefinitions/SignalEventDefinition.js

@@ -2,11 +2,11 @@ import getPropertyValue from '../getPropertyValue';
 import {brokerSafeId} from '../shared';
 import {cloneContent, shiftParent} from '../messageHelper';
 
-const completedSymbol = Symbol.for('completed');
-const messageQSymbol = Symbol.for('messageQ');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const referenceElementSymbol = Symbol.for('referenceElement');
-const referenceInfoSymbol = Symbol.for('referenceInfo');
+const kCompleted = Symbol.for('completed');
+const kMessageQ = Symbol.for('messageQ');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kReferenceElement = Symbol.for('referenceElement');
+const kReferenceInfo = Symbol.for('referenceInfo');
 
 export default function SignalEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, isStart, isThrowing} = activity;
@@ -26,12 +26,12 @@ export default function SignalEventDefinition(activity, eventDefinition) {
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = this[referenceElementSymbol] = reference.id && activity.getActivityById(reference.id);
+  const referenceElement = this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
   if (!isThrowing && isStart) {
-    this[completedSymbol] = false;
+    this[kCompleted] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[messageQSymbol] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
     broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true});
   }
 }
@@ -40,7 +40,7 @@ const proto = SignalEventDefinition.prototype;
 
 Object.defineProperty(proto, 'executionId', {
   get() {
-    const message = this[executeMessageSymbol];
+    const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
@@ -50,23 +50,23 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.executeCatch = function executeCatch(executeMessage) {
-  this[executeMessageSymbol] = executeMessage;
-  this[completedSymbol] = false;
+  this[kExecuteMessage] = executeMessage;
+  this[kCompleted] = false;
 
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
   const parentExecutionId = parent && parent.executionId;
 
-  const info = this[referenceInfoSymbol] = this._getReferenceInfo(executeMessage);
+  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
   const broker = this.broker;
 
   const onCatchMessage = this._onCatchMessage.bind(this);
   if (this.activity.isStart) {
-    this[messageQSymbol].consume(onCatchMessage, {
+    this[kMessageQ].consume(onCatchMessage, {
       noAck: true,
       consumerTag: `_api-signal-${executionId}`,
     });
-    if (this[completedSymbol]) return;
+    if (this[kCompleted]) return;
   }
 
   const onApiMessage = this._onApiMessage.bind(this);
@@ -116,13 +116,13 @@ proto.executeThrow = function executeThrow(executeMessage) {
 };
 
 proto._onCatchMessage = function onCatchMessage(routingKey, message) {
-  const info = this[referenceInfoSymbol];
+  const info = this[kReferenceInfo];
   if (getPropertyValue(message, 'content.message.id') !== info.message.id) return;
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
   this._stop();
 
   const {type, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(this[executeMessageSymbol].content, {
+  this.broker.publish('event', 'activity.consumed', cloneContent(this[kExecuteMessage].content, {
     message: { ...message.content.message},
   }), {
     correlationId,
@@ -140,9 +140,9 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       return this._complete(message.content.message, {correlationId});
     }
     case 'discard': {
-      this[completedSymbol] = true;
+      this[kCompleted] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
     }
     case 'stop': {
       this._stop();
@@ -152,10 +152,10 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
 };
 
 proto._complete = function complete(output, options) {
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
   this._stop();
-  this._debug(`signaled with ${this[referenceInfoSymbol].description}`);
-  return this.broker.publish('execution', 'execute.completed', cloneContent(this[executeMessageSymbol].content, {
+  this._debug(`signaled with ${this[kReferenceInfo].description}`);
+  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {
     output,
     state: 'signal',
   }), options);
@@ -167,11 +167,11 @@ proto._stop = function stop() {
   broker.cancel(`_api-parent-${executionId}`);
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);
-  if (this.activity.isStart) this[messageQSymbol].purge();
+  if (this.activity.isStart) this[kMessageQ].purge();
 };
 
 proto._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[referenceElementSymbol];
+  const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
       message: {...this.reference},

package/src/eventDefinitions/TimerEventDefinition.js

@@ -1,9 +1,10 @@
 import {cloneContent} from '../messageHelper';
 import {toSeconds, parse} from 'iso8601-duration';
 
-const stoppedSymbol = Symbol.for('stopped');
-const timerContentSymbol = Symbol.for('timerContent');
-const timerSymbol = Symbol.for('timer');
+const kStopped = Symbol.for('stopped');
+const kTimerContent = Symbol.for('timerContent');
+const kTimer = Symbol.for('timer');
+const repeatPattern = /^\s*R(\d+)\//;
 
 export default function TimerEventDefinition(activity, eventDefinition) {
   const type = this.type = eventDefinition.type || 'TimerEventDefinition';
@@ -19,15 +20,15 @@ export default function TimerEventDefinition(activity, eventDefinition) {
   this.broker = activity.broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  this[stoppedSymbol] = false;
-  this[timerSymbol] = null;
+  this[kStopped] = false;
+  this[kTimer] = null;
 }
 
 const proto = TimerEventDefinition.prototype;
 
 Object.defineProperty(proto, 'executionId', {
   get() {
-    const content = this[timerContentSymbol];
+    const content = this[kTimerContent];
     return content && content.executionId;
   },
 });
@@ -35,35 +36,35 @@ Object.defineProperty(proto, 'executionId', {
 Object.defineProperty(proto, 'stopped', {
   enumerable: true,
   get() {
-    return this[stoppedSymbol];
+    return this[kStopped];
   },
 });
 
 Object.defineProperty(proto, 'timer', {
   enumerable: true,
   get() {
-    return this[timerSymbol];
+    return this[kTimer];
   },
 });
 
 proto.execute = function execute(executeMessage) {
   const {routingKey: executeKey, redelivered: isResumed} = executeMessage.fields;
-  const timer = this[timerSymbol];
+  const timer = this[kTimer];
   if (timer && executeKey === 'execute.timer') {
     return;
   }
 
-  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
-  this[stoppedSymbol] = false;
+  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
+  this[kStopped] = false;
 
   const content = executeMessage.content;
   const executionId = content.executionId;
   const startedAt = this.startedAt = 'startedAt' in content ? new Date(content.startedAt) : new Date();
 
   const resolvedTimer = this._getTimers(executeMessage);
-  const timerContent = this[timerContentSymbol] = cloneContent(content, {
+  const timerContent = this[kTimerContent] = cloneContent(content, {
     ...resolvedTimer,
-    ...(isResumed ? {isResumed} : undefined),
+    ...(isResumed && {isResumed}),
     startedAt,
     state: 'timer',
   });
@@ -86,7 +87,7 @@ proto.execute = function execute(executeMessage) {
   if (timerContent.timeout <= 0) return this._completed();
 
   const timers = this.environment.timers.register(timerContent);
-  this[timerSymbol] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
+  this[kTimer] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
     id: content.id,
     type: this.type,
     executionId,
@@ -95,8 +96,8 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.stop = function stopTimer() {
-  const timer = this[timerSymbol];
-  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
+  const timer = this[kTimer];
+  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
 };
 
 proto._completed = function completed(completeContent, options) {
@@ -107,11 +108,17 @@ proto._completed = function completed(completeContent, options) {
   const runningTime = stoppedAt.getTime() - this.startedAt.getTime();
   this._debug(`completed in ${runningTime}ms`);
 
-  const timerContent = this[timerContentSymbol];
+  const timerContent = this[kTimerContent];
   const content = {stoppedAt, runningTime, state: 'timeout', ...completeContent};
 
   const broker = this.broker;
   broker.publish('event', 'activity.timeout', cloneContent(timerContent, content), options);
+
+  if (timerContent.repeat > 1) {
+    const repeat = timerContent.repeat - 1;
+    broker.publish('execution', 'execute.repeat', cloneContent(timerContent, {...content, repeat}), options);
+  }
+
   broker.publish('execution', 'execute.completed', cloneContent(timerContent, content), options);
 };
 
@@ -129,7 +136,7 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(routingKey, messag
   if (signalExecutionId && signalId === id && signalExecutionId !== executionId) return;
 
   const {type, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(this[timerContentSymbol], {
+  this.broker.publish('event', 'activity.consumed', cloneContent(this[kTimerContent], {
     message: {
       ...content.message,
     },
@@ -146,7 +153,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       this._stop();
       return this._completed({
         state: 'cancel',
-        ...(message.content.message ? {message: message.content.message} : undefined),
+        ...(message.content.message && {message: message.content.message}),
       }, {correlationId});
     }
     case 'stop': {
@@ -156,15 +163,15 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
     case 'discard': {
       this._stop();
       this._debug('discarded');
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[timerContentSymbol], {state: 'discard'}), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kTimerContent], {state: 'discard'}), {correlationId});
     }
   }
 };
 
 proto._stop = function stop() {
-  this[stoppedSymbol] = true;
-  const timer = this[timerSymbol];
-  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
+  this[kStopped] = true;
+  const timer = this[kTimer];
+  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
   const broker = this.broker;
   broker.cancel(`_api-${this.executionId}`);
   broker.cancel(`_api-delegated-${this.executionId}`);
@@ -175,7 +182,7 @@ proto._getTimers = function getTimers(executeMessage) {
 
   const now = Date.now();
   const result = {
-    ...('expireAt' in content ? {expireAt: new Date(content.expireAt)} : undefined),
+    ...('expireAt' in content && {expireAt: new Date(content.expireAt)}),
   };
 
   for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
@@ -183,33 +190,39 @@ proto._getTimers = function getTimers(executeMessage) {
     else if (t in this) result[t] = this.environment.resolveExpression(this[t], executeMessage);
     else continue;
 
-    let expireAtDate;
-    if (t === 'timeDuration') {
-      const durationStr = result[t];
-      if (durationStr) {
-        const delay = this._getDurationInMilliseconds(durationStr);
-        if (delay !== undefined) expireAtDate = new Date(now + delay);
-      } else {
-        expireAtDate = new Date(now);
-      }
-    } else if (t === 'timeDate') {
-      const dateStr = result[t];
-      if (dateStr) {
-        const ms = Date.parse(dateStr);
-        if (!isNaN(ms)) {
-          expireAtDate = new Date(ms);
-        } else {
-          this._warn(`invalid timeDate >${dateStr}<`);
+    let expireAtDate, repeat;
+    const timerStr = result[t];
+    if (timerStr) {
+      switch (t) {
+        case 'timeCycle': {
+          const mRepeat = timerStr.match(repeatPattern);
+          if (mRepeat && mRepeat.length) repeat = parseInt(mRepeat[1]);
+        }
+        case 'timeDuration': {
+          const delay = this._getDurationInMilliseconds(timerStr);
+          if (delay !== undefined) expireAtDate = new Date(now + delay);
+          break;
+        }
+        case 'timeDate': {
+          const dateStr = result[t];
+          const ms = Date.parse(dateStr);
+          if (!isNaN(ms)) {
+            expireAtDate = new Date(ms);
+          } else {
+            this._warn(`invalid timeDate >${dateStr}<`);
+          }
+          break;
         }
-      } else {
-        expireAtDate = new Date(now);
       }
+    } else {
+      expireAtDate = new Date(now);
     }
 
     if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
       result.timerType = t;
       result.expireAt = expireAtDate;
+      if (repeat) result.repeat = repeat;
     }
   }
 
@@ -221,6 +234,10 @@ proto._getTimers = function getTimers(executeMessage) {
     result.timeout = 0;
   }
 
+  if (content.inbound && 'repeat' in content.inbound[0]) {
+    result.repeat = content.inbound[0].repeat;
+  }
+
   return result;
 };
 
@@ -228,7 +245,7 @@ proto._getDurationInMilliseconds = function getDurationInMilliseconds(duration)
   try {
     return toSeconds(parse(duration)) * 1000;
   } catch (err) {
-    this._warn(`failed to parse timeDuration >${duration}<: ${err.message}`);
+    this._warn(`failed to parse ${this.timerType} >${duration}<: ${err.message}`);
   }
 };
 

package/src/events/BoundaryEvent.js

@@ -3,11 +3,11 @@ import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecuti
 import {cloneContent, cloneMessage} from '../messageHelper';
 import {brokerSafeId} from '../shared';
 
-const attachedTagsSymbol = Symbol.for('attachedConsumers');
-const completeContentSymbol = Symbol.for('completeContent');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const executionSymbol = Symbol.for('execution');
-const shovelsSymbol = Symbol.for('shovels');
+const kAttachedTags = Symbol.for('attachedConsumers');
+const kCompleteContent = Symbol.for('completeContent');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kExecution = Symbol.for('execution');
+const kShovels = Symbol.for('shovels');
 
 export default function BoundaryEvent(activityDef, context) {
   return new Activity(BoundaryEventBehaviour, activityDef, context);
@@ -20,16 +20,16 @@ export function BoundaryEventBehaviour(activity) {
   this.activity = activity;
   this.environment = activity.environment;
   this.broker = activity.broker;
-  this[executionSymbol] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
-  this[shovelsSymbol] = [];
-  this[attachedTagsSymbol] = [];
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
+  this[kShovels] = [];
+  this[kAttachedTags] = [];
 }
 
 const proto = BoundaryEventBehaviour.prototype;
 
 Object.defineProperty(proto, 'executionId', {
   get() {
-    const message = this[executeMessageSymbol];
+    const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
@@ -45,35 +45,32 @@ Object.defineProperty(proto, 'cancelActivity', {
 proto.execute = function execute(executeMessage) {
   const {isRootScope, executionId} = executeMessage.content;
 
-  const eventDefinitionExecution = this[executionSymbol];
+  const eventDefinitionExecution = this[kExecution];
   if (isRootScope) {
-    this[executeMessageSymbol] = executeMessage;
+    this[kExecuteMessage] = executeMessage;
 
     const broker = this.broker;
-    if (eventDefinitionExecution && !this.environment.settings.strict) {
-      broker.subscribeTmp('execution', 'execute.expect', this._onExpectMessage.bind(this), {
-        noAck: true,
-        consumerTag: '_expect-tag',
-      });
-    }
-
     const consumerTag = `_bound-listener-${executionId}`;
     this.attachedTo.broker.subscribeTmp('event', 'activity.leave', this._onAttachedLeave.bind(this), {
       noAck: true,
       consumerTag,
       priority: 300,
     });
-    this[attachedTagsSymbol].push(consumerTag);
+    this[kAttachedTags].push(consumerTag);
 
-    broker.subscribeOnce('execution', 'execute.detach', this._onDetachMessage.bind(this), {
-      consumerTag: '_detach-tag',
-    });
     broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
       consumerTag: `_api-${executionId}`,
     });
-    broker.subscribeOnce('execution', 'execute.bound.completed', this._onCompleted.bind(this), {
-      consumerTag: `_execution-completed-${executionId}`,
-    });
+
+    const execQ = broker.assertQueue(`_bound-execution-${executionId}`, {durable: false, autoDelete: true});
+    broker.bindQueue(execQ.name, 'execution', 'execute.detach');
+    broker.bindQueue(execQ.name, 'execution', 'execute.bound.completed');
+    broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    if (eventDefinitionExecution && !this.environment.settings.strict) {
+      broker.bindQueue(execQ.name, 'execution', 'execute.expect');
+    }
+
+    execQ.consume(this._onExecutionMessage.bind(this), {consumerTag: '_execution-tag'});
   }
 
   if (eventDefinitionExecution) {
@@ -81,15 +78,29 @@ proto.execute = function execute(executeMessage) {
   }
 };
 
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  message.ack();
+  switch (routingKey) {
+    case 'execute.detach':
+      return this._onDetachMessage(routingKey, message);
+    case 'execute.bound.completed':
+      return this._onCompleted(routingKey, message);
+    case 'execute.repeat':
+      return this._onRepeatMessage(routingKey, message);
+    case 'execute.expect':
+      return this._onExpectMessage(routingKey, message);
+  }
+};
+
 proto._onCompleted = function onCompleted(_, {content}) {
   if (!this.cancelActivity && !content.cancelActivity) {
     this._stop();
-    return this.broker.publish('execution', 'execute.completed', cloneContent(content));
+    return this.broker.publish('execution', 'execute.completed', cloneContent(content, {cancelActivity: false}));
   }
 
-  this[completeContentSymbol] = content;
+  this[kCompleteContent] = content;
 
-  const {inbound} = this[executeMessageSymbol].content;
+  const inbound = this[kExecuteMessage].content.inbound;
   const attachedToContent = inbound && inbound[0];
   const attachedTo = this.attachedTo;
   this.activity.logger.debug(`<${this.executionId} (${this.id})> cancel ${attachedTo.status} activity <${attachedToContent.executionId} (${attachedToContent.id})>`);
@@ -100,8 +111,8 @@ proto._onCompleted = function onCompleted(_, {content}) {
 proto._onAttachedLeave = function onAttachedLeave(_, {content}) {
   if (content.id !== this.attachedTo.id) return;
   this._stop();
-  const completeContent = this[completeContentSymbol];
-  if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[executeMessageSymbol].content);
+  const completeContent = this[kCompleteContent];
+  if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[kExecuteMessage].content);
   return this.broker.publish('execution', 'execute.completed', cloneContent(completeContent));
 };
 
@@ -110,7 +121,7 @@ proto._onExpectMessage = function onExpectMessage(_, {content}) {
   const attachedTo = this.attachedTo;
 
   const errorConsumerTag = `_bound-error-listener-${executionId}`;
-  this[attachedTagsSymbol].push(errorConsumerTag);
+  this[kAttachedTags].push(errorConsumerTag);
 
   attachedTo.broker.subscribeTmp('event', 'activity.error', (__, errorMessage) => {
     if (errorMessage.content.id !== attachedTo.id) return;
@@ -130,7 +141,7 @@ proto._onDetachMessage = function onDetachMessage(_, {content}) {
   const {executionId: detachId, bindExchange, sourceExchange, sourcePattern} = content;
 
   const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
-  this[shovelsSymbol].push(shovelName);
+  this[kShovels].push(shovelName);
 
   const broker = this.broker;
   attachedTo.broker.createShovel(shovelName, {
@@ -160,13 +171,19 @@ proto._onApiMessage = function onApiMessage(_, message) {
   }
 };
 
+proto._onRepeatMessage = function onRepeatMessage(_, message) {
+  if (this.cancelActivity) return;
+  const executeMessage = this[kExecuteMessage];
+  const repeat = message.content.repeat;
+  this.broker.getQueue('inbound-q').queueMessage({routingKey: 'activity.restart'}, cloneContent(executeMessage.content.inbound[0], {repeat}));
+};
+
 proto._stop = function stop(detach) {
   const attachedTo = this.attachedTo, broker = this.broker, executionId = this.executionId;
-  for (const tag of this[attachedTagsSymbol].splice(0)) attachedTo.broker.cancel(tag);
-  for (const shovelName of this[shovelsSymbol].splice(0)) attachedTo.broker.closeShovel(shovelName);
+  for (const tag of this[kAttachedTags].splice(0)) attachedTo.broker.cancel(tag);
+  for (const shovelName of this[kShovels].splice(0)) attachedTo.broker.closeShovel(shovelName);
 
-  broker.cancel('_expect-tag');
-  broker.cancel('_detach-tag');
+  broker.cancel('_execution-tag');
   broker.cancel(`_execution-completed-${executionId}`);
 
   if (detach) return;