@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/engineConfigV2.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('./configError');
+const TransformConfigUtil = require('./transformConfigUtil');
+
+class EngineConfig {
+  constructor(expressionService, config = {}, device = {}) {
+    this.expressionService = expressionService;
+    this.config = config;
+    this.device = device;
+
+    this.configUtil = new TransformConfigUtil(expressionService);
+
+    _.each(this.getIdentifiers(this.config), (ident) => {
+      if (!expressionService.isNameValid(ident.name)) {
+        throw new ConfigError(`variable name '${ident.name}' is not a valid name`).atSection('variables').atAttribute(ident.name);
+      } else if (expressionService.isNameDefined(ident.name)) {
+        throw new ConfigError(`variable name '${ident.name}' already defined in earlier section`).atSection('variables').atAttribute(ident.name);
+      }
+
+      expressionService.addName(ident);
+    });
+
+    // Standard identifier for devices to indicate whether they are fully connected or not
+    expressionService.addName({
+      name: 'device-connected',
+      channel: 'system',
+      defaultValue: false,
+    });
+
+    // Remap source shorthand format, ex:
+    // variables:
+    //   path1: input1 + 5
+    //   part1: composite.parts
+    //
+    // to:
+    // variables:
+    //   path1:
+    //     - source: input1 + 5
+    //   part1:
+    //     - source: composite.parts
+
+    this.config.variables = _.mapValues(this.config.variables, (variable) => {
+      if (_.isString(variable)) {
+        return [{ source: variable }];
+      }
+      return variable;
+    });
+
+    _.each(this.getExpressions(this.config), name => expressionService.addExpression(name));
+    _.each(this.getStringExpressions(this.config), name => expressionService.addStringExpression(name));
+  }
+
+  getIdentifiers(config = {}) {
+    if (!config.variables) {
+      return [];
+    }
+
+    return _.map(_.keys(config.variables), (name) => {
+      return {
+        name,
+        channel: 'engine',
+        defaultValue: 0, // TODO: Should figure out from final listed transform
+      };
+    });
+  }
+
+  getStringExpressions(config = {}) {
+    if (!config.variables) {
+      return [];
+    }
+
+    return this.configUtil.getStringExpressionsFromVariables(config.variables);
+  }
+
+  getExpressions(config = {}) {
+    if (!config.variables) {
+      return [];
+    }
+
+    return this.configUtil.getExpressionsFromVariables(config.variables);
+  }
+
+  parse(config = {}) {
+    this.scanInterval = config['scan-interval'] || 0.002;
+
+    this.variableNames = [];
+
+    this.variables = this.loadVariables(config);
+  }
+
+  loadVariables(defn) {
+    if (!defn.variables) {
+      return {};
+    }
+
+    this.variableNames = _.keys(defn.variables);
+
+    return _.mapValues(defn.variables, (variable, name) => {
+      return this.configUtil.loadTransformList(variable, `variables.${name}`, true);
+    });
+  }
+}
+
+module.exports = EngineConfig;

package/lib/config/generator/counterGenConfig.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const validations = require('../common/validations');
+
+class CounterGenConfig {
+  generatorName() {
+    return 'counter';
+  }
+
+  parse(config = {}) {
+    this.interval = validations.checkInterval(config, 'interval', 1);
+  }
+}
+
+module.exports = CounterGenConfig;

package/lib/config/generator/cronGenConfig.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const _ = require('lodash');
+const cronosjs = require('cronosjs');
+const ConfigError = require('../configError');
+const validations = require('../common/validations');
+
+class CronGenConfig {
+  generatorName() {
+    return 'cron';
+  }
+
+  parse(config = {}) {
+    this.cron = this.checkCron(config);
+    this.duration = validations.checkInterval(config, 'duration', 1);
+    this.timezone = validations.checkTimezone(config, 'timezone');
+  }
+
+  checkCron(defn) {
+    const cron = defn.cron;
+    if (_.isEmpty(cron)) {
+      throw new ConfigError('A valid cron expression must be specified').atAttribute('cron');
+    }
+
+    if (!cronosjs.validate(cron)) {
+      throw new ConfigError('Invalid or unsupported cron expression').atAttribute('cron');
+    }
+
+    return cron;
+  }
+}
+
+module.exports = CronGenConfig;

package/lib/config/generator/dateTimeGenConfig.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const validations = require('../common/validations');
+
+class DateTimeGenConfig {
+  generatorName() {
+    return 'datetime';
+  }
+
+  parse(config = {}) {
+    this.format = this.checkDateFormat(config);
+    this.interval = validations.checkInterval(config, 'interval', 1);
+    this.utc = this.checkUTC(config);
+    this.timezone = validations.checkTimezone(config, 'timezone');
+  }
+
+  checkDateFormat(defn) {
+    const dateFormat = defn.format ?? 'YYYY-MM-DDTHH:mm:ss';
+    if (_.isEmpty(dateFormat)) {
+      throw new ConfigError('A date format must be specified').atPath('format');
+    }
+
+    return dateFormat;
+  }
+
+  checkUTC(defn) {
+    return !!(defn.utc ?? true);
+  }
+}
+
+module.exports = DateTimeGenConfig;

package/lib/config/index.js

@@ -0,0 +1,339 @@
+'use strict';
+
+const _ = require('lodash');
+const yaml = require('yaml');
+const ConfigError = require('./configError');
+const EngineConfigV1 = require('./engineConfigV1');
+const EngineConfigV2 = require('./engineConfigV2');
+const AdapterConfig = require('./adapterConfig');
+const LabjackU3Config = require('./device/labjackU3Config');
+const LabjackT4Config = require('./device/labjackT4Config');
+const LabjackT7Config = require('./device/labjackT7Config');
+const OPCUAConfig = require('./device/opcuaConfig');
+const AdamConfig = require('./device/adam-6052Config');
+const MTConnectConfig = require('./device/mtconnectConfig');
+const MTConnectHaasConfig = require('./device/mtconnectHaasConfig');
+const MTConnectAdapterConfig = require('./device/mtconnectAdapterConfig');
+const ModbusTcpConfig = require('./device/modbusTcpConfig');
+const EthernetIPConfig = require('./device/ethernetIPConfig');
+const PcccConfig = require('./device/pcccConfig');
+const ExpressionService = require('../expressionService');
+const BrotherHTTPConfig = require('./device/brotherHTTPConfig');
+const MqttConfig = require('./device/mqttConfig');
+const MqttLincolnConfig = require('./device/mqttLincolnConfig');
+const NullConfig = require('./device/nullConfig');
+const IfmIotConfig = require('./device/ifmIotConfig');
+const JsonHttpConfig = require('./device/jsonHttpConfig');
+const DateTimeGenConfig = require('./generator/dateTimeGenConfig');
+const CounterGenConfig = require('./generator/counterGenConfig');
+const CronGenConfig = require('./generator/cronGenConfig');
+
+class Config {
+  constructor(configJson, options = {}) {
+    this.json = configJson;
+
+    this.document = options.document;
+
+    this.skipValidate = configJson['skip-validate'] ?? false;
+    this.port = configJson['mtconnect-port'];
+
+    this.diagnosticPort = configJson['diagnostic-port'];
+
+    this.deviceName = this.checkDevice(configJson);
+    this.configVersion = this.checkVersion(configJson);
+    this.engineVersion = this.checkEngineVersion(configJson);
+    this.replayEndTime = this.checkReplayCollection(configJson);
+
+    this.machineId = configJson.id;
+    this.machineRef = configJson['machine-ref'];
+    this.sourceRef = configJson['source-id'];
+
+    this.expressionService = new ExpressionService(configJson);
+
+    this.device = this.protectedCall('createDeviceConfig', () => {
+      return this.getDeviceConfig(this.deviceName, this.expressionService);
+    });
+
+    this.generators = this.protectedCall('createGeneratorConfig', () => {
+      return _.mapValues(configJson.generators, (generator, name) => {
+        this.expressionService.addName({
+          name,
+          channel: 'generator',
+          defaultValue: 0,
+        });
+        return this.getGeneratorConfig(generator.type);
+      });
+    });
+
+    this.engine = this.protectedCall('createEngineConfig', () => {
+      if (this.configVersion === 1) {
+        return new EngineConfigV1(this.expressionService);
+      } else if (this.configVersion === 2) {
+        return new EngineConfigV2(this.expressionService, this.json, this.device);
+      }
+      return null;
+    });
+
+    this.adapter = this.protectedCall('createAdapterConfig', () => {
+      return new AdapterConfig(this.expressionService, this.engine);
+    });
+
+    this.protectedCall('parseDevice', this.device.parse.bind(this.device, configJson));
+
+    _.each(this.generators, (generator, name) => {
+      this.protectedCall('parseGenerator', generator.parse.bind(generator, configJson.generators[name]));
+    });
+
+    this.protectedCall('parseEngine', this.engine.parse.bind(this.engine, configJson));
+    this.protectedCall('parseAdapter', this.adapter.parse.bind(this.adapter, configJson));
+
+    if (this.engine.postParse) {
+      this.protectedCall('postParseEngine', this.engine.postParse.bind(this.engine, this));
+    }
+    if (this.device.postParse) {
+      this.protectedCall('postParseDevice', this.device.postParse.bind(this.device, this));
+    }
+  }
+
+  protectedCall(sectionName, fn) {
+    try {
+      return fn();
+    } catch (err) {
+      err.extra = this.getErrorContext({
+        ...err?.extra,
+        section: sectionName,
+      });
+      throw err;
+    }
+  }
+
+  getErrorContext(context = {}) {
+    return {
+      machineId: this.machineId,
+      machineRef: this.machineRef,
+      sourceRef: this.sourceRef,
+      mtconnectPort: this.port,
+      diagnosticPort: this.diagnosticPort,
+      deviceName: this.deviceName,
+      configVersion: this.configVersion,
+      skipValidate: this.skipValidate,
+      ...context,
+    };
+  }
+
+  static async loadFile(filepath, options = {}) {
+    // eslint-disable-next-line global-require
+    const fs = require('fs/promises');
+
+    const file = await fs.readFile(filepath, 'utf8');
+    return this.load(file, options);
+  }
+
+  static load(data, options = {}) {
+    const cst = yaml.parseCST(data);
+    const document = new yaml.Document({ keepCstNodes: true }).parse(cst[0]);
+    if (_.size(document.errors) > 0) {
+      const error = _.first(document.errors);
+      const startPos = error.source.rangeAsLinePos.start;
+      const endPos = error.source.rangeAsLinePos.end;
+      let lineMessage = `line ${startPos.line}`;
+      if (startPos.line !== endPos.line) {
+        lineMessage = `lines ${startPos.line} - ${endPos.line}`;
+      }
+      throw new ConfigError(`YAML Error (${lineMessage}): ${error.message}`);
+    }
+
+    // Caller may wish to inject additional properties that are not part of the YAML document
+    if (!_.isEmpty(options.inject)) {
+      let inject = options.inject;
+      if (_.isString(inject)) {
+        try {
+          inject = yaml.parse(inject);
+        } catch (err) {
+          throw new ConfigError(`Injection Error: ${err.message}`);
+        }
+      }
+      if (!_.isObject(inject) || _.isArray(inject)) {
+        throw new ConfigError('Injection Error: Expected object');
+      }
+
+      _.each(inject, (val, key) => {
+        if (!document.get(key)) {
+          document.set(key, val);
+        }
+      });
+    }
+
+    const parsed = document.toJSON();
+
+    return new Config(parsed, { ...options, document });
+  }
+
+  dumpYaml() {
+    if (this.document) {
+      return this.document.toString();
+    }
+
+    const document = new yaml.Document();
+    document.contents = this.json;
+    return document.toString();
+  }
+
+  getGeneratorConfig(genName) {
+    switch (genName) {
+      case 'datetime':
+        return new DateTimeGenConfig();
+      case 'counter':
+        return new CounterGenConfig();
+      case 'cron':
+        return new CronGenConfig();
+      default:
+        throw new ConfigError(`Generator ${genName} not implemented`);
+    }
+  }
+
+  getDeviceConfig(deviceName, expressionService) {
+    switch (deviceName) {
+      case 'labjack-u3':
+        return new LabjackU3Config(expressionService);
+      case 'labjack-t4':
+        return new LabjackT4Config(expressionService);
+      case 'labjack-t7':
+        return new LabjackT7Config(expressionService);
+      case 'opc-ua':
+        return new OPCUAConfig(expressionService);
+      case 'brother':
+      case 'brother-http':
+        return new BrotherHTTPConfig(expressionService);
+      case 'adam-6052':
+        return new AdamConfig(expressionService);
+      case 'mtconnect':
+        return new MTConnectConfig(expressionService);
+      case 'mtconnect-haas':
+        return new MTConnectHaasConfig(expressionService);
+      case 'mtconnect-adapter':
+        return new MTConnectAdapterConfig(expressionService);
+      case 'modbus-tcp':
+        return new ModbusTcpConfig(expressionService);
+      case 'ethernet-ip':
+        return new EthernetIPConfig(expressionService);
+      case 'ab-pccc':
+        return new PcccConfig(expressionService);
+      case 'mqtt':
+        return new MqttConfig(expressionService);
+      case 'mqtt-lincoln':
+        return new MqttLincolnConfig(expressionService);
+      case 'iolink-ifm-iot':
+        return new IfmIotConfig(expressionService);
+      case 'json-http':
+        return new JsonHttpConfig(expressionService);
+      case 'local':
+        return new NullConfig(expressionService);
+      default:
+        throw new ConfigError(`Device ${this.device} not implemented`);
+    }
+  }
+
+  /**
+   * Checks 'version' top-level attribute
+   *
+   * Optional.  Specifies the major version of the config language.  Additive changes to the language, such as new
+   * attributes, would not warrant introducing a new config version.  Defaults to the deprecated version 1.
+   */
+  checkVersion(json) {
+    const version = json.version || 1;
+    const supportedVersions = [1, 2];
+    if (!_.includes(supportedVersions, version)) {
+      throw new ConfigError(`Unsupported config version.  Valid versions are: ${supportedVersions.join(', ')}`).atAttribute('version');
+    }
+
+    return version;
+  }
+
+  /**
+   * Checks 'engine-version' top-level attribute
+   *
+   * Optional.  Under normal circumstances this will never be specified.  It can be used to overlay an old
+   * config language over a new engine, if supported.
+   */
+  checkEngineVersion(json) {
+    const version = json.version || 1;
+    let engineVersion = json['engine-version'];
+    if (!engineVersion) {
+      if (version === 1) {
+        engineVersion = 1;
+      } else if (version === 2) {
+        engineVersion = 2;
+      }
+    }
+
+    const supportedEngineVersions = [1, 2];
+    if (!_.includes(supportedEngineVersions, engineVersion)) {
+      throw new ConfigError(`Unsupported engine version.  Valid versions are: ${supportedEngineVersions.join(', ')}`).atAttribute('engine-version');
+    }
+    if (version === 2 && engineVersion === 1) {
+      throw new ConfigError('Config version 2 is not compatible with engine version 1').atAttribute('engine-version');
+    }
+
+    return engineVersion;
+  }
+
+  checkReplayCollection(json) {
+    let collectUntil = json['collect-replay-until'];
+    if (collectUntil) {
+      // Dates that include time component will be parsed in local time if no zone is specified; default to UTC
+      if (!collectUntil.search(/T\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/)) {
+        collectUntil = `${collectUntil}Z`;
+      }
+
+      const untilTime = Date.parse(collectUntil);
+      if (Number.isNaN(untilTime)) {
+        throw new ConfigError(`Invalid ISO date: ${collectUntil}`).atAttribute('collect-replay-until');
+      }
+
+      return untilTime;
+    }
+
+    return null;
+  }
+
+  /**
+   * Checks 'device' top-level attribute
+   *
+   * Required.  Devices are data sources, such as IO devices or tag servers.
+   */
+  checkDevice(json) {
+    const device = json.device;
+    if (!device) {
+      throw new ConfigError('No device specified');
+    }
+
+    const supportedDevices = [
+      'labjack-u3',
+      'labjack-t4',
+      'labjack-t7',
+      'opc-ua',
+      'brother',
+      'brother-http',
+      'adam-6052',
+      'mtconnect',
+      'mtconnect-haas',
+      'mtconnect-adapter',
+      'modbus-tcp',
+      'ethernet-ip',
+      'mqtt',
+      'mqtt-lincoln',
+      'iolink-ifm-iot',
+      'json-http',
+      'local',
+      'ab-pccc',
+    ];
+    if (!_.includes(supportedDevices, device)) {
+      throw new ConfigError(`Unsupported device.  Valid devices are: ${supportedDevices.join(', ')}`).atAttribute('device');
+    }
+
+    return device;
+  }
+}
+
+module.exports = Config;