@alwaysai/device-agent 1.5.0 → 2.0.1

package/src/cloud-connection/connection-manager.ts

@@ -0,0 +1,187 @@
+import * as awsIot from 'aws-iot-device-sdk';
+import {
+  DEVICE_CERTIFICATE_FILE_PATH,
+  DEVICE_PRIVATE_KEY_FILE_PATH
+} from 'alwaysai/lib/infrastructure';
+import { AWS_ROOT_CERTIFICATE_FILE_PATH } from '../util/directories';
+import { stringifyError } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { MessageDispatcher, MessageHandler } from './message-dispatcher';
+
+const exec_promise = promisify(exec);
+
+export class ConnectionManager extends MessageDispatcher<any> {
+  private clientId: string;
+  private host: string;
+  private port: number;
+  private device = awsIot.device;
+  private subscribedTopics: Set<string> = new Set();
+
+  constructor(clientId: string, host: string, port: number) {
+    super();
+    this.clientId = clientId;
+    this.host = host;
+    this.port = port;
+  }
+
+  public getIoTDevice() {
+    return this.device;
+  }
+
+  public setupConnection(): void {
+    this.connect();
+  }
+
+  public connect(): void {
+    try {
+      this.device = awsIot.device({
+        keyPath: DEVICE_PRIVATE_KEY_FILE_PATH,
+        certPath: DEVICE_CERTIFICATE_FILE_PATH,
+        caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
+        clientId: this.clientId,
+        host: this.host,
+        port: this.port,
+        keepalive: 10 // time before re-connect attempt on dropped connection, default is 400 seconds
+      });
+      this.setupHandlers();
+    } catch (error) {
+      logger.error(`Error connecting to cloud!\n${stringifyError(error)}`);
+      this.handleReconnection();
+    }
+  }
+
+  public registerHandler(topic: string, handler: MessageHandler) {
+    super.registerHandler(topic, handler);
+    this.subscribe(topic);
+  }
+
+  public disconnect(): void {
+    if (this.device) {
+      this.device.end();
+      logger.debug(`Device Agent has been disconnected from the AWS IoT Core.`);
+    }
+  }
+
+  public subscribe(topic: string): void {
+    if (this.device && !this.subscribedTopics.has(topic)) {
+      this.device.subscribe(topic);
+      this.subscribedTopics.add(topic);
+      logger.debug(`Subscribed to topic: ${topic}`);
+    }
+  }
+
+  public unsubscribe(topic: string): void {
+    if (this.device && this.subscribedTopics.has(topic)) {
+      this.device.unsubscribe(topic);
+      this.subscribedTopics.delete(topic);
+      logger.debug(`Unsubscribed from topic: ${topic}`);
+    }
+  }
+
+  public isConnected(): boolean {
+    return this.device ? this.device.connected : false;
+  }
+
+  private handleReconnection() {
+    logger.debug(`Attempting to reconnect to AWS IoT Core...`);
+    setTimeout(() => this.connect(), 5000); // try in 5 seconds.
+  }
+
+  private setupHandlers(): void {
+    this.device.on('connect', (connack: any) => {
+      logger.info('Device Agent has connected to the cloud.');
+    });
+
+    this.device.on('disconnect', () => {
+      logger.warn('Device Agent has been disconnected from the cloud');
+    });
+
+    this.device.on('reconnect', () => {
+      logger.info(
+        `Device Agent attempting to re-connect ${new Date().toLocaleString()}`
+      );
+    });
+
+    this.device.on('error', function (e) {
+      logger.error(
+        `Error connecting to the AWS IoT Core!\n${stringifyError(e)}`
+      );
+    });
+
+    this.device.on('close', () => {
+      logger.warn('Device Agent AWS IoT Core connection closed.');
+    });
+
+    this.device.on('offline', () => {
+      logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
+      void this.logConnectionInfo();
+    });
+
+    this.device.on('message', async (topic: string, payload: string) => {
+      logger.debug(
+        `Message received on topic: ${topic}:\n${payload.toString()}`
+      );
+      try {
+        const jsonPacket = JSON.parse(payload);
+        this.dispatch(topic, jsonPacket);
+      } catch (e) {
+        logger.error(`Error parsing message!\n${stringifyError(e)}`);
+      }
+    });
+  }
+
+  private async logConnectionInfo() {
+    try {
+      /**
+       * We're using the 'netcat' or 'nc' command to test the connection to the IoT Core endpoint.
+       * This command doesn't always exit (see below), so
+       * we use timeout to break out of the prompt
+       * and catch the resulting error/parse the resulting stderr
+       *
+       * Sample command for current host and port:
+       * nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
+       *
+       * Sample output when port is not blocked and host is reachable:
+       * $ nc  -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443
+       * Connection to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443 port [tcp/https] succeeded!
+       *
+       *
+       * Sample output when port is blocked (will repeatedly try until ctrl-C out):
+       * $ nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
+       * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
+       * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
+       * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
+       * ^C
+       *
+       *
+       * Sample command/output when the port isn't enable on that host:
+       * $ nc -zv -w 1 localhost 8883
+       * nc: connect to localhost port 8883 (tcp) failed: Connection refused
+       */
+      await exec_promise(`nc -zv -w 1 ${this.host} ${this.port}`, {
+        timeout: 2000
+      });
+    } catch (err) {
+      const output = JSON.stringify(err['stderr']);
+      if (output.indexOf('not known') !== -1) {
+        logger.warn(
+          'Iot Core endpoint appears to be unreachable, internet connection may be unstable or the host may be down.'
+        );
+      } else if (output.indexOf('timed out') !== -1) {
+        logger.warn(
+          `Internet connection appears fine, however the endpoint was not reachable on the current connection port: ${this.port}\nPlease check if a firewall is in place.`
+        );
+      } else if (output.indexOf('refused') !== -1) {
+        logger.warn(
+          `The connection was refused, likely ${this.host} is not running a service on ${this.port}.`
+        );
+      } else {
+        logger.warn(
+          `Output from checking connection to ${this.host} on ${this.port}: ${output}`
+        );
+      }
+    }
+  }
+}