bpmn-elements 6.0.1 → 7.0.0

package/src/process/Process.js

@@ -2,389 +2,430 @@ import ProcessExecution from './ProcessExecution';
 import {getUniqueId} from '../shared';
 import {ProcessApi} from '../Api';
 import {ProcessBroker} from '../EventBroker';
-import {cloneMessage, cloneContent} from '../messageHelper';
+import {cloneMessage, cloneContent, cloneParent} from '../messageHelper';
 import {makeErrorFromMessage} from '../error/Errors';
 
+const consumingSymbol = Symbol.for('consuming');
+const countersSymbol = Symbol.for('counters');
+const execSymbol = Symbol.for('exec');
+const executeMessageSymbol = Symbol.for('executeMessage');
+const extensionsSymbol = Symbol.for('extensions');
+const messageHandlersSymbol = Symbol.for('messageHandlers');
+const stateMessageSymbol = Symbol.for('stateMessage');
+const statusSymbol = Symbol.for('status');
+const stoppedSymbol = Symbol.for('stopped');
+
 export default Process;
 
 export function Process(processDef, context) {
   const {id, type = 'process', name, parent, behaviour = {}} = processDef;
-  const environment = context.environment;
-  const {isExecutable} = behaviour;
-
-  const logger = environment.Logger(type.toLowerCase());
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = parent ? cloneParent(parent) : {};
+  this.behaviour = behaviour;
 
-  let execution, initExecutionId, executionId, status, stopped, postponedMessage, stateMessage, consumingRunQ;
+  const {isExecutable} = behaviour;
+  this.isExecutable = isExecutable;
 
-  let counters = {
+  const environment = this.environment = context.environment;
+  this.context = context;
+  this[countersSymbol] = {
     completed: 0,
     discarded: 0,
-    terminated: 0,
   };
-
-  const processApi = {
-    id,
-    type,
-    name,
-    isExecutable,
-    behaviour,
-    get counters() {
-      return {...counters};
-    },
-    get executionId() {
-      return executionId;
-    },
-    get status() {
-      return status;
-    },
-    get stopped() {
-      return stopped;
-    },
-    get execution() {
-      return execution;
-    },
-    get isRunning() {
-      if (!consumingRunQ) return false;
-      return !!status;
-    },
-    context,
-    environment,
-    parent: {...parent},
-    logger,
-    getApi,
-    getActivities,
-    getActivityById,
-    getSequenceFlows,
-    getPostponed,
-    getStartActivities,
-    getState,
-    init,
-    recover,
-    resume,
-    run,
-    sendMessage,
-    shake,
-    signal,
-    cancelActivity,
-    stop,
+  this[stoppedSymbol] = false;
+  this[execSymbol] = {};
+
+  const {broker, on, once, waitFor} = ProcessBroker(this);
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+
+  this[messageHandlersSymbol] = {
+    onApiMessage: this._onApiMessage.bind(this),
+    onRunMessage: this._onRunMessage.bind(this),
+    onExecutionMessage: this._onExecutionMessage.bind(this),
   };
 
-  const {broker, on, once, waitFor} = ProcessBroker(processApi);
-
-  processApi.on = on;
-  processApi.once = once;
-  processApi.waitFor = waitFor;
-
-  const runQ = broker.getQueue('run-q');
-  const executionQ = broker.getQueue('execution-q');
-
-  Object.defineProperty(processApi, 'broker', {
-    enumerable: true,
-    get: () => broker,
-  });
-
-  const extensions = context.loadExtensions(processApi);
-  Object.defineProperty(processApi, 'extensions', {
-    enumerable: true,
-    get: () => extensions,
-  });
+  this.logger = environment.Logger(type.toLowerCase());
 
-  return processApi;
+  this[extensionsSymbol] = context.loadExtensions(this);
+}
 
-  function init() {
-    initExecutionId = getUniqueId(id);
-    logger.debug(`<${id}> initialized with executionId <${initExecutionId}>`);
-    publishEvent('init', createMessage({executionId: initExecutionId}));
+const proto = Process.prototype;
+
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+  get() {
+    return {...this[countersSymbol]};
+  },
+});
+
+Object.defineProperty(proto, 'extensions', {
+  enumerable: true,
+  get() {
+    return this[extensionsSymbol];
+  },
+});
+
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
+  get() {
+    return this[stoppedSymbol];
+  },
+});
+
+Object.defineProperty(proto, 'isRunning', {
+  enumerable: true,
+  get() {
+    if (!this[consumingSymbol]) return false;
+    return !!this.status;
+  },
+});
+
+Object.defineProperty(proto, 'executionId', {
+  enumerable: true,
+  get() {
+    const {executionId, initExecutionId} = this[execSymbol];
+    return executionId || initExecutionId;
+  },
+});
+
+Object.defineProperty(proto, 'execution', {
+  enumerable: true,
+  get() {
+    return this[execSymbol].execution;
+  },
+});
+
+Object.defineProperty(proto, 'status', {
+  enumerable: true,
+  get() {
+    return this[statusSymbol];
+  },
+});
+
+proto.init = function init(useAsExecutionId) {
+  const exec = this[execSymbol];
+  const initExecutionId = exec.initExecutionId = useAsExecutionId || getUniqueId(this.id);
+  this._debug(`initialized with executionId <${initExecutionId}>`);
+  this._publishEvent('init', this._createMessage({executionId: initExecutionId}));
+};
+
+proto.run = function run(runContent) {
+  if (this.isRunning) throw new Error(`process <${this.id}> is already running`);
+
+  const exec = this[execSymbol];
+  const executionId = exec.executionId = exec.initExecutionId || getUniqueId(this.id);
+  exec.initExecutionId = undefined;
+
+  const content = this._createMessage({...runContent, executionId});
+
+  const broker = this.broker;
+  broker.publish('run', 'run.enter', content);
+  broker.publish('run', 'run.start', cloneContent(content));
+  broker.publish('run', 'run.execute', cloneContent(content));
+
+  this._activateRunConsumers();
+};
+
+proto.resume = function resume() {
+  if (this.isRunning) throw new Error(`cannot resume running process <${this.id}>`);
+  if (!this.status) return this;
+
+  this[stoppedSymbol] = false;
+
+  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 process <${this.id}>`);
+  if (!state) return this;
+
+  this[stoppedSymbol] = !!state.stopped;
+  this[statusSymbol] = state.status;
+  const exec = this[execSymbol];
+  exec.executionId = state.executionId;
+  this[countersSymbol] = {...this[countersSymbol], ...state.counters};
+  this.environment.recover(state.environment);
+
+  if (state.execution) {
+    exec.execution = new ProcessExecution(this, this.context).recover(state.execution);
   }
 
-  function run(runContent) {
-    if (processApi.isRunning) throw new Error(`process <${id}> is already running`);
-
-    executionId = initExecutionId || getUniqueId(id);
-    initExecutionId = undefined;
-
-    const content = createMessage({...runContent, executionId});
-
-    broker.publish('run', 'run.enter', content);
-    broker.publish('run', 'run.start', cloneContent(content));
-    broker.publish('run', 'run.execute', cloneContent(content));
-
-    activateRunConsumers();
+  this.broker.recover(state.broker);
+
+  return this;
+};
+
+proto.shake = function shake(startId) {
+  if (this.isRunning) return this.execution.shake(startId);
+  return new ProcessExecution(this, this.context).shake(startId);
+};
+
+proto.stop = function stop() {
+  if (!this.isRunning) return;
+  this.getApi().stop();
+};
+
+proto.getApi = function getApi(message) {
+  const execution = this.execution;
+  if (execution) return execution.getApi(message);
+  return ProcessApi(this.broker, message || this[stateMessageSymbol]);
+};
+
+proto.signal = function signal(message) {
+  return this.getApi().signal(message, {delegate: true});
+};
+
+proto.getState = function getState() {
+  return this._createMessage({
+    environment: this.environment.getState(),
+    status: this.status,
+    stopped: this.stopped,
+    counters: this.counters,
+    broker: this.broker.getState(true),
+    execution: this.execution && this.execution.getState(),
+    output: {...this.environment.output},
+  });
+};
+
+proto.cancelActivity = function cancelActivity(message) {
+  return this.getApi().cancel(message, {delegate: true});
+};
+
+proto._activateRunConsumers = function activateRunConsumers() {
+  this[consumingSymbol] = true;
+  const broker = this.broker;
+  const {onApiMessage, onRunMessage} = this[messageHandlersSymbol];
+  broker.subscribeTmp('api', `process.*.${this.executionId}`, onApiMessage, {noAck: true, consumerTag: '_process-api', priority: 100});
+  broker.getQueue('run-q').assertConsumer(onRunMessage, {exclusive: true, consumerTag: '_process-run'});
+};
+
+proto._deactivateRunConsumers = function deactivateRunConsumers() {
+  const broker = this.broker;
+  broker.cancel('_process-api');
+  broker.cancel('_process-run');
+  broker.cancel('_process-execution');
+  this[consumingSymbol] = false;
+};
+
+proto._onRunMessage = function onRunMessage(routingKey, message) {
+  const {content, fields} = message;
+
+  if (routingKey === 'run.resume') {
+    return this._onResumeMessage(message);
   }
 
-  function resume() {
-    if (processApi.isRunning) throw new Error(`cannot resume running process <${id}>`);
-    if (!status) return processApi;
-
-    stopped = false;
+  const exec = this[execSymbol];
+  this[stateMessageSymbol] = message;
 
-    const content = createMessage({executionId});
-    broker.publish('run', 'run.resume', content, {persistent: false});
-    activateRunConsumers();
-    return processApi;
-  }
+  switch (routingKey) {
+    case 'run.enter': {
+      this._debug('enter');
 
-  function recover(state) {
-    if (processApi.isRunning) throw new Error(`cannot recover running process <${id}>`);
-    if (!state) return processApi;
+      this[statusSymbol] = 'entered';
+      if (fields.redelivered) break;
 
-    stopped = state.stopped;
-    status = state.status;
-    executionId = state.executionId;
-    counters = {...counters, ...state.counters};
+      exec.execution = undefined;
+      this._publishEvent('enter', content);
 
-    if (state.execution) {
-      execution = ProcessExecution(processApi, context).recover(state.execution);
+      break;
     }
-
-    broker.recover(state.broker);
-
-    return processApi;
-  }
-
-  function shake(startId) {
-    if (processApi.isRunning) return execution.shake(startId);
-    return ProcessExecution(processApi, context).shake(startId);
-  }
-
-  function activateRunConsumers() {
-    consumingRunQ = true;
-    broker.subscribeTmp('api', `process.*.${executionId}`, onApiMessage, {noAck: true, consumerTag: '_process-api', priority: 100});
-    runQ.assertConsumer(onRunMessage, {exclusive: true, consumerTag: '_process-run'});
-  }
-
-  function deactivateRunConsumers() {
-    broker.cancel('_process-api');
-    broker.cancel('_process-run');
-    broker.cancel('_process-execution');
-    consumingRunQ = false;
-  }
-
-  function stop() {
-    if (!processApi.isRunning) return;
-    getApi().stop();
-  }
-
-  function getApi(message) {
-    if (execution) return execution.getApi(message);
-    return ProcessApi(broker, message || stateMessage);
-  }
-
-  function signal(message) {
-    return getApi().signal(message, {delegate: true});
-  }
-
-  function cancelActivity(message) {
-    return getApi().cancel(message, {delegate: true});
-  }
-
-  function onRunMessage(routingKey, message) {
-    const {content, ack, fields} = message;
-
-    if (routingKey === 'run.resume') {
-      return onResumeMessage();
+    case 'run.start': {
+      this._debug('start');
+      this[statusSymbol] = 'start';
+      this._publishEvent('start', content);
+      break;
     }
-
-    stateMessage = message;
-
-    switch (routingKey) {
-      case 'run.enter': {
-        logger.debug(`<${id}> enter`);
-
-        status = 'entered';
-        if (fields.redelivered) break;
-
-        execution = undefined;
-        publishEvent('enter', content);
-
-        break;
-      }
-      case 'run.start': {
-        logger.debug(`<${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: '_process-execution'});
-        execution = execution || ProcessExecution(processApi, context);
-        return execution.execute(executeMessage);
-      }
-      case 'run.error': {
-        publishEvent('error', cloneContent(content, {
-          error: fields.redelivered ? makeErrorFromMessage(message) : content.error,
-        }));
-        break;
+    case 'run.execute': {
+      this[statusSymbol] = 'executing';
+      const executeMessage = cloneMessage(message);
+      if (fields.redelivered && !exec.execution) {
+        executeMessage.fields.redelivered = undefined;
       }
-      case 'run.end': {
-        status = 'end';
+      this[executeMessageSymbol] = message;
 
-        if (fields.redelivered) break;
-        logger.debug(`<${id}> completed`);
+      this.broker.getQueue('execution-q').assertConsumer(this[messageHandlersSymbol].onExecutionMessage, {
+        exclusive: true,
+        consumerTag: '_process-execution',
+      });
 
-        counters.completed++;
-
-        broker.publish('run', 'run.leave', content);
-        publishEvent('end', content);
-        break;
-      }
-      case 'run.discarded': {
-        status = 'discarded';
-        if (fields.redelivered) break;
-
-        counters.discarded++;
-
-        broker.publish('run', 'run.leave', content);
-        break;
-      }
-      case 'run.leave': {
-        status = undefined;
-        broker.cancel('_process-api');
-        publishEvent('leave');
-        break;
-      }
+      const execution = exec.execution = exec.execution || new ProcessExecution(this, this.context);
+      return execution.execute(executeMessage);
     }
+    case 'run.error': {
+      this._publishEvent('error', cloneContent(content, {
+        error: fields.redelivered ? makeErrorFromMessage(message) : content.error,
+      }));
+      break;
+    }
+    case 'run.end': {
+      this[statusSymbol] = 'end';
 
-    ack();
-
-    function onResumeMessage() {
-      message.ack();
-
-      switch (stateMessage.fields.routingKey) {
-        case 'run.enter':
-        case 'run.start':
-        case 'run.discarded':
-        case 'run.end':
-        case 'run.leave':
-          break;
-        default:
-          return;
-      }
+      if (fields.redelivered) break;
+      this._debug('completed');
 
-      if (!stateMessage.fields.redelivered) return;
+      this[countersSymbol].completed++;
 
-      logger.debug(`<${id}> resume from ${status}`);
+      this.broker.publish('run', 'run.leave', content);
 
-      return broker.publish('run', stateMessage.fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
+      this._publishEvent('end', content);
+      break;
     }
-  }
+    case 'run.discarded': {
+      this[statusSymbol] = 'discarded';
+      if (fields.redelivered) break;
 
-  function onExecutionMessage(routingKey, message) {
-    const content = message.content;
-    const messageType = message.properties.type;
-    message.ack();
+      this[countersSymbol].discarded++;
 
-    switch (messageType) {
-      case 'stopped': {
-        return onStop();
-      }
-      case 'error': {
-        broker.publish('run', 'run.error', content);
-        broker.publish('run', 'run.discarded', content);
-        break;
-      }
-      case 'discard':
-        broker.publish('run', 'run.discarded', content);
-        break;
-      default: {
-        broker.publish('run', 'run.end', content);
-      }
-    }
+      this.broker.publish('run', 'run.leave', content);
 
-    if (postponedMessage) {
-      const ackMessage = postponedMessage;
-      postponedMessage = null;
-      ackMessage.ack();
+      this._publishEvent('discarded', content);
+      break;
     }
-  }
-
-  function publishEvent(state, content) {
-    if (!content) content = createMessage();
-    broker.publish('event', `process.${state}`, {...content, state}, {type: state, mandatory: state === 'error'});
-  }
-
-  function sendMessage(message) {
-    const messageContent = message.content;
-    if (!messageContent) return;
-
-    let targetsFound = false;
-    if (messageContent.target && messageContent.target.id && getActivityById(messageContent.target.id)) {
-      targetsFound = true;
-    } else if (messageContent.message && getStartActivities({referenceId: messageContent.message.id, referenceType: messageContent.message.messageType}).length) {
-      targetsFound = true;
+    case 'run.leave': {
+      this[statusSymbol] = undefined;
+      this.broker.cancel('_process-api');
+      const {output, ...rest} = content; // eslint-disable-line no-unused-vars
+      this._publishEvent('leave', rest);
+      break;
     }
-    if (!targetsFound) return;
-
-    if (!status) run();
-    getApi().sendApiMessage(message.properties.type || 'message', cloneContent(messageContent), {delegate: true});
   }
 
-  function getActivityById(childId) {
-    if (execution) return execution.getActivityById(childId);
-    return context.getActivityById(childId);
+  message.ack();
+};
+
+proto._onResumeMessage = function onResumeMessage(message) {
+  message.ack();
+
+  const stateMessage = this[stateMessageSymbol];
+  switch (stateMessage.fields.routingKey) {
+    case 'run.enter':
+    case 'run.start':
+    case 'run.discarded':
+    case 'run.end':
+    case 'run.leave':
+      break;
+    default:
+      return;
   }
 
-  function getActivities() {
-    if (execution) return execution.getActivities();
-    return context.getActivities(id);
-  }
+  if (!stateMessage.fields.redelivered) return;
 
-  function getStartActivities(filterOptions) {
-    return context.getStartActivities(filterOptions, id);
-  }
-
-  function getSequenceFlows() {
-    if (execution) return execution.getSequenceFlows();
-    return context.getSequenceFlows();
-  }
+  this._debug(`resume from ${this.status}`);
 
-  function getPostponed(...args) {
-    if (execution) return execution.getPostponed(...args);
-    return [];
-  }
+  return this.broker.publish('run', stateMessage.fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
+};
 
-  function onApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  const content = message.content;
+  const messageType = message.properties.type;
+  message.ack();
 
-    switch (messageType) {
-      case 'stop': {
-        if (execution && !execution.completed) return;
-        onStop();
-        break;
-      }
+  switch (messageType) {
+    case 'stopped': {
+      return this._onStop();
+    }
+    case 'error': {
+      this.broker.publish('run', 'run.error', content);
+      this.broker.publish('run', 'run.discarded', content);
+      break;
+    }
+    case 'discard':
+      this.broker.publish('run', 'run.discarded', content);
+      break;
+    default: {
+      this.broker.publish('run', 'run.end', content);
     }
   }
 
-  function onStop() {
-    stopped = true;
-    deactivateRunConsumers();
-    return publishEvent('stop');
+  const executeMessage = this[executeMessageSymbol];
+  if (executeMessage) {
+    this[executeMessageSymbol] = null;
+    executeMessage.ack();
   }
-
-  function createMessage(override = {}) {
-    return {
-      id,
-      type,
-      name,
-      parent: {...parent},
-      ...override,
-    };
+};
+
+proto._publishEvent = function publishEvent(state, content) {
+  const eventContent = this._createMessage({...content, state});
+  this.broker.publish('event', `process.${state}`, eventContent, {type: state, mandatory: state === 'error'});
+};
+
+proto.sendMessage = function sendMessage(message) {
+  const messageContent = message.content;
+  if (!messageContent) return;
+
+  let targetsFound = false;
+  if (messageContent.target && messageContent.target.id && this.getActivityById(messageContent.target.id)) {
+    targetsFound = true;
+  } else if (messageContent.message && this.getStartActivities({referenceId: messageContent.message.id, referenceType: messageContent.message.messageType}).length) {
+    targetsFound = true;
   }
-
-  function getState() {
-    return createMessage({
-      executionId,
-      status,
-      stopped,
-      counters: {...counters},
-      broker: broker.getState(true),
-      execution: execution && execution.getState(),
-    });
+  if (!targetsFound) return;
+
+  if (!this.status) this.run();
+  this.getApi().sendApiMessage(message.properties.type || 'message', cloneContent(messageContent), {delegate: true});
+};
+
+proto.getActivityById = function getActivityById(childId) {
+  if (this.execution) return this.execution.getActivityById(childId);
+  return this.context.getActivityById(childId);
+};
+
+proto.getActivities = function getActivities() {
+  if (this.execution) return this.execution.getActivities();
+  return this.context.getActivities(this.id);
+};
+
+proto.getStartActivities = function getStartActivities(filterOptions) {
+  return this.context.getStartActivities(filterOptions, this.id);
+};
+
+proto.getSequenceFlows = function getSequenceFlows() {
+  if (this.execution) return this.execution.getSequenceFlows();
+  return this.context.getSequenceFlows();
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  if (!this.execution) return [];
+  return this.execution.getPostponed(...args);
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'stop': {
+      if (this.execution && !this.execution.completed) return;
+      this._onStop();
+      break;
+    }
   }
-}
+};
+
+proto._onStop = function onStop() {
+  this[stoppedSymbol] = true;
+  this._deactivateRunConsumers();
+  return this._publishEvent('stop');
+};
+
+proto._createMessage = function createMessage(override) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    executionId: this.executionId,
+    parent: {...this.parent},
+    ...override,
+  };
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.id}> ${msg}`);
+};