@alwaysai/device-agent 2.0.2-0 → 2.1.0-0

package/src/cloud-connection/{device-agent.ts → bootstrap-agent.ts}

@@ -1,11 +1,10 @@
-// eslint-disable-next-line
-const awsIot = require('aws-iot-device-sdk');
 import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
 import {
   DEVICE_CERTIFICATE_FILE_NAME,
   DEVICE_CERTIFICATE_ID_FILE_NAME,
   DEVICE_PRIVATE_KEY_FILE_NAME,
-  LOCAL_CERT_AND_KEY_DIR
+  LOCAL_CERT_AND_KEY_DIR,
+  LocalDeviceCertificates
 } from 'alwaysai/lib/infrastructure';
 import { JsSpawner } from 'alwaysai/lib/util';
 import {
@@ -14,18 +13,20 @@ import {
 } from '../infrastructure/device-certificate';
 import { getDeviceUuid } from '../util/get-device-id';
 import { logger } from '../util/logger';
+import { ConnectionManager, DeviceAgentConfigType } from './connection-manager';
+import { Publisher } from './publisher';
+import { MessageHandler } from './message-dispatcher';
+import {
+  getBootstrapCertificateFilePath,
+  getBootstrapPrivateKeyFilePath
+} from '../infrastructure/device-certificate';
+import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
+``;
+import { AWS_ROOT_CERTIFICATE_FILE_PATH } from '../util/directories';
 
 // eslint-disable-next-line
 const process = require('process');
 
-interface DeviceAgentConfigType {
-  keyPath: string;
-  certPath: string;
-  caPath: string;
-  clientId: string;
-  host: string;
-}
-
 interface FleetProvisionTemplateMessageType {
   certificateOwnershipToken: string;
   parameters: {
@@ -36,38 +37,40 @@ interface FleetProvisionTemplateMessageType {
   };
 }
 
-export class DeviceAgent {
-  constructor(config: DeviceAgentConfigType) {
-    this.device = awsIot.device(config);
+export class BootstrapAgent implements MessageHandler {
+  private connectionManager: ConnectionManager;
+  private publisher: Publisher;
+  private readonly clientId = getDeviceUuid();
+  private readonly host = getIoTCoreEndpointUrl();
+  private readonly port = 8883;
+
+  constructor() {
+    // Initialize & setup the connection
+    const bootstrapAgentConfig = {
+      clientId: this.clientId,
+      host: this.host,
+      port: this.port,
+      keyPath: getBootstrapPrivateKeyFilePath(),
+      certPath: getBootstrapCertificateFilePath(),
+      caPath: AWS_ROOT_CERTIFICATE_FILE_PATH
+    };
+    this.connectionManager = new ConnectionManager(bootstrapAgentConfig);
+
+    this.publisher = new Publisher(
+      this.connectionManager,
+      bootstrapAgentConfig.clientId
+    );
   }
 
-  public deviceType = 'aai-device';
-  public device = awsIot.device;
   public hardwareId = async () => await getTargetHardwareUuid(JsSpawner());
   public deviceId = getDeviceUuid();
+  public deviceType = 'aai-device';
 
   public publishMessage(topic: string, message: string) {
-    this.device.publish(topic, message);
-  }
-}
-
-export class BootstrapAgent extends DeviceAgent {
-  public async subscribeToAllTopics() {
-    const AWS_CERTIFICATE_ACCEPT_TOPIC =
-      '$aws/certificates/create/json/accepted';
-    const PROVISIONING_ACCEPTED_TOPIC =
-      '$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted';
-
-    const topics = [AWS_CERTIFICATE_ACCEPT_TOPIC, PROVISIONING_ACCEPTED_TOPIC];
-    const resp = this.device.subscribe(
-      topics,
-      function (err: any, granted: { topic: string; qos: number }[]) {
-        logger.debug(`Bootstrap Agent: ${JSON.stringify(granted, null, 2)}`);
-      }
-    );
+    this.publisher.publish(topic, message);
   }
 
-  public async handleAwsCertificateTopics(topic: string, payload: any) {
+  public async handle(payload: any, topic: string) {
     switch (topic) {
       case '$aws/certificates/create/json/accepted': {
         logger.debug(
@@ -124,4 +127,34 @@ export class BootstrapAgent extends DeviceAgent {
       }
     }
   }
+
+  public async bootstrapProvision() {
+    const rmBootstrapCertsAndClose = async () => {
+      const deviceCertificates = new LocalDeviceCertificates();
+      const spawner = JsSpawner();
+      await spawner.rimraf(getBootstrapCertificateDirectoryPath());
+      await spawner.rimraf(deviceCertificates.getCertificateDirectoryPath());
+      logger.error('Could not provision device. Try again.');
+      process.exit(1);
+    };
+
+    setTimeout(rmBootstrapCertsAndClose, 60000);
+
+    this.connectionManager.initConnectionHandlers(() => {
+      logger.info('Your device is being provisioned');
+    });
+
+    await this.connectionManager.waitForConnection();
+
+    this.connectionManager.registerHandler(
+      '$aws/certificates/create/json/accepted',
+      this
+    );
+    this.connectionManager.registerHandler(
+      '$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted',
+      this
+    );
+
+    this.publishMessage('$aws/certificates/create/json', '{}');
+  }
 }

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

@@ -1,4 +1,4 @@
-import * as awsIot from 'aws-iot-device-sdk';
+import { mqtt5, iot } from 'aws-iot-device-sdk-v2';
 import {
   DEVICE_CERTIFICATE_FILE_PATH,
   DEVICE_PRIVATE_KEY_FILE_PATH
@@ -9,135 +9,213 @@ import { logger } from '../util/logger';
 import { promisify } from 'util';
 import { exec } from 'child_process';
 import { MessageDispatcher, MessageHandler } from './message-dispatcher';
+import { once } from 'events';
 
 const exec_promise = promisify(exec);
 
+// replace with direct params: instead of interface
+export interface DeviceAgentConfigType {
+  clientId: string;
+  host: string;
+  port: number;
+  keyPath?: string;
+  certPath?: string;
+  caPath?: string;
+}
+
 export class ConnectionManager extends MessageDispatcher<any> {
   private clientId: string;
   private host: string;
   private port: number;
-  private device: awsIot.device | null = null;
+  private config: mqtt5.Mqtt5ClientConfig;
+  private client: mqtt5.Mqtt5Client;
   private subscribedTopics: Set<string> = new Set();
+  private connected = false;
+  readonly qos: mqtt5.QoS;
 
-  constructor(clientId: string, host: string, port: number) {
+  constructor(deviceAgentConfig: DeviceAgentConfigType) {
     super();
-    this.clientId = clientId;
-    this.host = host;
-    this.port = port;
-  }
 
-  public getIoTDevice() {
-    return this.device;
+    // Use config values if provided, otherwise use defaults
+    this.clientId = deviceAgentConfig.clientId;
+    this.host = deviceAgentConfig.host;
+    this.port = deviceAgentConfig.port;
+    this.qos = mqtt5.QoS.AtLeastOnce;
+
+    const certPath = deviceAgentConfig.certPath || DEVICE_CERTIFICATE_FILE_PATH;
+    const keyPath = deviceAgentConfig.keyPath || DEVICE_PRIVATE_KEY_FILE_PATH;
+    const caPath = deviceAgentConfig.caPath || AWS_ROOT_CERTIFICATE_FILE_PATH;
+
+    const builder =
+      iot.AwsIotMqtt5ClientConfigBuilder.newDirectMqttBuilderWithMtlsFromPath(
+        this.host,
+        certPath,
+        keyPath
+      );
+
+    builder.withConnectProperties({
+      clientId: this.clientId,
+      keepAliveIntervalSeconds: 10
+    });
+
+    builder.withCertificateAuthorityFromPath(undefined, caPath);
+
+    this.config = builder.build();
+    this.client = new mqtt5.Mqtt5Client(this.config);
+    this.client.start();
   }
 
-  public connect(cb): 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(cb);
-    } catch (error) {
-      logger.error(`Error connecting to cloud!\n${stringifyError(error)}`);
-      this.handleReconnection();
-    }
+  public getIoTDevice() {
+    return this.client;
   }
 
   public isConnected(): boolean {
-    return this.device ? this.device.connected : false;
+    return this.connected;
   }
 
   public registerHandler(topic: string, handler: MessageHandler) {
     super.registerHandler(topic, handler);
-    this.subscribe(topic);
+    void 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 async disconnect(): Promise<void> {
+    const stopped = once(this.client, mqtt5.Mqtt5Client.STOPPED);
+    this.client.stop();
+    await stopped;
+    logger.debug(`Device Agent has been disconnected from the AWS IoT Core.`);
   }
 
-  public subscribe(topic: string): void {
-    if (!this.device) {
-      throw new Error('Must call connect() before subscribe()!');
-    }
+  public async subscribe(topic: string): Promise<void> {
     if (!this.subscribedTopics.has(topic)) {
-      this.device.subscribe(topic);
+      const suback = await this.client.subscribe({
+        subscriptions: [{ qos: mqtt5.QoS.AtLeastOnce, topicFilter: topic }]
+      });
       this.subscribedTopics.add(topic);
-      logger.debug(`Subscribed to topic: ${topic}`);
+      logger.debug(
+        `Subscribed to topic: ${topic}, result: ${JSON.stringify(suback)}`
+      );
     }
   }
 
-  public unsubscribe(topic: string): void {
-    if (!this.device) {
-      throw new Error('Must call connect() before unsubscribe()!');
-    }
+  public async unsubscribe(topic: string): Promise<void> {
     if (this.subscribedTopics.has(topic)) {
-      this.device.unsubscribe(topic);
+      const unsuback = await this.client.unsubscribe({
+        topicFilters: [topic]
+      });
+      logger.debug(
+        `Unsubscribed from topic: ${topic}, result: ${JSON.stringify(unsuback)}`
+      );
       this.subscribedTopics.delete(topic);
-      logger.debug(`Unsubscribed from topic: ${topic}`);
     }
   }
 
-  private handleReconnection() {
-    logger.debug(`Attempting to reconnect to AWS IoT Core...`);
-    setTimeout(
-      () =>
-        this.connect(() => {
-          // Do nothing
-        }),
-      5000
-    ); // try in 5 seconds.
-  }
-
-  private setupHandlers(cb): void {
-    this.device.on('connect', (connack: any) => {
-      logger.info('Device Agent has connected to the cloud.');
-      cb();
+  public initConnectionHandlers(connectCallback: () => void): void {
+    this.client.on('attemptingConnect', () => {
+      logger.debug(`Device Agent is attempting connection`);
     });
 
-    this.device.on('disconnect', () => {
+    this.client.on(
+      'connectionSuccess',
+      (eventData: mqtt5.ConnectionSuccessEvent) => {
+        logger.info('Device Agent has connected to the cloud.');
+        logger.debug(`Connack: ${JSON.stringify(eventData.connack)}`);
+        logger.debug(`Settings: ${JSON.stringify(eventData.settings)}`);
+        this.connected = true;
+        connectCallback();
+      }
+    );
+
+    this.client.on('disconnection', (eventData: mqtt5.DisconnectionEvent) => {
       logger.warn('Device Agent has been disconnected from the cloud');
+      logger.warn(`Disconnection event: ${eventData.error.toString()}`);
+      if (eventData.disconnect !== undefined) {
+        logger.debug(
+          'Disconnect packet: ' + JSON.stringify(eventData.disconnect)
+        );
+      }
+      this.connected = false;
     });
 
-    this.device.on('reconnect', () => {
-      logger.info(
-        `Device Agent attempting to re-connect ${new Date().toLocaleString()}`
-      );
-    });
+    this.client.on(
+      'connectionFailure',
+      (eventData: mqtt5.ConnectionFailureEvent) => {
+        logger.error(
+          `Error connecting to the AWS IoT Core! Disconnection event: ${eventData.error.toString()}`
+        );
+        if (eventData.connack) {
+          logger.debug(
+            'Disconnect packet: ' + JSON.stringify(eventData.connack)
+          );
+        }
+
+        this.connected = false;
+      }
+    );
 
-    this.device.on('error', function (e) {
+    this.client.on('error', (error) => {
       logger.error(
-        `Error connecting to the AWS IoT Core!\n${stringifyError(e)}`
+        `Error connecting to the AWS IoT Core! Error:\n${stringifyError(
+          error as Error
+        )}`
       );
+      this.connected = false;
     });
 
-    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()}`);
+    this.client.on('stopped', () => {
+      logger.warn(`Device Agent has stopped ${new Date().toLocaleString()}`);
       void this.logConnectionInfo();
+      this.connected = false;
     });
 
-    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)}`);
+    this.client.on(
+      'messageReceived',
+      (eventData: mqtt5.MessageReceivedEvent) => {
+        const topic = eventData.message.topicName;
+        const payloadBuffer = eventData.message.payload as ArrayBuffer;
+        try {
+          const payloadString = payloadBuffer
+            ? Buffer.from(new Uint8Array(payloadBuffer)).toString('utf-8')
+            : null;
+          logger.debug(
+            `Message received on topic: ${topic}:\n${payloadString}`
+          );
+          this.dispatch(eventData.message.topicName, payloadString);
+        } catch (e) {
+          logger.error(
+            `Error parsing message on topic ${
+              eventData.message.topicName
+            }!:\n${stringifyError(e)}`
+          );
+        }
+      }
+    );
+  }
+
+  public waitForConnection(timeoutMs = 10000): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (this.connected) {
+        return resolve(); // already connected
       }
+
+      const timeout = setTimeout(() => {
+        reject(new Error('Timed out waiting for MQTT connection'));
+      }, timeoutMs);
+
+      this.client.on('connectionSuccess', () => {
+        clearTimeout(timeout);
+        this.connected = true;
+        resolve();
+      });
+
+      this.client.on('disconnection', (event) => {
+        const errorString = event.error
+          ? event.error.toString()
+          : 'Unknown reason';
+        logger.warn(
+          `Disconnected while waiting for connection: ${errorString}`
+        );
+        reject(new Error(`Disconnected: ${errorString}`));
+      });
     });
   }