octoparse-cli 0.1.14

package/node_modules/@octopus/bpmn/lib/Definition.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const contextHelper = require('./context-helper');
+const debug = require('debug')('bpmn-engine:definition');
+const EventEmitter = require('events').EventEmitter;
+const getPropertyValue = require('./getPropertyValue');
+const mapper = require('./mapper');
+const validation = require('./validation');
+
+const internals = {};
+
+module.exports = internals.Definition = function(moddleContext, options) {
+  if (!moddleContext) throw new Error('No moddle context');
+  this.moddleContext = moddleContext;
+  this.id = getPropertyValue(moddleContext, 'rootHandler.element.id', 'anonymous');
+  options = options || {};
+
+  validation.validateOptions(options);
+  this.processes = [];
+
+  this.options = options;
+};
+
+internals.Definition.resume = function(state, optionsOrCallback, callback) {
+  let options;
+  if (typeof optionsOrCallback === 'function') {
+    callback = optionsOrCallback;
+    options = {};
+  } else if (optionsOrCallback) {
+    options = {
+      listener: optionsOrCallback.listener
+    };
+  }
+
+  const definition = new internals.Definition(state.moddleContext, options);
+
+  function resumeCallback(err) {
+    if (err) {
+      teardownProcesses.call(definition);
+      if (callback) return callback.apply(null, arguments);
+      return definition.emit('error', err);
+    }
+    if (callback) return callback.apply(null, arguments);
+  }
+
+  debug(`<${definition.id}> resume`);
+  delete this.stopped;
+
+  setTimeout(() => {
+    definition.getProcesses(options, (err, instance, siblings) => {
+      if (err) return resumeCallback.call(definition, err);
+      setupProcesses.call(definition);
+      siblings.forEach((p) => p.resume(state.processes[p.id]));
+      resumeCallback.call(definition, null, instance, siblings);
+    });
+  }, 0);
+  return definition;
+};
+
+internals.Definition.prototype = Object.create(EventEmitter.prototype);
+
+internals.Definition.prototype.execute = function(optionsOrCallback, callback) {
+  let options;
+  if (typeof optionsOrCallback === 'function') {
+    callback = optionsOrCallback;
+    options = this.options;
+  } else {
+    options = optionsOrCallback;
+    validation.validateOptions(options);
+  }
+
+  debug(`<${this.id}>`, 'start');
+
+  this.getProcesses(options, (getErr, firstExecutableProcess, allProcesses) => {
+    if (getErr) {
+      if (callback) return callback(getErr);
+      return this.emit('error', getErr, this);
+    }
+
+    if (!this.entryPointId) {
+      const entryErr = new Error(`definition <${this.id}> has no executable process`);
+      if (callback) return callback(entryErr);
+      return this.emit('error', entryErr, this);
+    }
+
+    this.started = true;
+    setupProcesses.call(this);
+    this.emit('start', this);
+
+    if (callback) callback(null, firstExecutableProcess, allProcesses);
+    firstExecutableProcess.run();
+  });
+};
+
+internals.Definition.prototype.signal = function(activityId, output) {
+  const activity = this.getChildActivityById(activityId);
+  if (!activity) {
+    debug(`<${this.id}>`, `signal failed! Activity <${activityId}> was not found`);
+    return false;
+  }
+  debug(`<${this.id}>`, `signal ${activity.type} <${activityId}>`);
+  activity.signal(output);
+  return true;
+};
+
+internals.Definition.prototype.stop = function() {
+  debug(`<${this.id}>`, 'stop');
+  this.stopped = true;
+  teardownProcesses.call(this);
+  this.processes.forEach((p) => p.deactivate());
+  this.emit('end', this);
+};
+
+internals.Definition.prototype.getState = function() {
+  const state = {
+    id: this.id,
+    state: getRunningStatus.call(this),
+    moddleContext: contextHelper.cloneContext(this.moddleContext)
+  };
+  if (this.stopped) {
+    state.stopped = true;
+  }
+
+  state.processes = this.processes.reduce((result, instance) => {
+    result[instance.id] = instance.getState();
+    return result;
+  }, {});
+
+  return state;
+};
+
+internals.Definition.prototype.getPendingActivities = function() {
+  const pendingState = {
+    id: this.id,
+    state: getRunningStatus.call(this)
+  };
+
+  pendingState.children = this.processes.reduce((result, instance) => {
+    result = result.concat(instance.getPendingActivities());
+    return result;
+  }, []);
+
+  return pendingState;
+};
+
+internals.Definition.prototype.getProcesses = function(optionsOrCallback, callback) {
+  let options;
+  if (typeof optionsOrCallback === 'function') {
+    callback = optionsOrCallback;
+  } else {
+    validation.validateOptions(optionsOrCallback);
+    options = optionsOrCallback;
+  }
+
+  if (this.started) {
+    if (callback) callback(null, this.mainProcess, this.processes);
+    return this.processes;
+  }
+
+  const warnings = validation.validateModdleContext(this.moddleContext);
+  if (warnings.length) {
+    if (callback) return callback(warnings[0]);
+    return this.emit('error', warnings[0], this);
+  }
+
+  loadProcesses.call(this, this.moddleContext, options || this.options);
+
+  if (callback) callback(null, this.mainProcess, this.processes);
+  return this.processes;
+};
+
+internals.Definition.prototype.getProcessById = function(processId) {
+  return this.processes.find((p) => p.id === processId);
+};
+
+internals.Definition.prototype.getChildActivityById = function(childId) {
+  let child;
+  if (!this.processes.length) {
+    loadProcesses.call(this, this.moddleContext, this.options);
+  }
+
+  for (let i = 0; i < this.processes.length; i++) {
+    child = this.processes[i].getChildActivityById(childId);
+    if (child) break;
+  }
+  return child;
+};
+
+internals.Definition.prototype.onMessage = function(from, message, via) {
+  const targetElement = contextHelper.getTargetProcess(this.moddleContext, via.targetId);
+
+  debug(`<${this.id}>`, `message sent from <${from.id}> via <${via.id}> to <${targetElement.id}>`);
+
+  this.getProcessById(targetElement.id).signal(via.targetId, message);
+};
+
+internals.Definition.prototype.onEnd = function(process) {
+  updateVariables.call(this, process);
+
+  if (this.processes.every((p) => p.isEnded)) {
+    debug(`<${this.id}>`, 'end');
+    teardownProcesses.call(this);
+    this.started = false;
+    this.isEnded = true;
+    this.emit('end', this);
+  }
+};
+
+internals.Definition.prototype.onError = function() {
+  const args = Array.prototype.slice.call(arguments);
+  teardownProcesses.call(this);
+
+  args.unshift('error');
+  args.push(this);
+  this.emit.apply(this, args);
+};
+
+function loadProcesses(moddleContext, options) {
+  const processElements = contextHelper.getProcesses(moddleContext);
+
+  this.processes = processElements.map((e) => new mapper.Process(e, moddleContext, options));
+  this.entryPointId = contextHelper.getExecutableProcessId(moddleContext);
+
+  debug(`<${this.id}>`, `found ${this.processes.length} processes. Start with <${this.entryPointId}>`);
+  this.mainProcess = this.processes.find((p) => p.id === this.entryPointId);
+  return this.processes;
+}
+
+function setupProcesses() {
+  this._onMessage = this.onMessage.bind(this);
+  this._onEnd = this.onEnd.bind(this);
+  this._onError = this.onError.bind(this);
+
+  this.processes.forEach((p) => {
+    p.on('message', this._onMessage);
+    p.on('leave', this._onEnd);
+    p.on('error', this._onError);
+  });
+}
+
+function teardownProcesses() {
+  this.processes.forEach((p) => {
+    p.removeListener('message', this._onMessage);
+    p.removeListener('leave', this._onEnd);
+    p.removeListener('error', this._onError);
+  });
+}
+
+function updateVariables(process) {
+  this.variables = this.variables || {};
+  this.variables = Object.assign(this.variables, process.context.variables);
+}
+
+function getRunningStatus() {
+  if (!this.hasOwnProperty('started')) return 'pending';
+  return this.started ? 'running' : 'completed';
+}
+

package/node_modules/@octopus/bpmn/lib/Engine.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const Async = require('async');
+const contextHelper = require('./context-helper');
+const debug = require('debug')('bpmn-engine:engine');
+const EventEmitter = require('events').EventEmitter;
+const mapper = require('./mapper');
+const transformer = require('./transformer');
+const validation = require('./validation');
+const packageVersion = require('../package.json').version;
+
+const internals = {};
+const validOptions = ['name', 'source', 'moddleContext', 'moddleOptions'];
+
+module.exports = internals.Engine = function(options) {
+  options = options || {};
+
+  Object.keys(options).forEach((key) => {
+    if (validOptions.indexOf(key) === -1) throw new Error(`Option ${key} is unsupported`);
+  });
+
+  this.name = options.name || 'undefined';
+  this.definitions = [];
+  this.sources = [];
+  this.moddleContexts = [];
+  this.moddleOptions = options.moddleOptions;
+
+  if (options.source) {
+    addSource.call(this, options.source);
+  }
+  if (options.moddleContext) {
+    addModdleContext.call(this, options.moddleContext);
+  }
+
+  this._onEnd = this.onEnd.bind(this);
+  this._onError = this.onError.bind(this);
+};
+
+internals.Engine.prototype = Object.create(EventEmitter.prototype);
+
+internals.Engine.resume = function(engineState, executeOptionsOrCallback, callback) {
+  if (!Array.isArray(engineState.definitions)) {
+    throw new Error('State definitions must be an array');
+  }
+
+  let options;
+  if (typeof executeOptionsOrCallback === 'function') {
+    callback = executeOptionsOrCallback;
+    options = {};
+  } else {
+    options = executeOptionsOrCallback;
+  }
+
+  function resumeCallback(err) {
+    if (err) {
+      teardownDefinitions.call(engine);
+      if (callback) return callback.apply(null, arguments);
+      return this.emit('error', err);
+    }
+    if (callback) return callback.apply(null, arguments);
+  }
+
+  const engine = new internals.Engine({
+    name: engineState.name
+  });
+  debug(`<${engine.name}>`, 'resume');
+
+  function resume() {
+    Async.each(engineState.definitions, (definitionState, next) => {
+      const definition = mapper.Definition.resume(definitionState, options, next);
+      engine.definitions.push(definition);
+      setupDefinition.call(engine, definition);
+    }, (err) => {
+      if (err) return resumeCallback.call(engine, err);
+      resumeCallback.call(engine, null, engine.definitions[0], engine.definitions);
+    });
+  }
+
+  process.nextTick(resume);
+
+  return engine;
+};
+
+internals.Engine.prototype.execute = function(executeOptionsOrCallback, callback) {
+  let executeOptions = {};
+  if (typeof executeOptionsOrCallback === 'function') {
+    callback = executeOptionsOrCallback;
+    executeOptions = {};
+  } else {
+    validation.validateOptions(executeOptionsOrCallback);
+    executeOptions = executeOptionsOrCallback;
+  }
+
+  function executeCallback(err) {
+    if (callback) return callback.apply(null, arguments);
+    if (err) this.emit('error', err);
+  }
+
+  this.getDefinitions((getErr, definitions) => {
+    if (getErr) return executeCallback.call(this, getErr);
+    if (!definitions.length) return executeCallback.call(this, new Error('Nothing to execute'));
+
+    debug(`<${this.name}>`, `start all definitions (${definitions.length})`);
+
+    setupDefinitions.call(this, definitions);
+
+    this.started = true;
+    Async.each(definitions, (d, next) => {
+      d.execute(executeOptions, next);
+    }, (err) => {
+      executeCallback.call(this, err, definitions[0], definitions);
+    });
+  });
+};
+
+internals.Engine.prototype.getDefinitions = function(callback) {
+  if (this.definitions.length) return callback(null, this.definitions);
+  return loadDefinitions.call(this, callback);
+};
+
+internals.Engine.prototype.getDefinition = function(callback) {
+  this.getDefinitions((err, definitions) => {
+    if (err) return callback(err);
+    if (definitions.length === 0) return callback();
+    const definition = definitions[0];
+    return callback(null, definition);
+  });
+};
+
+internals.Engine.prototype.addDefinitionBySource = function(source, moddleOptionsOrCallback, callback) {
+  let moddleOptions;
+  if (typeof moddleOptionsOrCallback === 'function') {
+    callback = moddleOptionsOrCallback;
+    moddleOptions = this.moddleOptions;
+  } else {
+    moddleOptions = moddleOptionsOrCallback;
+  }
+
+  getModdleContext(source, moddleOptions, (err, moddleContext) => {
+    if (err) return callback(err);
+    return callback(null, this.addDefinitionByModdleContext(moddleContext));
+  });
+};
+
+internals.Engine.prototype.addDefinitionByModdleContext = function(moddleContext) {
+  const idx = this.definitions.findIndex((d) => d.id === contextHelper.getDefinitionId(moddleContext));
+  const definition = new mapper.Definition(moddleContext);
+  if (idx === -1) {
+    debug(`<${this.name}>`, `add definition <${definition.id}>`);
+    this.definitions.push(definition);
+  } else {
+    debug(`<${this.name}>`, `definition <${definition.id}> is replaced`);
+    this.definitions[idx] = definition;
+  }
+  return definition;
+};
+
+internals.Engine.prototype.getDefinitionById = function(definitionId) {
+  return this.definitions.find((d) => d.id === definitionId);
+};
+
+internals.Engine.prototype.onEnd = function(lastReportingDefinition) {
+  if (this.definitions.every((d) => d.isEnded || d.stopped)) {
+    debug(`<${this.name}>`, 'end');
+    teardownDefinitions.call(this);
+    this.started = false;
+    this.emit('end', lastReportingDefinition);
+  }
+};
+
+internals.Engine.prototype.onError = function() {
+  const args = Array.prototype.slice.call(arguments);
+
+  teardownDefinitions.call(this);
+  this.started = false;
+
+  args.unshift('error');
+  this.emit.apply(this, args);
+};
+
+internals.Engine.prototype.getState = function() {
+  const state = {
+    name: this.name,
+    state: this.started ? 'running' : 'idle',
+    engineVersion: packageVersion
+  };
+
+  state.definitions = this.definitions.map((definition) => {
+    return definition.getState();
+  });
+  return state;
+};
+
+internals.Engine.prototype.getPendingActivities = function() {
+  const pendingState = {
+    name: this.name,
+    state: this.started ? 'running' : 'idle',
+  };
+
+  pendingState.definitions = this.definitions.map((definition) => {
+    return definition.getPendingActivities();
+  });
+  return pendingState;
+};
+
+internals.Engine.prototype.signal = function(activityId, output) {
+  if (!this.started) return;
+
+  for (const defIdx in this.definitions) {
+    const definition = this.definitions[defIdx];
+    const child = definition.getChildActivityById(activityId);
+    if (child && child.waiting) {
+      return definition.signal(activityId, output);
+    }
+  }
+};
+
+internals.Engine.prototype.stop = function() {
+  debug(`<${this.name}>`, 'stop');
+  this.definitions.forEach((d) => d.stop());
+};
+
+function addSource(sourceXml) {
+  if (Buffer.isBuffer(sourceXml)) {
+    this.sources.push(sourceXml.toString());
+  } else if (typeof sourceXml === 'string') {
+    this.sources.push(sourceXml);
+  } else {
+    this.emit('error', new Error('Unparsable Bpmn source'));
+  }
+}
+
+function addModdleContext(moddleContext) {
+  this.moddleContexts.push(moddleContext);
+}
+
+function loadDefinitionBySource(source, callback) {
+  debug(`<${this.name}>`, 'load definition from source');
+  getModdleContext(source, this.moddleOptions, (err, moddleContext) => {
+    if (err) return callback(err);
+    return callback(null, this.addDefinitionByModdleContext(moddleContext));
+  });
+}
+
+function loadDefinitions(callback) {
+  if (this.sources.length) {
+    return Async.map(this.sources, loadDefinitionBySource.bind(this), callback);
+  }
+  if (this.moddleContexts.length) {
+    return callback(null, this.moddleContexts.map(this.addDefinitionByModdleContext.bind(this)));
+  }
+  return callback(null, []);
+}
+
+function setupDefinition(definition) {
+  definition.on('end', this._onEnd);
+  definition.on('error', this._onError);
+}
+
+function setupDefinitions(definitions) {
+  definitions.forEach(setupDefinition.bind(this));
+}
+
+function teardownDefinitions() {
+  this.definitions.forEach((p) => {
+    p.removeListener('end', this._onEnd);
+    p.removeListener('error', this._onError);
+  });
+}
+
+function getModdleContext(source, moddleOptions, callback) {
+  transformer.transform(source, moddleOptions, (err, def, moddleContext) => {
+    return callback(err, moddleContext);
+  });
+}

package/node_modules/@octopus/bpmn/lib/PrematureStopError.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function PrematureStopError() {}
+
+PrematureStopError.prototype = Object.create(Error.prototype);
+
+module.exports = PrematureStopError;