@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/device/opcuaConfig.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+// Pattern to match valid OPC-UA node ID paths, as supported by node-opcua
+// Our validation may be slightly stricter on some value validation.
+// Other OPC-UA solutions may also support nsu namespaces instead of ns, but node-opcua does not appear to.
+const tagPathPattern = /^((ns=\d+);)?((i=\d+)|(g=[0-9A-Fa-f-]+)|(b=[A-Za-z0-9+/]+={0,2})|(s=[^;]+))$/;
+
+// OPCUA supports index range, so accept n or n:m values.
+const tagIndexPattern = /^(\d+)(:(\d+))?$/;
+
+class OpcuaConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    if (_.isEmpty(config.tags)) {
+      // No tags, this should be a softer warning
+      return [];
+    }
+
+    const keyset = Object.keys(config.tags);
+    if (config['opcua-condition-key']) {
+      keyset.push(config['opcua-condition-key']);
+    }
+
+    return _.map(keyset, (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    this.endpoint = config.endpoint;
+
+    this.username = config.username;
+    if (!_.isEmpty(this.username)) {
+      this.username = this.username.toString();
+    }
+
+    this.password = config.password;
+    if (!_.isEmpty(this.password)) {
+      this.password = this.password.toString();
+    }
+
+    this.userCertificatePath = config['user-certificate-path'];
+    this.userPrivateKeyPath = config['user-private-key-path'];
+
+    this.tags = this.loadTags(config.tags);
+    this.conditionKey = config['opcua-condition-key'];
+
+    this.securityMode = this.checkSecurityMode(config['security-mode']);
+    this.securityPolicy = this.checkSecurityPolicy(config['security-policy']);
+    this.readMode = this.checkReadMode(config);
+    this.forceReadOnConnect = !!config['force-read-on-connect'];
+    this.scanInterval = this.checkScanInterval(config);
+  }
+
+  loadTags(tags) {
+    // Shorthand syntax: tags: { name: 'path' }
+    tags = _.mapValues(tags, (tag, name) => {
+      if (_.isString(tag)) {
+        // TODO: We'd really like to examine newlines but YAML strips them.  Another yaml library could surface this.
+        if (/^path\s+/.test(tag)) {
+          throw new ConfigError('Malformed tag definition.  Possible mix of shorthand and standard form.').atSection('tags').atAttribute(name);
+        }
+
+        return { path: tag };
+      }
+      return tag;
+    });
+
+    return _(tags).map((defn, name) => {
+      try {
+        const tagPath = this.checkTagPath(defn);
+        const { type, property } = defn;
+        // let log;
+        // if (defn.log) {
+        //   log = fs.createWriteStream(path.join(this.logDir, defn.log));
+        // }
+
+        return {
+          name,
+          type,
+          property,
+          path: tagPath,
+          index: this.checkIndex(defn),
+          // log,
+          verboseSample: !!defn['verbose-sample'],
+          verboseEmit: !!defn['verbose-emit'],
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`tags.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  checkTagPath(defn) {
+    const path = defn.path;
+    if (!path) {
+      throw new ConfigError('no path specified');
+    }
+
+    if (!tagPathPattern.test(path)) {
+      throw new ConfigError(`Invalid node ID path format: ${path}`).atAttribute('path');
+    }
+
+    return path;
+  }
+
+  checkIndex(defn) {
+    const index = defn.index;
+    if (!index) {
+      return null;
+    }
+
+    const parts = index.toString().match(tagIndexPattern);
+    if (!parts) {
+      throw new ConfigError(`Invalid index or index range: ${index}`).atAttribute('index');
+    }
+
+    const start = +parts[1];
+    const end = parts[3] ? +parts[3] : start;
+    if (start > end) {
+      throw new ConfigError('Index start must be less than end').atAttribute('index');
+    }
+
+    let indexRange = start;
+    if (end > start) {
+      indexRange = `${start}:${end}`;
+    }
+
+    return { start, end, indexRange };
+  }
+
+  checkSecurityMode(defn) {
+    const securityModes = ['None', 'Sign', 'SignAndEncrypt'];
+    if (!defn) {
+      return securityModes[0];
+    }
+    if (!_.includes(securityModes, defn)) {
+      throw new ConfigError(`Security Mode not recognized. Valid values are ${securityModes.join(', ')}`).atAttribute('security-mode');
+    }
+    return defn;
+  }
+
+  checkSecurityPolicy(defn) {
+    const securityPolicies = [
+      'None',
+      'Basic128',
+      'Basic192',
+      'Basic192Rsa15',
+      'Basic256Rsa15',
+      'Basic256Sha256',
+      // new
+      'Aes128_Sha256_RsaOaep',
+      'PubSub_Aes128_CTR',
+      'PubSub_Aes256_CTR',
+      // obsoletes
+      'Basic128Rsa15',
+      'Basic256',
+    ];
+    if (!defn) {
+      return securityPolicies[0];
+    }
+    if (!_.includes(securityPolicies, defn)) {
+      throw new ConfigError(`Security Policy not recognized. Valid values are ${securityPolicies.join(', ')}`).atAttribute('security-policy');
+    }
+    return defn;
+  }
+
+  checkReadMode(defn) {
+    const mode = defn['read-mode'];
+    const readModes = ['subscription', 'polling'];
+    if (!mode) {
+      return readModes[0];
+    }
+    if (!_.includes(readModes, mode)) {
+      throw new ConfigError(`Read mode not recognized.  Valid values are ${readModes.join(', ')}`).atAttribute('read-mode');
+    }
+    return mode;
+  }
+
+  checkScanInterval(defn) {
+    const scanInterval = +(defn['scan-interval'] || 1.0);
+    if (scanInterval <= 0) {
+      throw new ConfigError('scan-interval must be > 0').atAttribute('scan-interval');
+    }
+
+    return Math.ceil(scanInterval * 1000);
+  }
+}
+
+module.exports = OpcuaConfig;

package/lib/config/device/pcccConfig.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const validations = require('../common/validations');
+
+class PcccConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    return _.map(_.keys(config.tags), (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    const { host, port } = validations.checkEndpoint(config, 'endpoint');
+    this.host = host;
+    this.port = port;
+
+    this.scanRate = validations.checkScanInterval(config, 'scan-interval');
+    this.routing = validations.checkBoolean(config, 'routing');
+    this.verboseDevice = validations.checkBoolean(config, 'verbose-device');
+    this.extraVerboseDevice = validations.checkBoolean(config, 'extra-verbose-device');
+    this.deviceTimeout = validations.checkNumber(config, 'device-timeout', { defaultValue: 4.5, min: 1 });
+    this.slot = this.checkSlot(config);
+    this.tags = this.loadTags(config.tags);
+  }
+
+  loadTags(tags) {
+    // Shorthand syntax: tags: { name: 'path' }
+    tags = _.mapValues(tags, (tag, name) => {
+      if (_.isString(tag)) {
+        // TODO: We'd really like to examine newlines but YAML strips them.  Another yaml library could surface this.
+        if (/^path\s+/.test(tag)) {
+          throw new ConfigError('Malformed tag definition.  Possible mix of shorthand and standard form.').atSection('tags').atAttribute(name);
+        }
+
+        return { path: tag };
+      }
+      return tag;
+    });
+
+    return _(tags).map((defn, name) => {
+      try {
+        const tagPath = this.checkTagPath(defn);
+
+        return {
+          name,
+          path: tagPath,
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`tags.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  checkSlot(defn) {
+    const slot = defn.slot || 0;
+    return slot;
+  }
+
+  checkTagPath(defn) {
+    const path = defn.path;
+    if (_.isEmpty(path)) {
+      throw new ConfigError('No tag path specified');
+    }
+
+    if (!/^([A-Za-z]+)(\d+):(\d+)(?:(?:\/(\d+))|(?:\/(?:DN|EN|TT))|(?:\.(?:ACC|PRE|LEN)))?(?:,(\d+))?$/.test(path)) {
+      throw new ConfigError(`Invalid tag path: ${path}`);
+    }
+
+    return path;
+  }
+}
+
+module.exports = PcccConfig;

package/lib/config/engineConfigV1.js

@@ -0,0 +1,382 @@
+'use strict';
+
+const _ = require('lodash');
+const math = require('../math');
+const ConfigError = require('./configError');
+
+class EngineConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => expressionService.addName(name));
+    _.each(this.getExpressions(expressionService.config), name => expressionService.addExpression(name));
+  }
+
+  getIdentifiers(config = {}) {
+    if (!config.input) {
+      return [];
+    }
+
+    return _.map(_.keys(this.loadInputExpressionNames(config.input || {})), (name) => {
+      return {
+        name,
+        channel: 'engine',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  getExpressions(config = {}) {
+    if (!config.input) {
+      return [];
+    }
+
+    const analog = _.pickBy(config.input.analog, defn => _.has(defn, 'pin'));
+    const digital = _.pickBy(config.input.digital, defn => _.has(defn, 'pin'));
+    const counter = _.pickBy(config.input.counter, defn => _.has(defn, 'pin'));
+    const counterSusp = _.pickBy(counter, defn => _.has(defn, 'suspend'));
+
+    return [
+      ..._.map(analog, (defn, name) => {
+        return {
+          path: `input.analog.${name}`,
+          expression: `pin-${defn.pin}`,
+        };
+      }),
+      ..._.map(digital, (defn, name) => {
+        return {
+          path: `input.digital.${name}`,
+          expression: `pin-${defn.pin}`,
+        };
+      }),
+      ..._.map(counter, (defn, name) => {
+        return {
+          path: `input.counter.${name}`,
+          expression: `pin-${defn.pin}`,
+        };
+      }),
+      ..._.map(counterSusp, (defn, name) => {
+        return {
+          path: `input.counter.${name}.suspend`,
+          expression: defn.suspend,
+        };
+      }),
+    ];
+  }
+
+  parse(config = {}) {
+    const input = config.input || {};
+
+    this.scanInterval = config['scan-interval'] || 0.002;
+    this.deviceSourceType = 'value';
+
+    this.inputToExpression = this.loadInputExpressionNames(input);
+    this.expressionToInput = _.invert(this.inputToExpression);
+
+    this.vpins = {
+      ...this.loadAnalogPinInput(input.analog),
+      ...this.loadDigitalPinInput(input.digital),
+      ...this.loadCounterPinInput(input.counter),
+    };
+  }
+
+  loadInputExpressionNames(input) {
+    const names = [
+      ..._.keys(input.analog),
+      ..._.keys(input.digital),
+      ..._.keys(input.counter),
+    ];
+
+    return _(names).keyBy(_.identity).mapValues(_.snakeCase).value();
+  }
+
+  loadCommonPinInput(item, name) {
+    this.checkPin(item);
+    this.checkInputName(name);
+
+    return {
+      name,
+      pin: item.pin,
+      pinName: this.deviceSourceType === 'value' ? `pin-${item.pin}` : item.pin,
+      verboseSample: !!item['verbose-sample'],
+      verboseEmit: !!item['verbose-emit'],
+      logPath: item.log,
+    };
+  }
+
+  loadAnalogPinInput(items) {
+    return _(items).map((defn, name) => {
+      try {
+        const common = this.loadCommonPinInput(defn, name);
+
+        const minDelta = this.checkMinDelta(defn);
+        const sampleInterval = this.checkSampleInterval(defn);
+        const sampleFunc = this.checkSampleFunc(defn);
+        const sampleWindow = this.checkSampleWindow(defn);
+
+        return {
+          ...common,
+          type: 'analog',
+          sampleInterval,
+          sampleFunc,
+          sampleWindow,
+          minDelta,
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`input.analog.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  loadDigitalPinInput(items) {
+    return _(items).map((defn, name) => {
+      try {
+        const common = this.loadCommonPinInput(defn, name);
+
+        const vThresh = this.checkVThresh(defn);
+        const onDelay = this.checkOnDelay(defn);
+        const offDelay = this.checkOffDelay(defn);
+        const filter = this.checkFilter(defn);
+        const onLatch = this.checkOnLatch(defn);
+        const offLatch = this.checkOffLatch(defn);
+
+        return {
+          ...common,
+          type: 'digital',
+          vThresh,
+          invert: !!defn.invert,
+          onDelay,
+          offDelay,
+          filter,
+          onLatch,
+          offLatch,
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`input.digital.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  loadCounterPinInput(items) {
+    return _(items).map((defn, name) => {
+      try {
+        const common = this.loadCommonPinInput(defn, name);
+
+        const vThresh = this.checkVThresh(defn);
+        const edge = this.checkEdge(defn);
+        const onDelay = this.checkOnDelay(defn);
+        const offDelay = this.checkOffDelay(defn);
+        const filter = this.checkFilter(defn);
+        const minPulseWidth = this.checkMinPulseWidth(defn);
+        const maxPulseWidth = this.checkMaxPulseWidth(defn);
+        const suspend = this.checkSuspend(defn);
+        const sourceType = defn['source-type'];
+
+        return {
+          ...common,
+          type: 'counter',
+          sourceType,
+          vThresh,
+          invert: !!defn.invert,
+          risingEdge: edge === 'rising' || edge === 'both',
+          fallingEdge: edge === 'falling' || edge === 'both',
+          onDelay,
+          offDelay,
+          filter,
+          minPulseWidth,
+          maxPulseWidth,
+          suspend,
+          suspendDefinition: defn.suspend,
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`input.counter.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  checkInputName(name) {
+    if (!name.match(/^[A-Za-z0-9-_]+$/)) {
+      throw new ConfigError('input names can only contain alpha-numeric characters, dash, and underscore');
+    }
+    return name;
+  }
+
+  checkPin(defn) {
+    const pin = defn.pin;
+    if (!_.isFinite(pin)) {
+      throw new ConfigError('no pin specified');
+    }
+    if (pin < 0 || pin > 15) {
+      throw new ConfigError('pin must be in range [0-15]').atAttribute('pin');
+    }
+    return pin;
+  }
+
+  checkSampleInterval(defn) {
+    const sampleInterval = defn['sample-interval'] || 1;
+    if (sampleInterval <= 0) {
+      throw new ConfigError('interval must be greater than 0').atAttribute('sample-interval');
+    }
+    return sampleInterval;
+  }
+
+  checkSampleFunc(defn) {
+    const sampleFunc = defn['sample-function'];
+    if (sampleFunc && !_.includes(['avg', 'min', 'max'], sampleFunc)) {
+      throw new ConfigError('valid functions are avg, min, max').atAttribute('sample-function');
+    }
+    return sampleFunc;
+  }
+
+  checkSampleWindow(defn) {
+    const sampleFunc = defn['sample-function'];
+    const sampleWindow = defn['sample-window'];
+
+    if (sampleFunc && !sampleWindow) {
+      throw new ConfigError('a sample-window must be provided when a sample-function is defined');
+    }
+    if (sampleWindow <= 0) {
+      throw new ConfigError('window size must be greater than 0').atAttribute('sample-window');
+    }
+    return parseInt(sampleWindow / this.scanInterval, 10);
+  }
+
+  checkMinDelta(defn) {
+    const minDelta = defn['min-delta'] || 0;
+    if (minDelta < 0) {
+      throw new ConfigError('value must be 0 or greater').atAttribute('min-delta');
+    }
+    return minDelta;
+  }
+
+  checkVThresh(defn) {
+    const vThresh = defn['v-threshold'] || 1.5;
+    if (vThresh <= 0 || vThresh >= 10) {
+      throw new ConfigError('threshold must be in range (0, 10) volts').atAttribute('v-threshold');
+    }
+    return vThresh;
+  }
+
+  checkOnDelay(defn) {
+    const onDelay = defn['on-delay'] || 0;
+    const filter = defn.filter || 0;
+    if (onDelay < 0) {
+      throw new ConfigError('delay must be 0 or greater').atAttribute('on-delay');
+    }
+    if (onDelay && filter > onDelay) {
+      throw new ConfigError('delay must not be less than the specified filter').atAttribute('on-delta');
+    }
+    return onDelay;
+  }
+
+  checkOffDelay(defn) {
+    const offDelay = defn['off-delay'] || 0;
+    const filter = defn.filter || 0;
+    if (offDelay < 0) {
+      throw new ConfigError('delay must be 0 or greater').atAttribute('off-delay');
+    }
+    if (offDelay && filter > offDelay) {
+      throw new ConfigError('delay must not be less than the specified filter').atAttribute('off-delay');
+    }
+    return offDelay;
+  }
+
+  checkOnLatch(defn) {
+    const onLatch = defn['on-latch'] || 0;
+    const offLatch = defn['off-latch'];
+    const offDelay = defn['off-delay'];
+    const filter = defn.filter || 0;
+
+    if (onLatch && offLatch) {
+      throw new ConfigError('not compatible with off-latch option').atAttribute('on-latch');
+    }
+    if (onLatch && offDelay) {
+      throw new ConfigError('not compatible with off-delay option').atAttribute('on-latch');
+    }
+    if (onLatch < 0) {
+      throw new ConfigError('value must be 0 or greater').atAttribute('on-latch');
+    }
+    if (onLatch && filter > onLatch) {
+      throw new ConfigError('value must not be less than the specified filter').atAttribute('on-latch');
+    }
+
+    return onLatch;
+  }
+
+  checkOffLatch(defn) {
+    const offLatch = defn['off-latch'] || 0;
+    const onLatch = defn['on-latch'];
+    const onDelay = defn['on-delay'];
+    const filter = defn.filter || 0;
+
+    if (offLatch && onLatch) {
+      throw new ConfigError('not compatible with on-latch option').atAttribute('off-latch');
+    }
+    if (offLatch && onDelay) {
+      throw new ConfigError('not compatible with on-delay option').atAttribute('off-latch');
+    }
+    if (offLatch < 0) {
+      throw new ConfigError('value must be 0 or greater').atAttribute('off-latch');
+    }
+    if (offLatch && filter > onLatch) {
+      throw new ConfigError('value must not be less than the specified filter').atAttribute('off-latch');
+    }
+
+    return offLatch;
+  }
+
+  checkFilter(defn) {
+    const filter = defn.filter || 0;
+    if (filter < 0) {
+      throw new ConfigError('filter must be 0 or greater').atAttribute('filter');
+    }
+    return filter;
+  }
+
+  checkEdge(defn) {
+    const edge = defn['trigger-edge'] || 'rising';
+    if (!_.includes(['rising', 'falling', 'both'], edge)) {
+      throw new ConfigError('value must be rising, falling, or both').atAttribute('trigger-edge');
+    }
+    return edge;
+  }
+
+  checkMinPulseWidth(defn) {
+    const minPulseWidth = defn['min-pulse-width'] || 0;
+    if (minPulseWidth < 0) {
+      throw new ConfigError('width must be 0 or greater').atAttribute('min-pulse-width');
+    }
+    return minPulseWidth;
+  }
+
+  checkMaxPulseWidth(defn) {
+    const maxPulseWidth = defn['max-pulse-width'] || 0;
+    if (maxPulseWidth < 0) {
+      throw new ConfigError('width must be 0 or greater').atAttribute('max-pulse-width');
+    }
+    return maxPulseWidth;
+  }
+
+  checkSuspend(defn) {
+    if (!defn.suspend) {
+      return null;
+    }
+
+    try {
+      return math.compile(defn.suspend);
+    } catch (err) {
+      throw new ConfigError(`Problem evaluating suspend expression: ${err.message}`).atAttribute('suspend');
+    }
+  }
+}
+
+module.exports = EngineConfig;