@wiotp/sdk 0.4.2 → 0.6.2

package/dist/BaseClient.js

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _events = _interopRequireDefault(require("events"));
+
+var _mqtt = _interopRequireDefault(require("mqtt"));
+
+var _loglevel = _interopRequireDefault(require("loglevel"));
+
+var _tinycache = _interopRequireDefault(require("tinycache"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var uuidv4 = require('uuid/v4');
+
+var BaseClient =
+/*#__PURE__*/
+function (_events$EventEmitter) {
+  _inherits(BaseClient, _events$EventEmitter);
+
+  function BaseClient(config) {
+    var _this;
+
+    _classCallCheck(this, BaseClient);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(BaseClient).call(this));
+    _this.log = _loglevel["default"];
+
+    _this.log.setDefaultLevel(config.options.logLevel);
+
+    _this.config = config;
+    _this.reconnectLog = 0;
+    _this.mqtt = null;
+    _this.lostConnectionLog = new _tinycache["default"]();
+    return _this;
+  }
+
+  _createClass(BaseClient, [{
+    key: "isConnected",
+    value: function isConnected() {
+      if (this.mqtt == null) {
+        return false;
+      }
+
+      return this.mqtt.connected;
+    }
+  }, {
+    key: "connect",
+    value: function connect() {
+      var _this2 = this;
+
+      if (this.mqtt != null) {
+        this.log.info("[BaseClient:connect] Reconnecting to " + this.config.getMqttHost() + " as " + this.config.getClientId());
+        this.mqtt.reconnect();
+        return;
+      }
+
+      this.log.info("[BaseClient:connect] Connecting to " + this.config.getMqttHost() + " as " + this.config.getClientId());
+      this.mqtt = _mqtt["default"].connect(this.config.getMqttHost(), this.config.getMqttConfig());
+      /* Events coming from mqtt
+       * Event 'connect' - Emitted on successful (re)connection (i.e. connack rc=0).
+       * Event 'reconnect' - Emitted when a reconnect starts.
+       * Event 'close' - Emitted after a disconnection.
+       * Event 'offline' - Emitted when the client goes offline.
+       * Event 'error' - Emitted when the client cannot connect (i.e. connack rc != 0) or when a parsing error occurs.
+       * Event 'end' - Emitted when mqtt.Client#end() is called. If a callback was passed to mqtt.Client#end(), this event is emitted once the callback returns.
+       * Event 'message' - Emitted when the client receives a publish packet
+       * Event 'packetsend' - Emitted when the client sends any packet. This includes .published() packets as well as packets used by MQTT for managing subscriptions and connections
+       * Event 'packetreceive' - Emitted when the client receives any packet. This includes packets from subscribed topics as well as packets used by MQTT for managing subscriptions and connections
+       */
+
+      this.mqtt.on('connect', function () {
+        _this2.log.info("[BaseClient:onConnect] MQTT client is connected.");
+
+        _this2.emit('connect'); // less than 3 connect attempts you get put to a connect delay of 1 second
+        // after 3 connect attempts you get put to a connect delay of 2 seconds (3 seconds elapsed - 3 attempts @ 1 second intervals)
+        // after 6 connect attempts you get put to a connect delay of 5 seconds (3 + 6 seconds elapsed - 3 attempts @ 2 second intervals)
+        // after 9 connect attempts you get put to a connect delay of 20 seconds (3 + 6 + 15 seconds elapsed - 3 attempts @ 5 second intervals)
+
+
+        var connectionLostCount = _this2.lostConnectionLog.size; // Default is 1 second reconnect period
+
+        var reconnectPeriod = 1000;
+
+        if (connectionLostCount >= 9) {
+          reconnectPeriod = 20000; // Log this and raise the error EVERY time we reconnect under these conditions.
+
+          _this2.log.warn("[BaseClient:onOffline] This client is likely suffering from clientId stealing (where two connections try to use the same client Id).");
+
+          _this2.emit("error", "Exceeded 9 connection losses in a 5 minute period.  Check for clientId conflict with another connection.");
+        } else if (connectionLostCount >= 6) {
+          reconnectPeriod = 5000;
+        } else if (connectionLostCount >= 3) {
+          reconnectPeriod = 2000;
+        }
+
+        if (reconnectPeriod != _this2.mqtt.options.reconnectPeriod) {
+          _this2.log.info("[BaseClient:onOffline] Client has lost connection " + connectionLostCount + " times during the last 5 minutes, reconnect delay adjusted to " + reconnectPeriod + " ms");
+
+          _this2.mqtt.options.reconnectPeriod = reconnectPeriod;
+        }
+      });
+      this.mqtt.on('reconnect', function () {
+        _this2.log.info("[BaseClient:onReconnect] MQTT client is reconnecting."); // this.log.debug("[BaseClient:onReconnect] Resubscribe topics:");
+        // this.log.debug(this.mqtt._resubscribeTopics);
+
+
+        _this2.emit('reconnect');
+      });
+      this.mqtt.on('close', function () {
+        _this2.log.info("[BaseClient:onClose] MQTT client connection was closed.");
+
+        _this2.emit('close');
+      });
+      this.mqtt.on('offline', function () {
+        var newId = uuidv4();
+
+        _this2.log.info("[BaseClient:onOffline] MQTT client connection is offline. [" + newId + "]");
+
+        _this2.emit('offline'); // Record the disconnect event for 5 minutes
+
+
+        _this2.lostConnectionLog.put(newId, '1', 300000);
+
+        var connectionLostCount = _this2.lostConnectionLog.size;
+
+        _this2.log.info("[BaseClient:onOffline] Connection losses in the last 5 minutes: " + connectionLostCount);
+      });
+      this.mqtt.on('error', function (error) {
+        _this2.log.error("[BaseClient:onError] " + error);
+
+        var errorMsg = '' + error;
+
+        if (errorMsg.indexOf('Not authorized') > -1) {
+          _this2.log.error("[BaseClient:onError] One or more configuration parameters are wrong. Modify the configuration before trying to reconnect.");
+
+          _this2.mqtt.end(false, function () {
+            _this2.log.info("[BaseClient:onError] Closed the MQTT connection due to client misconfiguration");
+          });
+        }
+
+        _this2.emit('error', error);
+      });
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      var _this3 = this;
+
+      if (this.mqtt == null) {
+        this.log.info("[BaseClient:disconnect] Client was never connected");
+        return;
+      }
+
+      this.mqtt.end(false, function () {
+        _this3.log.info("[BaseClient:disconnect] Closed the MQTT connection due to disconnect() call");
+      });
+    }
+  }, {
+    key: "_subscribe",
+    value: function _subscribe(topic, QoS, callback) {
+      if (this.mqtt == null) {
+        this.emit('error', "[BaseClient:_subscribe] MQTT Client is not initialized - call connect() first");
+        return;
+      }
+
+      if (!this.mqtt.connected) {
+        this.emit('error', "[BaseClient:_subscribe] MQTT Client is not connected - call connect() first");
+        return;
+      }
+
+      QoS = QoS || 0;
+
+      callback = callback || function (err, granted) {
+        if (err == null) {
+          for (var index in granted) {
+            var grant = granted[index];
+            this.log.debug("[BaseClient:_subscribe] Subscribed to " + grant.topic + " at QoS " + grant.qos);
+          }
+        } else {
+          this.log.error("[BaseClient:_subscribe] " + err);
+          this.emit("error", err);
+        }
+      }.bind(this);
+
+      this.log.debug("[BaseClient:_subscribe] Subscribing to topic " + topic + " with QoS " + QoS);
+      this.mqtt.subscribe(topic, {
+        qos: parseInt(QoS)
+      }, callback);
+    }
+  }, {
+    key: "_unsubscribe",
+    value: function _unsubscribe(topic, callback) {
+      if (this.mqtt == null) {
+        this.emit('error', "[BaseClient:_unsubscribe] MQTT Client is not initialized - call connect() first");
+        return;
+      }
+
+      if (!this.mqtt.connected) {
+        this.emit('error', "[BaseClient:_unsubscribe] MQTT Client is not connected - call connect() first");
+        return;
+      }
+
+      callback = callback || function (err) {
+        if (err == null) {
+          this.log.debug("[BaseClient:_unsubscribe] Unsubscribed from: " + topic);
+        } else {
+          this.log.error("[BaseClient:_unsubscribe] " + err);
+          this.emit("error", err);
+        }
+      }.bind(this);
+
+      this.log.debug("[BaseClient:_unsubscribe] Unsubscribe: " + topic);
+      this.mqtt.unsubscribe(topic, callback);
+    }
+  }, {
+    key: "_publish",
+    value: function _publish(topic, msg, QoS, callback) {
+      QoS = QoS || 0;
+
+      if ((_typeof(msg) === 'object' || typeof msg === 'boolean' || typeof msg === 'number') && !Buffer.isBuffer(msg)) {
+        // mqtt library does not support sending JSON/Boolean/Number data. So stringifying it.
+        // All JSON object, array will be encoded.
+        msg = JSON.stringify(msg);
+      }
+
+      this.log.debug("[BaseClient:_publish] Publish: " + topic + ", " + msg + ", QoS : " + QoS);
+      this.mqtt.publish(topic, msg, {
+        qos: parseInt(QoS)
+      }, callback);
+    }
+  }]);
+
+  return BaseClient;
+}(_events["default"].EventEmitter);
+
+exports["default"] = BaseClient;

package/dist/BaseConfig.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/**
+ *****************************************************************************
+ Copyright (c) 2019 IBM Corporation and other Contributors.
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License v1.0
+ which accompanies this distribution, and is available at
+ http://www.eclipse.org/legal/epl-v10.html
+ *****************************************************************************
+ *
+ */
+var BaseConfig =
+/*#__PURE__*/
+function () {
+  function BaseConfig(identity, auth, options) {
+    _classCallCheck(this, BaseConfig);
+
+    this.identity = identity;
+    this.auth = auth;
+    this.options = options; // Validation for options common to all confiugration
+
+    if (this.options != null && "mqtt" in this.options) {
+      // validate port
+      if ("port" in this.options.mqtt && this.options.mqtt.port != null) {
+        if (isNaN(this.options.mqtt.port)) {
+          throw new Error("Optional setting options.mqtt.port must be a number if provided");
+        }
+      } // Validate cleanStart
+
+
+      if ("cleanStart" in this.options.mqtt && typeof this.options.mqtt.cleanStart != "boolean") {
+        throw new Error("Optional setting options.mqtt.cleanStart must be a boolean if provided");
+      }
+    } // Set defaults for optional configuration
+
+
+    if (this.options == null) {
+      this.options = {};
+    }
+
+    if (!("domain" in this.options) || this.options.domain == null) {
+      this.options.domain = "internetofthings.ibmcloud.com";
+    }
+
+    if (!("logLevel" in this.options) || this.options.logLevel == null) {
+      this.options.logLevel = "info";
+    }
+
+    if (!("mqtt" in this.options)) {
+      this.options.mqtt = {};
+    }
+
+    if (!("port" in this.options.mqtt) || this.options.mqtt.port == null) {
+      this.options.mqtt.port = 8883;
+    }
+
+    if (!("transport" in this.options.mqtt) || this.options.mqtt.transport == null) {
+      this.options.mqtt.transport = "tcp";
+    }
+
+    if (!("cleanStart" in this.options.mqtt)) {
+      this.options.mqtt.cleanStart = true;
+    }
+
+    if (!("sessionExpiry" in this.options.mqtt)) {
+      this.options.mqtt.sessionExpiry = 3600;
+    }
+
+    if (!("keepAlive" in this.options.mqtt)) {
+      this.options.mqtt.keepAlive = 60;
+    }
+
+    if (!("caFile" in this.options.mqtt)) {
+      this.options.mqtt.caFile = null;
+    }
+  }
+
+  _createClass(BaseConfig, [{
+    key: "getOrgId",
+    value: function getOrgId() {
+      throw new Error("Sub class must implement getOrgId()");
+    }
+  }, {
+    key: "isQuickstart",
+    value: function isQuickstart() {
+      return this.getOrgId() == "quickstart";
+    }
+  }, {
+    key: "getClientId",
+    value: function getClientId() {
+      throw new Error("Sub class must implement getClientId()");
+    }
+  }, {
+    key: "getMqttUsername",
+    value: function getMqttUsername() {
+      throw new Error("Sub class must implement getMqttUsername()");
+    }
+  }, {
+    key: "getMqttPassword",
+    value: function getMqttPassword() {
+      throw new Error("Sub class must implement getMqttPassowrd()");
+    }
+  }, {
+    key: "getMqttConfig",
+    value: function getMqttConfig() {
+      // See: https://www.npmjs.com/package/mqtt#mqttclientstreambuilder-options
+      var mqttConfig = {
+        // Identity
+        clientId: this.getClientId(),
+        // Basic Connectivity
+        keepalive: this.options.mqtt.keepAlive,
+        // in seconds
+        connectTimeout: 90 * 1000,
+        // milliseconds, time to wait before a CONNACK is received
+        reconnectPeriod: 1000,
+        // milliseconds, interval between two reconnections
+        queueQoSZero: true,
+        // if connection is broken, queue outgoing QoS zero messages
+        resubscribe: true,
+        // if connection is broken and reconnects, subscribed topics are automatically subscribed again
+        clean: this.options.mqtt.cleanStart,
+        //  set to false to receive QoS 1 and 2 messages while offline
+        // Authentication
+        username: this.getMqttUsername(),
+        password: this.getMqttPassword(),
+        // Security
+        // If you are using a self-signed certificate, pass the rejectUnauthorized: false option. Beware 
+        // that you are exposing yourself to man in the middle attacks, so it is a configuration that 
+        // is not recommended for production environments.
+        rejectUnauthorized: true // MQTTv5 support doesn't work with Watson IoT Platform, so stick to default for now
+        // protocolId: "MQTT",
+        // protocolVersion: 5
+
+      };
+      return mqttConfig;
+    }
+  }, {
+    key: "getMqttHost",
+    value: function getMqttHost() {
+      var server = this.getOrgId() + ".messaging." + this.options.domain + ":" + this.options.mqtt.port; // For unencrpyted ports
+
+      if (this.options.mqtt.port == 80 || this.options.mqtt.port == 1883) {
+        if (this.options.mqtt.transport == "tcp") {
+          return "tcp://" + server;
+        }
+
+        if (this.options.mqtt.transport == "websockets") {
+          return "ws://" + server;
+        }
+      } // For encrypted ports
+
+
+      if (this.options.mqtt.port == 433 || this.options.mqtt.port == 8883) {
+        if (this.options.mqtt.transport == "tcp") {
+          return "ssl://" + server;
+        }
+
+        if (this.options.mqtt.transport == "websockets") {
+          return "wss://" + server;
+        }
+      } // Default to something, but really shouldn't hit this scenario unless misconfigured
+
+
+      return "ssl://" + server;
+    }
+  }], [{
+    key: "parseEnvVars",
+    value: function parseEnvVars() {
+      throw new Error("Sub class must implement parseEnvVars()");
+    }
+  }, {
+    key: "parseConfigFile",
+    value: function parseConfigFile() {
+      throw new Error("Sub class must implement parseConfigFile()");
+    }
+  }]);
+
+  return BaseConfig;
+}();
+
+exports["default"] = BaseConfig;
+;