@machinemetrics/io-adapter-lib 2.32.0

package/lib/engine/engineV2.js

@@ -0,0 +1,719 @@
+'use strict';
+
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+
+class EngineV2 extends EventEmitter {
+  constructor(config = {}, options = {}) {
+    super();
+    this.pool = {};
+    this.inputSource = {};
+    this.pendingAttach = [];
+    this.updateFuncs = {};
+    this.sources = [];
+
+    this.expressionService = config.expressionService;
+
+    // References variable chains directly
+    this.variablePool = {};
+    this.priorityPool = {};
+
+    this.nextVariableIndex = 0;
+    this.lastUpdateTime = 0;
+
+    this.logDir = options.logDir || '.';
+    this.logger = options.logger || {
+      error: () => {},
+      warn: () => {},
+      info: () => {},
+    };
+
+    this.deviceOutput = options.deviceOutput;
+
+    this.initSystem();
+    this.resetStatistics();
+  }
+
+  resetStatistics() {
+    this.stats = {
+      currentStateCalls: 0,
+      updateCyclesDetected: 0,
+      unavailCyclesDetected: 0,
+    };
+  }
+
+  initSystem() {
+    _.each(this.expressionService.definedNames('system'), (name) => {
+      if (!this.pool[name]) {
+        const state = this.createStandardState(name);
+        this.pool[name] = state;
+        this.emit('add-item', state);
+      }
+    });
+  }
+
+  addVariable(name, chain) {
+    const state = this.createStandardState(name);
+    state.isVariable = true;
+
+    state.variableOrder = this.nextVariableIndex;
+    this.nextVariableIndex += 1;
+
+    chain.chainEnd().on('update', (value, time, context) => {
+      state.updateFromChain(value, time, { context });
+    });
+    chain.chainEnd().on('unavailable', (time, context) => {
+      state.setUnavailable(time, { context });
+    });
+    chain.chainEnd().on('error', (err, time, context) => {
+      state.recordError(err, time, context);
+    });
+
+    this.pool[name] = state;
+    this.variablePool[name] = chain;
+
+    if (chain.chainSupportsPendingChange()) {
+      this.priorityPool[name] = chain;
+    }
+
+    this.emit('add-item', state);
+  }
+
+  getVariableNames() {
+    const variables = Object.values(this.pool).filter(s => s.isVariable);
+    variables.sort((a, b) => a.variableOrder - b.variableOrder);
+    return variables.map(v => v.name);
+  }
+
+  getImmediateDependencies(name) {
+    const state = this.pool[name];
+    if (!state || !state.isVariable) {
+      return [];
+    }
+
+    const path = `variables.${state.name}`;
+    const names = this.expressionService.referencedNamesByPath[path] ?? [];
+    names.sort((a, b) => (this.pool[a]?.id ?? -1) - (this.pool[b]?.id ?? -1));
+
+    return names;
+  }
+
+  getExtendedDependencies(name) {
+    const state = this.pool[name];
+    if (!state || !state.isVariable) {
+      return [];
+    }
+
+    const found = new Set();
+    const explored = new Set();
+
+    const explore = (name) => {
+      explored.add(name);
+
+      const path = `variables.${name}`;
+      const deps = this.expressionService.referencedNamesByPath[path] ?? [];
+
+      deps.forEach(d => {
+        found.add(d);
+        if (!explored.has(d)) {
+          explore(d);
+        }
+      });
+    };
+
+    explore(name);
+
+    const names = Array.from(found);
+    names.sort((a, b) => (this.pool[a]?.id ?? -1) - (this.pool[b]?.id ?? -1));
+
+    return names;
+  }
+
+  /**
+   * Inactivates all inputs and variables except for the given identifiers and their extended dependencies
+   *
+   * @param {*} names
+   */
+  setFocus(names) {
+    const keep = (names ?? []).reduce((accum, name) => {
+      this.getExtendedDependencies(name).forEach((dep) => {
+        accum.add(dep);
+      });
+      return accum;
+    }, new Set(names));
+
+    Object.values(this.pool).forEach((state) => {
+      state.active = keep.has(state.name);
+    });
+  }
+
+  clearFocus() {
+    Object.values(this.pool).forEach((state) => {
+      state.active = true;
+    });
+  }
+
+  currentState() {
+    this.stats.currentStateCalls += 1;
+    return _.mapValues(this.pool, 'value');
+  }
+
+  getState(name) {
+    return this.pool[name];
+  }
+
+  normalizeTime(time) {
+    if (this.sources.length > 1 && time < this.lastUpdateTime) {
+      time = this.lastUpdateTime;
+    } else {
+      this.lastUpdateTime = time;
+    }
+
+    return time;
+  }
+
+  updateStateValue(name, value, time) {
+    const context = { sourceType: 'source', trigger: name };
+
+    // Check all variables that might have pending changes occuring before <time>
+    this.probe(context, time);
+
+    // With all potential earlier pending changes resolved, report this state change
+    if (this.pool[name]) {
+      this.pool[name].update(value, time, { context });
+    }
+  }
+
+  updateConditionValue(name, value, time, code, message) {
+    const context = { sourceType: 'source', trigger: name };
+
+    // Check all variables that might have pending changes occuring before <time>
+    this.probe(context, time);
+
+    // With all potential earlier pending changes resolved, report this state change
+    if (this.pool[name]) {
+      this.pool[name].update(value, time, code, message, { context });
+    }
+  }
+
+  probe(context, time) {
+    // Check all variables that might have pending changes occuring before <time>
+    while (true) { // eslint-disable-line no-constant-condition
+      const [chain, pendingTime] = this.getNextPendingVariable(time);
+      if (chain === null) {
+        break;
+      }
+
+      // A probe call "refreshes" the chain at the specified time with the last value it was updated with.
+      // This may or may not result in a value change (and thus a recursive updateStateValue call)
+      // Excessively deep call stacks should hopefully be tempered by these recursive calls having earlier timestamps
+      // and thus fewer candidate pending changes to further call into.
+      chain.probeOrForward(context, pendingTime);
+    }
+  }
+
+  // Find the variable chain with the earliest pending change that is scheduled before the given time
+  getNextPendingVariable(time) {
+    let nextChain = null;
+    let nextChangeTime = null;
+
+    _.each(this.priorityPool, (chain) => {
+      const changeTime = chain.chainNextPendingChange(time);
+      if (changeTime === null || changeTime >= time) {
+        return;
+      }
+
+      if (nextChangeTime === null || changeTime < nextChangeTime) {
+        nextChain = chain;
+        nextChangeTime = changeTime;
+      }
+    });
+
+    return [nextChain, nextChangeTime];
+  }
+
+  addSource(source) {
+    this.sources.push(source);
+
+    if (source.sourceType === 'value') {
+      this.addValueSource(source);
+    } else if (source.sourceType === 'mtconnect') {
+      this.addMtconnectSource(source);
+    } else if (source.sourceType === 'generator') {
+      this.addGeneratorSource(source);
+    }
+  }
+
+  addGeneratorSource(source) {
+    if (!this.pool[source.name]) {
+      const state = this.createStandardState(source.name);
+      this.pool[source.name] = state;
+      this.emit('add-item', state);
+    }
+
+    source.on('update', (value, time) => {
+      time = this.normalizeTime(time);
+      this.updateStateValue(source.name, value, time);
+
+      if (this.deviceOutput) {
+        this.deviceOutput.add(source.name, value, time);
+      }
+    });
+  }
+
+  addValueSource(source) {
+    _.each(this.expressionService.referencedNames('device'), (name) => {
+      if (!this.pool[name]) {
+        const state = this.createStandardState(name);
+        this.pool[name] = state;
+        this.emit('add-item', state);
+      }
+    });
+
+    source.on('update', (key, value, time) => {
+      time = this.normalizeTime(time);
+      this.updateStateValue(key, value, time);
+
+      if (this.deviceOutput) {
+        this.deviceOutput.add(key, value, time);
+      }
+    });
+
+    source.on('probe', (time) => {
+      time = this.normalizeTime(time);
+      const context = { sourceType: 'source', trigger: '[probe]' };
+      this.probe(context, time);
+    });
+
+    source.on('unavailable', (time) => {
+      time = this.normalizeTime(time);
+      const context = { sourceType: 'source', trigger: '[unavailable]' };
+      this.probe(context, time);
+
+      _.each(this.expressionService.referencedNames('device'), (name) => {
+        if (this.pool[name]) {
+          this.pool[name].setUnavailable(time, { context });
+        }
+
+        if (this.deviceOutput) {
+          this.deviceOutput.add(name, 'UNAVAILABLE', time);
+        }
+      });
+    });
+
+    source.on('add-input', (name) => {
+      if (!this.pool[name]) {
+        const state = this.createStandardState(name);
+        this.pool[name] = state;
+        this.emit('add-item', state);
+      }
+    });
+
+    // Some devices may support 'subscribing' to specfic engine variables by implementing two methods
+    if (source.getTrackedVariables && source.updateVariable) {
+      _.each(source.getTrackedVariables(), (name) => {
+        if (this.pool[name]) {
+          this.pool[name].on('update', (value, time) => {
+            source.updateVariable(name, value, time);
+          });
+        }
+      });
+    }
+
+    source.on('update-condition', (key, fields, time) => {
+      this.emit('update-condition', key, fields, time);
+    });
+  }
+
+  addMtconnectSource(source) {
+    let mkeys = {};
+    if (source.mtconnectKeys) {
+      mkeys = _.keyBy(source.mtconnectKeys(), 'name');
+    }
+
+    const names = new Set([...this.expressionService.referencedNames('device'), ...Object.keys(mkeys)]);
+    _.each(Array.from(names), (name) => {
+      if (!this.pool[name]) {
+        let state = null;
+        if (mkeys[name]?.type === 'condition') {
+          state = this.createConditionState(name);
+        } else {
+          state = this.createStandardState(name);
+        }
+
+        this.pool[name] = state;
+        this.emit('add-item', state);
+      }
+    });
+
+    _.each(mkeys, (msource) => {
+      let func = null;
+      if (msource.type === 'value') {
+        func = (value, time) => {
+          this.updateStateValue(msource.name, value, time);
+        };
+      } else if (msource.type === 'condition') {
+        func = (value, time) => {
+          this.updateConditionValue(msource.name, value.level, time, value.code, value.message);
+        };
+      }
+
+      if (func) {
+        if (!this.updateFuncs[msource.name]) {
+          this.updateFuncs[msource.name] = [];
+        }
+
+        this.updateFuncs[msource.name].push(func);
+      }
+    });
+
+    const poolUpdate = (key, updateFunc, _time) => {
+      if (!this.pool[key]) {
+        const state = this.createStandardState(key);
+        this.pool[key] = state;
+        this.emit('add-item', state);
+      }
+
+      updateFunc();
+    };
+
+    // valueOf is available on native Date, Moment, and Luxon objects to get milli epoch timestamp
+    // valueOf on a number passes back the number
+    const parseTimestamp = (time) => {
+      return time?.valueOf();
+    };
+
+    // Non-passthrough update function only pumps the engine's variable pool
+    source.on('update', (key, value, time) => {
+      const poolTime = this.normalizeTime(parseTimestamp(time) / 1000.0);
+      time = poolTime * 1000.0;
+
+      if (this.updateFuncs[key]) {
+        _.each(this.updateFuncs[key], func => poolUpdate(key, () => func(value, poolTime), poolTime));
+      } else {
+        poolUpdate(key, () => {
+          if (this.pool[key] instanceof ConditionState) {
+            this.updateConditionValue(key, value.level, time, value.code, value.message);
+          } else {
+            this.updateStateValue(key, value, poolTime);
+          }
+        }, poolTime);
+      }
+    });
+
+    source.on('probe', (time) => {
+      const context = { sourceType: 'source', trigger: '[probe]' };
+
+      time = this.normalizeTime(parseTimestamp(time) / 1000.0);
+      this.probe(context, time);
+    });
+
+    source.on('update-sample', (key, value, time) => {
+      const poolTime = this.normalizeTime(parseTimestamp(time) / 1000.0);
+      time = poolTime * 1000.0;
+
+      if (this.updateFuncs[key]) {
+        _.each(this.updateFuncs[key], func => poolUpdate(key, () => func(value, poolTime), poolTime));
+      } else {
+        poolUpdate(key, () => this.updateStateValue(key, value, poolTime), poolTime);
+      }
+
+      if (this.deviceOutput) {
+        this.deviceOutput.add(key, value, poolTime);
+      }
+
+      this.emit('update-sample', key, value, time);
+    });
+
+    source.on('update-condition', (key, fields, time) => {
+      const poolTime = this.normalizeTime(parseTimestamp(time) / 1000.0);
+      time = poolTime * 1000.0;
+
+      if (this.updateFuncs[key]) {
+        _.each(this.updateFuncs[key], func => poolUpdate(key, () => func(fields, poolTime), poolTime));
+      } else {
+        poolUpdate(key, () => this.updateStateValue(key, fields.level || 'NORMAL', poolTime), poolTime);
+      }
+
+      this.emit('update-condition', key, fields, time);
+    });
+
+    source.on('update-message', (key, value, time) => {
+      const poolTime = this.normalizeTime(parseTimestamp(time) / 1000.0);
+      time = poolTime * 1000.0;
+
+      if (this.updateFuncs[key]) {
+        _.each(this.updateFuncs[key], func => poolUpdate(key, () => func(value, poolTime), poolTime));
+      } else {
+        poolUpdate(key, () => this.updateStateValue(key, value, poolTime), poolTime);
+      }
+
+      this.emit('update-message', key, value, time);
+    });
+  }
+
+  createStandardState(name) {
+    const state = new DataState(name);
+    this.attachStateHandlers(state);
+
+    return state;
+  }
+
+  createConditionState(name) {
+    const state = new ConditionState(name);
+    this.attachStateHandlers(state);
+
+    return state;
+  }
+
+  attachStateHandlers(state) {
+    state.on('update', () => {
+      this.emit('update', state.name, state.value, state.valueTime);
+    });
+    state.on('unavailable', (time) => {
+      this.emit('unavailable', state.name, time);
+    });
+    state.on('cycle-update', () => {
+      this.stats.updateCyclesDetected += 1;
+    });
+    state.on('cycle-unavailable', () => {
+      this.stats.unavailCyclesDetected += 1;
+    });
+  }
+}
+
+let stateNextId = 1;
+
+class DataState extends EventEmitter {
+  constructor(name) {
+    super();
+    this.id = stateNextId;
+    this.name = name;
+    this.defaultValue = 0;
+    this.value = 0;
+    this.valueTime = 0;
+    this.updateTime = 0;
+    this.changeCount = 0;
+    this.updateCount = 0;
+    this.available = false;
+    this.errorCount = 0;
+    this.lastError = null;
+    this.lastErrorTime = 0;
+    this.lastErrorContext = null;
+    this.errorHistory = [];
+    this.valueHistory = [];
+    this.inUpdate = false;
+    this.active = true;
+
+    stateNextId += 1;
+  }
+
+  // options:
+  //   forceEmit: Emit update even if value hasn't changed
+  //   engineUpdate: Whether the normal "update" event should be emitted in addition to "update-unfiltered"
+  //     Engine updates should occur for variables updated at the end of their op chains or for device values
+  //   context: Specifies source and name of identifier causing update
+
+  update(value, time, options = {}) {
+    if (value === 'UNAVAILABLE' && !this.isVariable) {
+      this.updateInner(value, time, { ...options, engineUpdate: false });
+      this.setUnavailable(time, options);
+    } else {
+      this.updateInner(value, time, { ...options, engineUpdate: !this.isVariable });
+    }
+  }
+
+  updateFromChain(value, time, options = {}) {
+    this.updateInner(value, time, { ...options, engineUpdate: true });
+  }
+
+  updateInner(value, time, options = {}) {
+    if (this.inUpdate) {
+      this.recordError('Execution cycle detected on UPDATE', time, options.context);
+      this.setUnavailable(time, { ...options, breakCycle: true });
+      this.emit('cycle-update', this);
+      this.inUpdate = true;
+      return;
+    }
+
+    try {
+      if (!this.available || !_.isEqual(this.value, value) || options.forceEmit) {
+        this.value = value;
+        this.valueTime = time;
+        this.available = true;
+        this.changeCount += 1;
+
+        if (this.valueHistory.length > 10) {
+          this.valueHistory.shift();
+        }
+
+        this.valueHistory.push({
+          value: options.historyValue ?? value,
+          valueTime: time,
+          available: true,
+        });
+
+        if (options.engineUpdate && this.active) {
+          this.inUpdate = true;
+          this.emit('update', value, time);
+          this.inUpdate = false;
+        }
+      }
+
+      this.updateTime = time;
+      this.updateCount += 1;
+
+      if (this.active) {
+        this.inUpdate = true;
+        this.emit('update-unfiltered', value, time, options.context);
+        this.inUpdate = false;
+      }
+    } catch (err) {
+      this.recordError(err, time, options.context);
+      this.inUpdate = false;
+    }
+  }
+
+  setUnavailable(time, options = {}) {
+    this.value = this.defaultValue;
+    this.valueTime = time;
+    this.available = false;
+
+    if (this.valueHistory.length > 10) {
+      this.valueHistory.shift();
+    }
+    this.valueHistory.push({
+      value: this.defaultValue,
+      valueTime: time,
+      available: false,
+    });
+
+    if (this.inUpdate) {
+      if (!options.breakCycle) {
+        this.recordError('Execution cycle detected on UNAVAILABLE', time, options.context);
+        this.emit('cycle-unavailable', this);
+      }
+      return;
+    }
+
+    try {
+      if (this.active) {
+        this.inUpdate = true;
+        this.emit('unavailable', time, options.context);
+        this.inUpdate = false;
+      }
+    } catch (err) {
+      this.recordError(err, time, options.context);
+      this.inUpdate = false;
+    }
+  }
+
+  recordError(err, time, context) {
+    this.errorCount += 1;
+    this.lastError = err;
+    this.lastErrorTime = time;
+    this.lastErrorContext = context;
+
+    if (this.errorHistory.length > 10) {
+      this.errorHistory.shift();
+    }
+    this.errorHistory.push({
+      error: err,
+      errorTime: time,
+      errorContext: context,
+    });
+  }
+}
+
+class ConditionState extends DataState {
+  constructor(name) {
+    super(name);
+
+    const handler = {
+      get: (target, name) => {
+        if (target[name]) {
+          return target[name];
+        }
+        return {
+          code: null,
+          level: this.sharedLevel,
+          message: '',
+        };
+      },
+
+      set: (target, name, value) => {
+        target[name] = value;
+        return true;
+      },
+    };
+
+    this.sharedLevel = 'UNAVAILABLE';
+    this.state = new Proxy({}, handler);
+  }
+
+  update(value, time, code, message, options = {}) {
+    const prevSharedLevel = this.sharedLevel;
+    if (value === 'UNAVAILABLE') {
+      this.sharedLevel = value;
+    } else {
+      this.sharedLevel = 'NORMAL';
+    }
+
+    message ??= '';
+    let forceEmit = false;
+    const historyValue = { code, value, message, time };
+
+    if (code) {
+      if (this.state[code]?.code === null) {
+        this.state[code] = {
+          code,
+          level: this.sharedLevel,
+          message: '',
+        };
+        forceEmit = true;
+      }
+
+      if (this.state[code].level !== value || this.state[code].message !== message) {
+        this.state[code].code = code;
+        this.state[code].level = value;
+        this.state[code].updateTime = time;
+        this.state[code].message = message;
+        forceEmit = true;
+      }
+
+      this.state[code].valueTime = time;
+    } else if (value === 'NORMAL' || value === 'UNAVAILABLE') {
+      Object.values(this.state).forEach((s) => {
+        s.level = value;
+        s.message = message;
+        s.valueTime = time;
+        s.updateTime = time;
+      });
+
+      if (value !== prevSharedLevel) {
+        forceEmit = true;
+      }
+    }
+
+    super.update(this.state, time, { ...options, forceEmit, historyValue });
+  }
+
+  setUnavailable(time, options = {}) {
+    Object.values(this.state).forEach((s) => {
+      s.value = 'UNAVAILABLE';
+      s.valueTime = time;
+    });
+
+    super.setUnavailable(time, options);
+  }
+
+  getLevel(code) {
+    return this.state[code]?.value ?? 'UNAVAILABLE';
+  }
+
+  getMessage(code) {
+    return this.state[code]?.message ?? '';
+  }
+}
+
+module.exports = EngineV2;