@alwaysai/device-agent 0.0.13 → 0.0.15

package/src/cloud-connection/device-agent-cloud-connection.ts

@@ -3,11 +3,11 @@ const awsIot = require('aws-iot-device-sdk');
 import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
 import { existsSync } from 'fs';
 import {
-  getPrivateKeyFilePath,
-  getCertificateFilePath,
-  BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
+  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
   AWS_ROOT_CERTIFICATE_FILE_PATH,
-  BOOTSTRAP_CERTIFICATES_DIR_PATH
+  BOOTSTRAP_CERTIFICATES_DIR_PATH,
+  DEVICE_PRIVATE_KEY_FILE_PATH,
+  DEVICE_CERTIFICATE_FILE_PATH
 } from '../util/directories';
 import {
   keyMirrors,
@@ -31,18 +31,21 @@ import {
   uninstallApp,
   updateAppCfg
 } from '../application-control';
-import { AppConfigUpdate, ShadowHandler } from './shadow-handler';
+import { AppConfigUpdate, ShadowHandler, ShadowTopics } from './shadow-handler';
 import { Publisher } from './publisher';
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { bootstrapProvision } from './bootstrap-provision';
-import { AppInstallStatusManager } from './app-install-status';
 import { AppConfig } from '@alwaysai/app-configuration-schemas';
+import { CmdStatusManager } from './cmd-status';
+import { PassthroughHandler, runChannel } from './passthrough-handler';
+import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
+import { getAppInstallStatusMessage } from './messages';
 
 export class DeviceAgentCloudConnection {
   private shadowHandler: ShadowHandler;
-  private publisher: Publisher;
+  public publisher: Publisher;
+  private cmdStatusMgr: CmdStatusManager;
   private liveUpdatesHandler: LiveUpdatesHandler;
-  private appInstallStatusMgr: AppInstallStatusManager;
   private device = awsIot.device;
 
   private clientId = getDeviceUuid();
@@ -51,38 +54,62 @@ export class DeviceAgentCloudConnection {
   // FIXME: Add support for multiple simultaneous project updates
   private newAppCfgQueue: AppConfig[] = [];
 
-  private handleAppStateControl(payload: AppStateControlPacket) {
+  private async handleAppStateControl(payload: AppStateControlPacket) {
     const { baseCommand, projectId } = payload;
     switch (baseCommand) {
       case keyMirrors.appStateControl.start:
-        startApp({ projectId });
+        await startApp({ projectId });
         break;
       case keyMirrors.appStateControl.stop:
-        stopApp({ projectId });
+        await stopApp({ projectId });
         break;
       case keyMirrors.appStateControl.restart:
-        restartApp({ projectId });
+        await restartApp({ projectId });
         break;
     }
   }
 
-  private handleAppVersionControl(payload: AppVersionControlPacket) {
-    const { projectId, appReleaseHash } = payload;
-    const signedUrlsRequest = { projectId, appReleaseHash };
-    this.publishCloudRequest({
-      messageType: keyMirrors.agentMessageType.signed_urls_request,
-      signedUrlsRequest
-    });
+  private async handleAppVersionControl(payload: AppVersionControlPacket) {
+    switch (payload.baseCommand) {
+      case keyMirrors.appVersionControl.install: {
+        const { projectId, appReleaseHash } = payload;
+        await this.cmdStatusMgr.start(projectId);
+        await this.liveUpdatesHandler.enableAppInstallStatus({
+          projectId,
+          appReleaseHash
+        });
+
+        const signedUrlsRequest = { projectId, appReleaseHash };
+        await this.publishCloudRequest({
+          messageType: keyMirrors.agentMessageType.signed_urls_request,
+          signedUrlsRequest
+        });
+        break;
+      }
+      case keyMirrors.appVersionControl.uninstall: {
+        const { projectId } = payload;
+        await this.atomicApplicationUninstall(projectId);
+        break;
+      }
+      default:
+        logger.warn(
+          `Ignore App Version Control packet: ${JSON.stringify(
+            payload,
+            null,
+            2
+          )}`
+        );
+    }
   }
 
   private handleDeviceCommand = async (packet: any) => {
     // TODO
   };
 
-  private handleAgentCommand(message: LiveUpdatesToggleMessage) {
+  private async handleAgentCommand(message: LiveUpdatesToggleMessage) {
     switch (message.messageType) {
       case keyMirrors.clientMessageType.live_state_updates:
-        this.liveUpdatesHandler.update(message.liveUpdatesToggles);
+        await this.liveUpdatesHandler.handleToggles(message.liveUpdatesToggles);
         break;
       default:
         logger.error(
@@ -100,6 +127,49 @@ export class DeviceAgentCloudConnection {
     this.device.subscribe(topic);
   }
 
+  private async atomicApplicationUninstall(projectId: string) {
+    const appReleaseHash = await AgentConfigFile().getAppVersion({
+      projectId
+    });
+    await this.cmdStatusMgr.start(projectId);
+    await this.liveUpdatesHandler.enableAppInstallStatus({
+      projectId,
+      appReleaseHash
+    });
+    try {
+      await uninstallApp({ projectId });
+      this.shadowHandler.deleteProjectShadow(projectId);
+
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.success,
+          '',
+          appReleaseHash
+        )
+      );
+    } catch (e) {
+      logger.error(`Failed to uninstall ${projectId}: ${e}`);
+      const message: string = e.message;
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.failure,
+          message,
+          appReleaseHash
+        )
+      );
+    }
+  }
+
   // eslint-disable-next-line
   private async atomicApplicationUpdate<T extends any[], R extends any>(
     func: (...args: T) => R,
@@ -107,53 +177,67 @@ export class DeviceAgentCloudConnection {
     projectId: string,
     appReleaseHash: string
   ) {
-    this.appInstallStatusMgr.update(
-      appReleaseHash,
-      keyMirrors.appInstallStatus.in_progress
-    );
-
-    this.liveUpdatesHandler.update({
-      appInstallStatus: { toggle: true, appReleaseHash }
+    await this.cmdStatusMgr.start(projectId);
+    await this.liveUpdatesHandler.enableAppInstallStatus({
+      projectId,
+      appReleaseHash
     });
 
     // Install the app and models
     try {
       const out: R = await func(...args);
-      this.appInstallStatusMgr.update(
-        appReleaseHash,
-        keyMirrors.appInstallStatus.success
-      );
-      this.liveUpdatesHandler.update({
-        appInstallStatus: { toggle: false, appReleaseHash }
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
       });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.success,
+          '',
+          appReleaseHash
+        )
+      );
 
       // update app config shadow for project
       await this.shadowHandler.publishAppState(projectId);
       return out;
     } catch (e) {
-      logger.error(e);
+      logger.error(`Failed to install ${projectId}: ${e}`);
       const message: string = e.message;
 
       // uninstall the failed app to put system back in good state
+      // TODO: Replace this with rollback
       await uninstallApp({ projectId });
-      this.appInstallStatusMgr.update(
-        appReleaseHash,
-        keyMirrors.appInstallStatus.failure,
-        message
-      );
-      this.liveUpdatesHandler.update({
-        appInstallStatus: { toggle: false, appReleaseHash }
-      });
+      this.shadowHandler.deleteProjectShadow(projectId);
 
-      // delete shadow for project
-      // FIXME: Why do we delete the shadow? Doesn't this delete it for all projects?
-      this.shadowHandler.deleteProjectShadow();
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.failure,
+          message,
+          appReleaseHash
+        )
+      );
     }
   }
 
-  private async handleAppConfigUpdates(appConfgUpdates: AppConfigUpdate[]) {
-    for (const appConfigUpdate of appConfgUpdates) {
+  private async handleAppConfigUpdates(appCfgUpdates: AppConfigUpdate[]) {
+    for (const appConfigUpdate of appCfgUpdates) {
       const { projectId, newAppCfg, updatedModels } = appConfigUpdate;
+      const appReleaseHash = await AgentConfigFile().getAppVersion({
+        projectId
+      });
+      await this.cmdStatusMgr.start(projectId);
+      await this.liveUpdatesHandler.enableAppInstallStatus({
+        projectId,
+        appReleaseHash
+      });
+
       if (updatedModels && Object.keys(updatedModels).length) {
         // Publish request for model urls
         this.newAppCfgQueue.push(newAppCfg);
@@ -193,12 +277,14 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  // Public Methods
+  /*=================================================================
+                            Public interface
+  =================================================================*/
 
   constructor() {
     this.device = awsIot.device({
-      keyPath: getPrivateKeyFilePath(),
-      certPath: getCertificateFilePath(),
+      keyPath: DEVICE_PRIVATE_KEY_FILE_PATH,
+      certPath: DEVICE_CERTIFICATE_FILE_PATH,
       caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
       clientId: this.clientId,
       host: this.host,
@@ -207,11 +293,8 @@ export class DeviceAgentCloudConnection {
     });
     this.publisher = new Publisher(this.device, this.clientId);
     this.shadowHandler = new ShadowHandler(this.clientId, this.publisher);
-    this.appInstallStatusMgr = new AppInstallStatusManager();
-    this.liveUpdatesHandler = new LiveUpdatesHandler(
-      this.publisher,
-      this.appInstallStatusMgr
-    );
+    this.cmdStatusMgr = new CmdStatusManager();
+    this.liveUpdatesHandler = new LiveUpdatesHandler(this.publisher);
 
     this.subscribe(this.toDeviceTopic);
     this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
@@ -222,6 +305,18 @@ export class DeviceAgentCloudConnection {
     return this.clientId;
   }
 
+  public getToDeviceTopic() {
+    return this.toDeviceTopic;
+  }
+
+  public getShadowTopics(): ShadowTopics {
+    return this.shadowHandler.shadowTopics;
+  }
+
+  public isCmdInProgress(projectId: string): boolean {
+    return this.cmdStatusMgr.isCmdInProgress(projectId);
+  }
+
   public async handleClientMessage({
     topic,
     message
@@ -229,18 +324,29 @@ export class DeviceAgentCloudConnection {
     topic: string;
     message: ClientMessage;
   }) {
+    const valid = validateClientMessage(message);
+    if (!valid) {
+      logger.error(
+        `Error validating message: ${JSON.stringify(
+          { topic, message, errors: validateClientMessage.errors },
+          null,
+          2
+        )}`
+      );
+      return;
+    }
     const payload = message.payload;
     switch (payload.messageType) {
       case keyMirrors.clientMessageType.app_state_control: {
-        this.handleAppStateControl(payload.appStateControl);
+        await this.handleAppStateControl(payload.appStateControl);
         break;
       }
       case keyMirrors.clientMessageType.app_version_control: {
-        this.handleAppVersionControl(payload.appVersionControl);
+        await this.handleAppVersionControl(payload.appVersionControl);
         break;
       }
       case keyMirrors.clientMessageType.live_state_updates: {
-        this.handleAgentCommand(payload);
+        await this.handleAgentCommand(payload);
         break;
       }
       case keyMirrors.clientMessageType.app_install_cloud_response: {
@@ -271,9 +377,10 @@ export class DeviceAgentCloudConnection {
 
         const newAppCfg = this.newAppCfgQueue.shift();
         if (newAppCfg === undefined) {
-          throw new Error(
+          logger.error(
             'Unknown error while updating models via application config! No config present for model update.'
           );
+          return;
         }
 
         await this.atomicApplicationUpdate(
@@ -303,11 +410,35 @@ export class DeviceAgentCloudConnection {
     }
   }
 
+  public async handleMessage(topic: string, message: ClientMessage | any) {
+    logger.debug(
+      `Received message: ${JSON.stringify({ topic, message }, null, 2)}`
+    );
+    switch (topic) {
+      case this.shadowHandler.shadowTopics.projects.getAccepted:
+      case this.shadowHandler.shadowTopics.projects.updateDelta: {
+        const appConfigUpdates = await this.shadowHandler.handleShadowTopic({
+          topic,
+          payload: message.state
+        });
+        await this.handleAppConfigUpdates(appConfigUpdates);
+        break;
+      }
+      case this.toDeviceTopic:
+        await this.handleClientMessage({
+          topic,
+          message
+        });
+        break;
+      default:
+        logger.error(`Unexpected topic, ignoring! ${topic}`);
+    }
+  }
+
   public async setupHandlers() {
     this.device.on('connect', (connack: any) => {
       logger.info('Device Agent has connected to the cloud');
 
-      // Get shadow updates
       this.shadowHandler.getShadowUpdates();
     });
 
@@ -321,47 +452,15 @@ export class DeviceAgentCloudConnection {
       );
     });
 
+    this.device.on('error', function (error) {
+      const errorString = error.message.toString();
+      logger.error(`${errorString}`);
+    });
+
     this.device.on('message', async (topic: string, payload: string) => {
       try {
         const jsonPacket = JSON.parse(payload);
-        logger.debug(
-          `Received message: ${JSON.stringify({ topic, jsonPacket }, null, 2)}`
-        );
-
-        if (Object.prototype.hasOwnProperty.call(jsonPacket, 'state')) {
-          if (jsonPacket.clientToken === this.getClientId()) {
-            logger.debug(
-              `Ignoring message sent from self: ${JSON.stringify(
-                { topic, jsonPacket },
-                null,
-                2
-              )}`
-            );
-            return;
-          }
-
-          const appConfigUpdates = await this.shadowHandler.handleShadowTopic({
-            topic,
-            payload: jsonPacket.state
-          });
-          await this.handleAppConfigUpdates(appConfigUpdates);
-        } else {
-          const valid = validateClientMessage(jsonPacket);
-          if (!valid) {
-            logger.error(
-              `Error validating message: ${JSON.stringify(
-                validateClientMessage.errors,
-                null,
-                2
-              )}`
-            );
-          } else {
-            this.handleClientMessage({
-              topic,
-              message: jsonPacket
-            });
-          }
-        }
+        await this.handleMessage(topic, jsonPacket);
       } catch (error) {
         logger.error(`Error parsing message: ${error}`);
       }
@@ -371,15 +470,25 @@ export class DeviceAgentCloudConnection {
       logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
     });
   }
+
+  public stop() {
+    this.device.end();
+  }
 }
 
 export async function runDeviceAgentCloudInterface() {
   // FIXME: Check for KeyPath as well
-  if (existsSync(getCertificateFilePath())) {
+  if (existsSync(DEVICE_CERTIFICATE_FILE_PATH)) {
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
-  } else if (existsSync(BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH())) {
-    bootstrapProvision();
+    if (ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
+      const publisher = deviceAgent.publisher;
+      const passthroughHandler = new PassthroughHandler(publisher);
+      await passthroughHandler.setup();
+      await runChannel(passthroughHandler);
+    }
+  } else if (existsSync(BOOTSTRAP_PRIVATE_KEY_FILE_PATH())) {
+    await bootstrapProvision();
   } else if (existsSync(BOOTSTRAP_CERTIFICATES_DIR_PATH())) {
     throw new Error(
       "Device has not been created using 'aai-agent device init' or there has been an issue with device initialization"

package/src/cloud-connection/device-agent.ts

@@ -3,7 +3,7 @@ const awsIot = require('aws-iot-device-sdk');
 import {
   DEVICE_PRIVATE_KEY_FILE_NAME,
   CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
-  DEVICE_CLAIM_ID_FILE_NAME,
+  DEVICE_ID_FILE_NAME,
   DEVICE_CERTIFICATE_FILE_NAME
 } from '../util/directories';
 import { getDeviceUuid } from '../util/get-device-id';
@@ -66,6 +66,9 @@ export class BootstrapAgent extends DeviceAgent {
   public async handleAwsCertificateTopics(topic: string, payload: any) {
     switch (topic) {
       case '$aws/certificates/create/json/accepted': {
+        logger.debug(
+          `Received Certs: ${JSON.stringify(JSON.parse(payload), null, 2)}`
+        );
         const {
           certificateId,
           certificatePem,
@@ -76,13 +79,13 @@ export class BootstrapAgent extends DeviceAgent {
         const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
 
         await certSpawner.writeFile(
-          DEVICE_CERTIFICATE_FILE_NAME(),
+          DEVICE_CERTIFICATE_FILE_NAME,
           certificatePem
         );
 
-        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME(), privateKey);
+        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
 
-        await certSpawner.writeFile(DEVICE_CLAIM_ID_FILE_NAME(), certificateId);
+        await certSpawner.writeFile(DEVICE_ID_FILE_NAME, certificateId);
 
         await certSpawner.writeFile(
           CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,