bpmn-elements 6.0.1 → 8.0.1

package/src/activity/ActivityExecution.js

@@ -1,306 +1,352 @@
 import {ActivityApi} from '../Api';
 import {cloneContent, cloneMessage} from '../messageHelper';
 
-export default function ActivityExecution(activity, context) {
-  const {id, broker, logger, isSubProcess, Behaviour, environment} = activity;
-  const {batchSize = 50} = environment.settings;
-  const postponed = [];
-
-  let source, initMessage, completed = false, executionId;
-
-  const executeQ = broker.assertQueue('execute-q', {durable: true, autoDelete: false});
-
-  const executionApi = {
-    get completed() {
-      return completed;
-    },
-    get source() {
-      return source;
-    },
-    discard,
-    execute,
-    passthrough,
-    getApi,
-    getPostponed,
-    getState,
-    recover,
-    stop,
+const kCompleted = Symbol.for('completed');
+const kExecuteQ = Symbol.for('executeQ');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kPostponed = Symbol.for('postponed');
+
+export default ActivityExecution;
+
+function ActivityExecution(activity, context) {
+  this.activity = activity;
+  this.context = context;
+  this.id = activity.id;
+  this.broker = activity.broker;
+  this[kPostponed] = [];
+  this[kCompleted] = false;
+  this[kExecuteQ] = this.broker.assertQueue('execute-q', {durable: true, autoDelete: false});
+
+  this[kMessageHandlers] = {
+    onParentApiMessage: this._onParentApiMessage.bind(this),
+    onExecuteMessage: this._onExecuteMessage.bind(this),
   };
+}
 
-  return executionApi;
-
-  function getPostponed() {
-    let apis = postponed.map((msg) => getApi(msg));
-    if (!isSubProcess || !source) return apis;
-    apis = apis.concat(source.getPostponed());
-    return apis;
-  }
-
-  function execute(executeMessage) {
-    if (!executeMessage) throw new Error('Execution requires message');
-    if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Execution requires execution id');
-
-    const isRedelivered = executeMessage.fields.redelivered;
-    executionId = executeMessage.content.executionId;
+const proto = ActivityExecution.prototype;
 
-    initMessage = cloneMessage(executeMessage);
-    initMessage.content = {...initMessage.content, executionId, state: 'start', isRootScope: true};
+Object.defineProperty(proto, 'completed', {
+  enumerable: true,
+  get() {
+    return this[kCompleted];
+  },
+});
 
-    if (isRedelivered) {
-      postponed.splice(0);
-      logger.debug(`<${executionId} (${id})> resume execution`);
+proto.execute = function execute(executeMessage) {
+  if (!executeMessage) throw new Error('Execution requires message');
+  const executionId = executeMessage.content && executeMessage.content.executionId;
+  if (!executionId) throw new Error('Execution requires execution id');
 
-      if (!source) source = Behaviour(activity, context);
+  this.executionId = executionId;
+  const initMessage = this[kExecuteMessage] = cloneMessage(executeMessage, {
+    executionId,
+    state: 'start',
+    isRootScope: true,
+  });
 
-      activate();
-      return broker.publish('execution', 'execute.resume.execution', cloneContent(initMessage.content), {persistent: false});
-    }
+  if (executeMessage.fields.redelivered) {
+    this[kPostponed].splice(0);
+    this._debug('resume execution');
 
-    logger.debug(`<${executionId} (${id})> execute`);
-    activate();
-    source = Behaviour(activity, context);
-    broker.publish('execution', 'execute.start', cloneContent(initMessage.content));
-  }
+    if (!this.source) this.source = new this.activity.Behaviour(this.activity, this.context);
 
-  function passthrough(executeMessage) {
-    if (!source) return execute(executeMessage);
-    return source.execute(executeMessage);
+    this.activate();
+    return this.broker.publish('execution', 'execute.resume.execution', cloneContent(initMessage.content), {persistent: false});
   }
 
-  function discard() {
-    if (completed) return;
-    if (!initMessage) return logger.warn(`<${id}> is not executing`);
-    getApi(initMessage).discard();
+  this._debug('execute');
+  this.activate();
+  this.source = new this.activity.Behaviour(this.activity, this.context);
+  this.broker.publish('execution', 'execute.start', cloneContent(initMessage.content));
+};
+
+proto.activate = function activate() {
+  if (this[kCompleted]) return;
+
+  const broker = this.broker;
+  const batchSize = this.activity.environment.settings.batchSize || 50;
+  broker.bindQueue('execute-q', 'execution', 'execute.#', {priority: 100});
+
+  const {onExecuteMessage, onParentApiMessage} = this[kMessageHandlers];
+  this[kExecuteQ].assertConsumer(onExecuteMessage, {
+    exclusive: true,
+    prefetch: batchSize * 2,
+    priority: 100,
+    consumerTag: '_activity-execute',
+  });
+
+  if (this[kCompleted]) return this.deactivate();
+
+  broker.subscribeTmp('api', `activity.*.${this.executionId}`, onParentApiMessage, {
+    noAck: true,
+    consumerTag: '_activity-api-execution',
+    priority: 200,
+  });
+};
+
+proto.deactivate = function deactivate() {
+  const broker = this.broker;
+  broker.cancel('_activity-api-execution');
+  broker.cancel('_activity-execute');
+  broker.unbindQueue('execute-q', 'execution', 'execute.#');
+};
+
+proto.discard = function discard() {
+  if (this[kCompleted]) return;
+  const initMessage = this[kExecuteMessage];
+  if (!initMessage) return this.activity.logger.warn(`<${this.id}> is not executing`);
+  this.getApi(initMessage).discard();
+};
+
+proto.getApi = function getApi(apiMessage) {
+  const self = this;
+  if (!apiMessage) apiMessage = this[kExecuteMessage];
+
+  if (self.source.getApi) {
+    const sourceApi = self.source.getApi(apiMessage);
+    if (sourceApi) return sourceApi;
   }
 
-  function stop() {
-    if (!initMessage) return;
-    getApi(initMessage).stop();
-  }
+  const api = ActivityApi(self.broker, apiMessage);
 
-  function getState() {
-    const result = {completed};
+  api.getExecuting = function getExecuting() {
+    return self[kPostponed].reduce((result, msg) => {
+      if (msg.content.executionId === apiMessage.content.executionId) return result;
+      result.push(self.getApi(msg));
+      return result;
+    }, []);
+  };
 
-    if (!source || !source.getState) return result;
-    return {...result, ...source.getState()};
-  }
+  return api;
+};
 
-  function recover(state) {
-    postponed.splice(0);
+proto.passthrough = function passthrough(executeMessage) {
+  if (!this.source) return this.execute(executeMessage);
+  return this._sourceExecute(executeMessage);
+};
 
-    if (!state) return executionApi;
-    if ('completed' in state) completed = state.completed;
+proto.getPostponed = function getPostponed() {
+  let apis = this[kPostponed].map((msg) => this.getApi(msg));
+  if (!this.activity.isSubProcess || !this.source) return apis;
+  apis = apis.concat(this.source.getPostponed());
+  return apis;
+};
 
-    source = Behaviour(activity, context);
-    if (source.recover) {
-      source.recover(state);
-    }
+proto.getState = function getState() {
+  const result = {completed: this[kCompleted]};
+  const source = this.source;
 
-    return executionApi;
-  }
-
-  function activate() {
-    if (completed) return;
+  if (!source || !source.getState) return result;
+  return {...result, ...source.getState()};
+};
 
-    broker.bindQueue(executeQ.name, 'execution', 'execute.#', {priority: 100});
-    executeQ.assertConsumer(onExecuteMessage, {exclusive: true, prefetch: batchSize * 2, priority: 100, consumerTag: '_activity-execute'});
-    if (completed) return deactivate();
+proto.recover = function recover(state) {
+  this[kPostponed].splice(0);
 
-    broker.subscribeTmp('api', `activity.*.${executionId}`, onParentApiMessage, {noAck: true, consumerTag: '_activity-api-execution', priority: 200});
-  }
+  if (!state) return this;
+  if ('completed' in state) this[kCompleted] = state.completed;
 
-  function deactivate() {
-    broker.cancel('_activity-api-execution');
-    broker.cancel('_activity-execute');
-    broker.unbindQueue(executeQ.name, 'execution', 'execute.#');
+  const source = this.source = new this.activity.Behaviour(this.activity, this.context);
+  if (source.recover) {
+    source.recover(state);
   }
 
-  function onParentApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
+  return this;
+};
 
-    switch (messageType) {
-      case 'discard':
-        executeQ.queueMessage({routingKey: 'execute.discard'}, cloneContent(initMessage.content));
-        break;
-      case 'stop':
-        onStop(message);
-        break;
-    }
-  }
+proto.stop = function stop() {
+  const executeMessage = this[kExecuteMessage];
+  if (!executeMessage) return;
+  this.getApi(executeMessage).stop();
+};
 
-  function onStop(message) {
-    const stoppedId = message && message.content && message.content.executionId;
-    const running = getPostponed();
-    running.forEach((api) => {
-      if (stoppedId !== api.content.executionId) {
-        api.stop();
-      }
-    });
-
-    broker.cancel('_activity-execute');
-    broker.cancel('_activity-api-execution');
+proto._sourceExecute = function sourceExecute(executeMessage) {
+  try {
+    return this.source.execute(executeMessage);
+  } catch (error) {
+    return this.broker.publish('execution', 'execute.error', cloneContent(executeMessage.content, {error}));
   }
+};
 
-  function onExecuteMessage(routingKey, message) {
-    const {fields = {}, content = {}, properties = {}} = message;
-    const isRedelivered = fields.redelivered;
-    const {isRootScope, ignoreIfExecuting, keep, executionId: cexid, error} = content;
-    const {persistent, correlationId} = properties;
+proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+  const {fields, content, properties} = message;
+  const isRedelivered = fields.redelivered;
 
-    if (isRedelivered && persistent === false) return message.ack();
+  if (isRedelivered && properties.persistent === false) return message.ack();
 
-    switch (routingKey) {
-      case 'execute.resume.execution': {
-        if (!postponed.length) return broker.publish('execution', 'execute.start', cloneContent(initMessage.content));
-        break;
-      }
-      case 'execute.error':
-      case 'execute.discard':
-        executionDiscard();
-        break;
-      case 'execute.cancel':
-      case 'execute.completed': {
-        if (isRedelivered) {
-          message.ack();
-          return broker.publish('execution', routingKey, getExecuteMessage().content);
-        }
-
-        executionCompleted();
-        break;
-      }
-      case 'execute.start': {
-        if (!stateChangeMessage()) return;
-        return source.execute(getExecuteMessage());
+  switch (routingKey) {
+    case 'execute.resume.execution': {
+      if (!this[kPostponed].length) return this.broker.publish('execution', 'execute.start', cloneContent(this[kExecuteMessage].content));
+      break;
+    }
+    case 'execute.error':
+    case 'execute.discard':
+      return this._onExecutionDiscarded(message);
+    case 'execute.cancel':
+    case 'execute.completed': {
+      if (isRedelivered) {
+        message.ack();
+        return this.broker.publish('execution', routingKey, getExecuteMessage(message).content);
       }
-      case 'execute.outbound.take': {
-        if (isRedelivered) {
-          message.ack();
-          break;
-        }
-        broker.publish('execution', 'execution.outbound.take', cloneContent(content), {type: 'outbound'});
+
+      return this._onExecutionCompleted(message);
+    }
+    case 'execute.start': {
+      if (!this._onStateChangeMessage(message)) return;
+      return this._sourceExecute(getExecuteMessage(message));
+    }
+    case 'execute.outbound.take': {
+      if (isRedelivered) {
+        message.ack();
         break;
       }
-      default: {
-        if (!stateChangeMessage()) return;
-        if (isRedelivered) {
-          return source.execute(getExecuteMessage());
-        }
-      }
+      this.broker.publish('execution', 'execution.outbound.take', cloneContent(content), {type: 'outbound'});
+      break;
     }
-
-    function stateChangeMessage() {
-      const idx = postponed.findIndex((msg) => msg.content.executionId === cexid);
-      let previousMsg;
-      if (idx > -1) {
-        if (ignoreIfExecuting) {
-          message.ack();
-          return false;
-        }
-
-        previousMsg = postponed.splice(idx, 1, message)[0];
-        previousMsg.ack();
-
-        return true;
+    default: {
+      if (!this._onStateChangeMessage(message)) return;
+      if (isRedelivered) {
+        return this._sourceExecute(getExecuteMessage(message));
       }
-
-      postponed.push(message);
-      return true;
     }
-
-    function getExecuteMessage() {
-      const result = cloneMessage(message, {...(isRedelivered ? {isRecovered: true} : undefined)});
-      result.content.ignoreIfExecuting = undefined;
-      return result;
+  }
+};
+
+proto._onStateChangeMessage = function onStateChangeMessage(message) {
+  const {ignoreIfExecuting, executionId} = message.content;
+  const postponed = this[kPostponed];
+  const idx = postponed.findIndex((msg) => msg.content.executionId === executionId);
+  let previousMsg;
+  if (idx > -1) {
+    if (ignoreIfExecuting) {
+      message.ack();
+      return false;
     }
 
-    function executionCompleted() {
-      const postponedMsg = ackPostponed(message);
-      if (!postponedMsg) return;
-
-      if (!isRootScope) {
-        logger.debug(`<${cexid} (${id})> completed sub execution`);
-        if (!keep) message.ack();
-        if (postponed.length === 1 && postponed[0].content.isRootScope && !postponed[0].content.preventComplete) {
-          return broker.publish('execution', 'execute.completed', cloneContent(postponed[0].content));
-        }
-        return;
-      }
-
-      logger.debug(`<${cexid} (${id})> completed execution`);
-      completed = true;
+    previousMsg = postponed.splice(idx, 1, message)[0];
+    previousMsg.ack();
 
-      message.ack(true);
-
-      deactivate();
-
-      const subApis = getPostponed();
-      postponed.splice(0);
-      subApis.forEach((api) => api.discard());
+    return true;
+  }
 
-      publishExecutionCompleted('completed', {...postponedMsg.content, ...message.content});
+  postponed.push(message);
+  return true;
+};
+
+proto._onExecutionCompleted = function onExecutionCompleted(message) {
+  const postponedMsg = this._ackPostponed(message);
+  if (!postponedMsg) return;
+  const postponed = this[kPostponed];
+
+  const {executionId, keep, isRootScope} = message.content;
+  if (!isRootScope) {
+    this._debug('completed sub execution');
+    if (!keep) message.ack();
+    if (postponed.length === 1 && postponed[0].content.isRootScope && !postponed[0].content.preventComplete) {
+      return this.broker.publish('execution', 'execute.completed', cloneContent(postponed[0].content));
     }
+    return;
+  }
 
-    function executionDiscard() {
-      const postponedMsg = ackPostponed(message);
-      if (!isRootScope && !postponedMsg) return;
+  this._debug('completed execution', executionId);
+  this[kCompleted] = true;
 
-      if (!error && !isRootScope) {
-        message.ack();
-        if (postponed.length === 1 && postponed[0].content.isRootScope) {
-          return broker.publish('execution', 'execute.discard', {...postponed[0].content}, {correlationId});
-        }
-        return;
-      }
+  message.ack(true);
 
-      message.ack(true);
+  this.deactivate();
 
-      deactivate();
+  const subApis = this.getPostponed();
+  postponed.splice(0);
+  for (const api of subApis) api.discard();
 
-      const subApis = getPostponed();
-      postponed.splice(0);
-      subApis.forEach((api) => api.discard());
+  this._publishExecutionCompleted('completed', {...postponedMsg.content, ...message.content}, message.properties.correlationId);
+};
 
-      publishExecutionCompleted(error ? 'error' : 'discard', {...content});
-    }
+proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
+  const postponedMsg = this._ackPostponed(message);
+  const {isRootScope, error} = message.content;
+  if (!isRootScope && !postponedMsg) return;
 
-    function publishExecutionCompleted(completionType, completeContent) {
-      completed = true;
-
-      broker.publish('execution', `execution.${completionType}`, {
-        ...completeContent,
-        state: completionType,
-      }, {type: completionType, correlationId});
+  const postponed = this[kPostponed];
+  const correlationId = message.properties.correlationId;
+  if (!error && !isRootScope) {
+    message.ack();
+    if (postponed.length === 1 && postponed[0].content.isRootScope) {
+      return this.broker.publish('execution', 'execute.discard', postponed[0].content, {correlationId});
     }
+    return;
   }
 
-  function ackPostponed(completeMessage) {
-    const {executionId: eid} = completeMessage.content;
-
-    const idx = postponed.findIndex(({content}) => content.executionId === eid);
-    if (idx === -1) return;
-    const [msg] = postponed.splice(idx, 1);
-    msg.ack();
-    return msg;
-  }
-
-  function getApi(apiMessage) {
-    if (!apiMessage) apiMessage = initMessage;
+  message.ack(true);
 
-    if (source.getApi) {
-      const sourceApi = source.getApi(apiMessage);
-      if (sourceApi) return sourceApi;
-    }
+  this.deactivate();
 
-    const api = ActivityApi(broker, apiMessage);
+  const subApis = this.getPostponed();
+  postponed.splice(0);
+  for (const api of subApis) api.discard();
 
-    api.getExecuting = function getExecuting() {
-      return postponed.reduce((result, msg) => {
-        if (msg.content.executionId === apiMessage.content.executionId) return result;
-        result.push(getApi(msg));
-        return result;
-      }, []);
-    };
+  if (error) {
+    return this._publishExecutionCompleted('error', cloneContent(message.content, {error}), correlationId);
+  }
 
-    return api;
+  this._publishExecutionCompleted('discard', message.content, correlationId);
+};
+
+proto._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
+  this[kCompleted] = true;
+
+  this.broker.publish('execution', `execution.${completionType}`, {
+    ...completeContent,
+    state: completionType,
+  }, {type: completionType, correlationId});
+};
+
+proto._ackPostponed = function ackPostponed(completeMessage) {
+  const {executionId: eid} = completeMessage.content;
+
+  const postponed = this[kPostponed];
+  const idx = postponed.findIndex(({content: c}) => c.executionId === eid);
+  if (idx === -1) return;
+  const [msg] = postponed.splice(idx, 1);
+  msg.ack();
+  return msg;
+};
+
+proto._onParentApiMessage = function onParentApiMessage(routingKey, message) {
+  switch (message.properties.type) {
+    case 'error':
+      return this[kExecuteQ].queueMessage({routingKey: 'execute.error'}, {error: message.content.error});
+    case 'discard':
+      return this[kExecuteQ].queueMessage({routingKey: 'execute.discard'}, cloneContent(this[kExecuteMessage].content));
+    case 'stop': {
+      return this._onStop(message);
+    }
   }
+};
+
+proto._onStop = function onStop(message) {
+  const stoppedId = message && message.content && message.content.executionId;
+  const running = this.getPostponed();
+  for (const api of running) {
+    if (stoppedId !== api.content.executionId) {
+      api.stop();
+    }
+  }
+
+  this.broker.cancel('_activity-execute');
+  this.broker.cancel('_activity-api-execution');
+};
+
+proto._debug = function debug(logMessage, executionId) {
+  executionId = executionId || this.executionId;
+  this.activity.logger.debug(`<${executionId} (${this.id})> ${logMessage}`);
+};
+
+function getExecuteMessage(message) {
+  const result = cloneMessage(message, {
+    ...(message.fields.redelivered ? {isRecovered: true} : undefined),
+    ignoreIfExecuting: undefined,
+  });
+  return result;
 }

package/src/activity/Dummy.js

@@ -1,13 +1,13 @@
 import {cloneParent} from '../messageHelper';
 
 export default function DummyActivity(activityDef) {
-  const {id, type = 'dummy', name, parent: originalParent = {}, behaviour = {}} = activityDef;
+  const {id, type = 'dummy', name, parent, behaviour} = activityDef;
   return {
     id,
     type,
     name,
     behaviour: {...behaviour},
-    parent: cloneParent(originalParent),
+    parent: cloneParent(parent),
     placeholder: true,
   };
 }