@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/device/mqttBaseConfig.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class MqttBaseConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers() {
+    return [];
+  }
+
+  parse(config = {}) {
+    this.endpoint = this.checkEndpoint(config);
+    this.telemetryRate = this.checkTelemetryRate(config);
+
+    this.username = this.checkUsername(config);
+    this.password = this.checkPassword(config);
+  }
+
+  checkEndpoint(defn) {
+    const endpoint = defn.endpoint;
+    if (_.isEmpty(endpoint)) {
+      throw new ConfigError('An MQTT endpoint must be specified').atPath('endpoint');
+    }
+
+    return endpoint;
+  }
+
+  checkTelemetryRate(defn) {
+    const rate = _.get(defn, 'telemetry-rate', 1);
+    if (!_.isNumber(rate) || rate <= 0) {
+      throw new ConfigError('telemetry-rate must be >= 0').atPath('telemetry-rate');
+    }
+
+    return rate;
+  }
+
+  checkUsername(defn) {
+    const username = defn.username;
+    if (_.isEmpty(username)) {
+      return null;
+    }
+
+    if (!_.isString(username) && !_.isNumber(username)) {
+      throw new ConfigError('Username must be a string').atPath('username');
+    }
+
+    return String(username);
+  }
+
+  checkPassword(defn) {
+    const password = defn.password;
+    if (_.isEmpty(password)) {
+      return null;
+    }
+
+    if (!_.isString(password) && !_.isNumber(password)) {
+      throw new ConfigError('Password must be a string').atPath('password');
+    }
+
+    return String(password);
+  }
+}
+
+module.exports = MqttBaseConfig;

package/lib/config/device/mqttConfig.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const MqttBaseConfig = require('./mqttBaseConfig');
+const validations = require('../common/validations');
+const { checkJsonPropPath } = require('../common/jsonPath');
+
+class MqttConfig extends MqttBaseConfig {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(expressionService) {
+    super(expressionService);
+  }
+
+  getIdentifiers(config = {}) {
+    const keys = [];
+    _.each(config.topics, (val) => {
+      if (_.isString(val)) {
+        keys.push(val);
+      } else if (_.isObject(val?.json)) {
+        keys.push(...Object.keys(val.json));
+      }
+    });
+
+    return _.map(keys, (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  device() {
+    return 'mqtt';
+  }
+
+  parse(config = {}) {
+    this.endpoint = this.checkEndpoint(config);
+    this.telemetryRate = this.checkTelemetryRate(config);
+
+    this.username = this.checkUsername(config);
+    this.password = this.checkPassword(config);
+
+    this.topics = this.loadTopics(config.topics);
+    this.reset = validations.checkReset(config);
+  }
+
+  loadTopics(topics = {}) {
+    return _(topics).map((defn, topic) => {
+      let subSection = '';
+      try {
+        if (_.isString(defn)) {
+          defn = { type: 'raw', key: defn };
+        }
+
+        if (!_.isObject(defn)) {
+          throw new ConfigError('Unexpected topic structure');
+        }
+
+        const type = this.checkType(defn);
+        if (type === 'raw') {
+          // Simple raw topic value
+          return {
+            topic,
+            type: 'raw',
+            key: defn.key,
+          };
+        } else if (type === 'json') {
+          subSection = 'json';
+          this.checkJson(defn);
+
+          // JSON prop collection
+          return {
+            topic,
+            type: 'json',
+            json: defn.json,
+          };
+        }
+
+        throw new ConfigError('Unexpected topic type');
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          let section = `topics.${topic}`;
+          if (subSection) {
+            section += `.${subSection}`;
+          }
+          error.atSection(section);
+        }
+        throw error;
+      }
+    }).keyBy('topic').value();
+  }
+
+  checkType(defn) {
+    const type = defn.type ?? 'json';
+    if (!_.includes(['raw', 'json'], type)) {
+      throw new ConfigError('Type must be one of [raw, json]').atAttribute('type');
+    }
+    return type;
+  }
+
+  checkJson(defn) {
+    const json = defn.json;
+    if (!_.isObject(json)) {
+      throw new ConfigError('JSON block must be collection of prop names and JSON paths').atAttribute('json');
+    }
+
+    _.each(json, (prop, key) => checkJsonPropPath(prop, key));
+  }
+}
+
+module.exports = MqttConfig;

package/lib/config/device/mqttLincolnConfig.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const MqttBaseConfig = require('./mqttBaseConfig');
+
+const fixedKeys = [
+  // telemetry
+  'current', 'voltage', 'wire_speed', 'motor_current', 'true_energy', 'weld_record',
+  // summary
+  'summary_avg_current', 'summary_avg_voltage', 'summary_avg_wire_speed', 'summary_avg_motor_current',
+  'summary_avg_gas_flow', 'consumable_density', 'consumable_diameter', 'summary_duration',
+  // derived
+  'execution', 'weldcount', 'consumable_rate', 'control_board_serial', 'observed_serials',
+  'summary_wire_length', 'summary_wire_mass',
+];
+
+class MqttLincolnConfig extends MqttBaseConfig {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(expressionService) {
+    super(expressionService);
+  }
+
+  getIdentifiers() {
+    return _.map(fixedKeys, (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    this.endpoint = this.checkEndpoint(config);
+    this.telemetryRate = this.checkTelemetryRate(config);
+    this.serial = this.checkSerial(config);
+    this.username = this.checkUsername(config);
+    this.password = this.checkPassword(config);
+  }
+
+  postParse(config) {
+    _.each(fixedKeys, (key) => {
+      config.adapter.loadDataItem(key, key);
+    });
+  }
+
+  checkSerial(defn) {
+    const serial = defn.serial;
+    if (_.isNil(serial)) {
+      return null;
+    }
+
+    if (!_.isString(serial) && !_.isNumber(serial)) {
+      throw new ConfigError('Invalid serial').atPath('serial');
+    }
+
+    return String(serial);
+  }
+}
+
+module.exports = MqttLincolnConfig;

package/lib/config/device/mtconnectAdapterConfig.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const MTConnectBaseConfig = require('./mtconnectBaseConfig');
+const ConfigError = require('../configError');
+
+class MTConnectAdapterConfig extends MTConnectBaseConfig {
+  parse(config = {}) {
+    super.parse(config);
+
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.parseEndpoint(config.endpoint);
+    // TODO: Chase down local address translation
+  }
+
+  device() {
+    return 'mtconnect-adapter';
+  }
+
+  parseEndpoint(endpoint) {
+    if (!endpoint) {
+      throw new ConfigError('No endpoint defined').atAttribute('endpoint');
+    }
+
+    if (endpoint.match(/^local\s+/)) {
+      this.localAddress = endpoint.replace(/^local\s+/, '');
+      return;
+    }
+
+    if (!endpoint.match(/^[\w.]+(:\d+)?$/)) {
+      throw new ConfigError('Invalid endpoint').atAttribute('endpoint');
+    }
+
+    const [host, port] = endpoint.split(':');
+    this.host = host;
+    this.port = port || 7878;
+  }
+}
+
+module.exports = MTConnectAdapterConfig;

package/lib/config/device/mtconnectBaseConfig.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const _ = require('lodash');
+const AllowDenyList = require('../common/allowDenyList');
+const ConfigError = require('../configError');
+const validations = require('../common/validations');
+
+const allowDeny = new AllowDenyList();
+
+class MTConnectBaseConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    return _.map(config['declare-keys'], (name) => {
+      if (_.isObject(name)) {
+        name = _.first(_.keys(name));
+      }
+
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.mtconnectPassthrough = this.parsePassthrough(config);
+    this.allowKeyPatterns = allowDeny.parseWildcardKeyList(config['allow-keys'], 'allow-keys');
+    this.denyKeyPatterns = allowDeny.parseWildcardKeyList(config['deny-keys'], 'deny-keys');
+    this.keys = this.parseDeclaredKeysList(config);
+    this.enforceAvailCheck = validations.checkBoolean(config, 'enforce-avail-check', { defaultValue: true });
+
+    this.sourceKeys = _(this.keys).map('source').uniq().value();
+
+    this.aliasMap = this.createAliasMap(this.keys);
+  }
+
+  mtconnectKeys() {
+    return this.keys;
+  }
+
+  parsePassthrough(config) {
+    if (_.isUndefined(config['mtconnect-passthrough'])) {
+      return true;
+    }
+    return !!config['mtconnect-passthrough'];
+  }
+
+  parseDeclaredKeysList(config) {
+    let attribute = 'declare-keys';
+    if (!config[attribute] && config.keys) {
+      attribute = 'keys';
+    }
+
+    const keys = config[attribute];
+    if (_.isEmpty(keys)) {
+      return [];
+    }
+    if (!_.isArray(keys)) {
+      throw new ConfigError('list expected').atAttribute(attribute);
+    }
+
+    const parsedKeys = _(keys).map((key) => {
+      if (_.isObject(key)) {
+        const name = _.first(_.keys(key));
+        const body = key[name];
+        if (_.isObject(body)) {
+          let sourceName = name;
+          if (_.has(body, 'key')) {
+            sourceName = body.key;
+          }
+          const type = body.type ?? 'value';
+
+          return {
+            name,
+            source: sourceName,
+            type,
+          };
+        }
+
+        return {
+          name,
+          source: body,
+          type: 'value',
+        };
+      }
+
+      return {
+        name: key,
+        source: key,
+        type: 'value',
+      };
+    }).value();
+
+    // Check for duplicate key names
+    const keyNames = _.map(parsedKeys, 'name');
+    const duplicates = _(keyNames)
+      .groupBy()
+      .pickBy(x => x.length > 1)
+      .keys()
+      .value();
+
+    if (duplicates.length > 0) {
+      throw new ConfigError(`duplicate key names found: ${duplicates.join(', ')}`).atAttribute(attribute);
+    }
+
+    return _.keyBy(parsedKeys, 'name');
+  }
+
+  createAliasMap(keys) {
+    const aliasMap = {};
+    const sourceKeys = _(keys).map('source').uniq().value();
+
+    const aliasNames = _.uniq(_.map(_.filter(keys, k => k.name !== k.source), 'name'));
+    _.each(sourceKeys, (sourceKey) => {
+      aliasMap[sourceKey] = [];
+    });
+    _.each(aliasNames, (alias) => {
+      const key = keys[alias];
+      aliasMap[key.source].push(alias);
+    });
+
+    return aliasMap;
+  }
+}
+
+module.exports = MTConnectBaseConfig;

package/lib/config/device/mtconnectConfig.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const MTConnectBaseConfig = require('./mtconnectBaseConfig');
+const ConfigError = require('../configError');
+
+class MTConnectConfig extends MTConnectBaseConfig {
+  constructor(expressionService) {
+    super(expressionService);
+    this.defaultPort = '5000';
+  }
+
+  parse(config = {}) {
+    super.parse(config);
+
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.endpoint = this.parseEndpoint(config.endpoint);
+    this.verboseScanning = !!config['verbose-scanning'];
+    this.haasMode = !!config['haas-mode'];
+  }
+
+  device() {
+    return 'mtconnect';
+  }
+
+  parseEndpoint(endpointString) {
+    if (!endpointString) {
+      throw new ConfigError('No endpoint defined').atAttribute('endpoint');
+    }
+
+    // HTTP/S URLs are returned directly
+    if (endpointString.match(/^https?:\/\//)) {
+      return endpointString;
+    } else if (endpointString.match(/^\w+:\/\//)) {
+      throw new ConfigError('Unexpected endpoint protocol').atAttribute('endpoint');
+    }
+
+    let endpoint = endpointString;
+    // If no port is provided, specify 5000 by default
+    if (!endpointString.match(/:\d+/)) {
+      const [baseEndpoint, ...path] = endpointString.split('/');
+      endpoint = `${baseEndpoint}:${this.defaultPort}/${path.join('/')}`;
+    }
+
+    // Assume HTTP protocol by default
+    return `http://${endpoint}`;
+  }
+}
+
+module.exports = MTConnectConfig;

package/lib/config/device/mtconnectHaasConfig.js

@@ -0,0 +1,15 @@
+const MTConnectConfig = require('./mtconnectConfig');
+
+class MTConnectHaas extends MTConnectConfig {
+  constructor(expressionService) {
+    super(expressionService);
+    this.defaultPort = '8082';
+    this.haasMode = 1;
+  }
+
+  device() {
+    return 'mtconnect-haas';
+  }
+}
+
+module.exports = MTConnectHaas;

package/lib/config/device/nullConfig.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class NullConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    return _.map(config['declare-keys'], (name) => {
+      if (_.isObject(name)) {
+        name = _.first(_.keys(name));
+      }
+
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    if (config.device !== 'local') {
+      return;
+    }
+
+    this.keys = this.parseDeclaredKeysList(config);
+    this.sourceKeys = _(this.keys).map('source').uniq().value();
+  }
+
+  parseDeclaredKeysList(config) {
+    let attribute = 'declare-keys';
+    if (!config[attribute] && config.keys) {
+      attribute = 'keys';
+    }
+
+    const keys = config[attribute];
+    if (_.isEmpty(keys)) {
+      return [];
+    }
+    if (!_.isArray(keys)) {
+      throw new ConfigError('list expected').atAttribute(attribute);
+    }
+
+    return _(keys).map((key) => {
+      if (_.isObject(key)) {
+        const name = _.first(_.keys(key));
+        const body = key[name];
+        if (_.isObject(body)) {
+          const sourceName = body.key;
+          const type = body.type;
+
+          return {
+            name,
+            source: sourceName,
+            type,
+          };
+        }
+
+        return {
+          name,
+          source: name,
+          type: body,
+        };
+      }
+
+      return {
+        name: key,
+        source: key,
+        type: 'value',
+      };
+    }).keyBy('name').value();
+  }
+}
+
+module.exports = NullConfig;