@alwaysai/device-agent 1.3.1 → 1.5.0

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

@@ -1,59 +1,60 @@
 // eslint-disable-next-line
-const awsIot = require("aws-iot-device-sdk");
-import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
-import { existsSync } from 'fs';
-import {
-  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
-  AWS_ROOT_CERTIFICATE_FILE_PATH,
-  BOOTSTRAP_CERTIFICATES_DIR_PATH,
-  DEVICE_PRIVATE_KEY_FILE_PATH,
-  DEVICE_CERTIFICATE_FILE_PATH
-} from '../util/directories';
+const awsIot = require('aws-iot-device-sdk');
 import {
-  keyMirrors,
-  SignedUrlsRequestPayload,
-  getToDeviceTopic,
   AppInstallResponsePayload,
-  validateToDeviceAgentMessage,
-  ToDeviceAgentMessage,
-  ToCloudMessage,
   AppStateControlPayload,
   AppVersionControlInstallPayload,
   AppVersionControlUninstallPayload,
   DeviceActionPayload,
+  ModelsInstallResponsePayload,
+  SignedUrlsRequestPayload,
+  ToCloudMessage,
+  ToDeviceAgentMessage,
+  getToDeviceTopic,
   buildSignedUrlsRequestMessage,
   buildToClientStatusResponseMessage,
-  StatusResponsePayload
+  StatusResponsePayload,
+  keyMirrors,
+  validateToDeviceAgentMessage,
+  validateSecureTunnelShadowUpdate
 } from '@alwaysai/device-agent-schemas';
-import { getDeviceUuid } from '../util/get-device-id';
-import { logger } from '../util/logger';
-import { cloudModeReady } from '../util/cloud-mode-ready';
-import { AgentConfigFile } from '../infrastructure/agent-config';
+import { existsSync } from 'fs';
 import {
+  installApp,
+  restartApp,
   startApp,
   stopApp,
-  restartApp,
-  updateModelsWithPresignedUrls,
-  installApp,
   uninstallApp,
   updateAppCfg,
-  setEnv
+  updateModelsWithPresignedUrls
 } from '../application-control';
-import { ShadowHandler, ShadowTopics, ShadowUpdate } from './shadow-handler';
-import { secureTunnelNotifyHandler } from '../secure-tunneling/index';
-import { Publisher } from './publisher';
-import { bootstrapProvision } from './bootstrap-provision';
-import { PassthroughHandler, runChannel } from './passthrough-handler';
+import { createAppBackup, rollbackApp } from '../application-control/backup';
+import { reboot } from '../device-control/device-control';
 import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
-import { ModelsInstallResponsePayload } from '@alwaysai/device-agent-schemas';
+import { AgentConfigFile } from '../infrastructure/agent-config';
+import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
+import { SecureTunnelHandlerSingleton } from '../secure-tunneling/secure-tunneling';
+import { cloudModeReady } from '../util/cloud-mode-ready';
+import {
+  AWS_ROOT_CERTIFICATE_FILE_PATH,
+  BOOTSTRAP_CERTIFICATES_DIR_PATH,
+  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
+  DEVICE_CERTIFICATE_FILE_PATH,
+  DEVICE_PRIVATE_KEY_FILE_PATH
+} from '../util/directories';
+import { getDeviceUuid } from '../util/get-device-id';
+import { logger } from '../util/logger';
 import sleep from '../util/sleep';
-import { createAppBackup, rollbackApp } from '../application-control/backup';
+import { bootstrapProvision } from './bootstrap-provision';
+import { LiveUpdatesHandler } from './live-updates-handler';
+import { PassthroughHandler } from './passthrough-handler';
+import { Publisher } from './publisher';
+import { ShadowHandler, ShadowUpdate } from './shadow-handler';
 import { TransactionManager } from './transaction-manager';
-import { reboot } from '../device-control/device-control';
-
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { LiveUpdatesHandler } from './live-updates-handler';
+import { pruneModels } from '../application-control/models';
+import { getDeviceAgentVersion } from '../util/check-for-updates';
 
 const exec_promise = promisify(exec);
 
@@ -69,8 +70,8 @@ export class DeviceAgentCloudConnection {
   private port = 8883;
   private readonly toDeviceTopic = getToDeviceTopic(this.clientId);
   private readonly secureTunnelNotifyTopic = `$aws/things/${this.clientId}/tunnels/notify`;
-  // FIXME: Add support for multiple simultaneous project updates
-  private appCfgUpdateQueue: ShadowUpdate[] = [];
+  private readonly secureTunnelHandler =
+    SecureTunnelHandlerSingleton.getInstance();
 
   private handleAppStateControl = async (
     payload: AppStateControlPayload
@@ -144,46 +145,50 @@ export class DeviceAgentCloudConnection {
       appInstallPayload,
       modelsInstallPayload
     };
-    await this.atomicApplicationUpdate(
-      installApp,
-      [{ projectId, appReleaseHash, signedUrlsPayload }],
-      projectId
-    );
+    await this.atomicApplicationUpdate(async () => {
+      this.shadowHandler.clearProjectShadow(projectId);
+      await installApp({ projectId, appReleaseHash, signedUrlsPayload });
+    }, projectId);
     return true;
   };
 
   private handleModelsInstallCloudResponsePayload = async (
-    payload: ModelsInstallResponsePayload
+    payload: ModelsInstallResponsePayload,
+    txId: string
   ): Promise<boolean> => {
-    const update = this.appCfgUpdateQueue.shift();
+    const projectId = payload.modelsInstallResponse.projectId;
+
+    const update = this.txnMgr.getAppCfgUpdateFromTxID(txId);
     if (update === undefined) {
       throw new Error(
         'Unknown error while updating models via application config! No config present for model update.'
       );
     }
     const { appCfgUpdate, envVarUpdate } = update;
-    const projectId = payload.modelsInstallResponse.projectId;
     if (appCfgUpdate) {
       await this.atomicApplicationUpdate(
-        updateModelsWithPresignedUrls,
-        [
-          {
+        async () =>
+          await updateModelsWithPresignedUrls({
             projectId,
             modelInstallPayloads: payload.modelsInstallResponse.newModels,
             newAppCfg: appCfgUpdate.newAppCfg
-          }
-        ],
+          }),
         projectId
       );
     }
 
     if (envVarUpdate) {
       await this.atomicApplicationUpdate(
-        setEnv,
-        [{ projectId, envVars: envVarUpdate.envVars }],
-        projectId
+        async () =>
+          await this.shadowHandler.updateProjectEnvVars({
+            projectId,
+            envVars: envVarUpdate.envVars
+          }),
+        projectId,
+        true
       );
     }
+
     return true;
   };
 
@@ -214,7 +219,7 @@ export class DeviceAgentCloudConnection {
   private async atomicApplicationUninstall(projectId: string) {
     try {
       await uninstallApp({ projectId });
-      this.shadowHandler.clearAppConfig(projectId);
+      this.shadowHandler.clearProjectShadow(projectId);
     } catch (e) {
       logger.error(`Failed to uninstall ${projectId}: ${e.message}`);
       throw e;
@@ -222,11 +227,11 @@ export class DeviceAgentCloudConnection {
   }
 
   // eslint-disable-next-line
-  private async atomicApplicationUpdate<T extends any[], R extends any>(
-    func: (...args: T) => R,
-    args: T,
-    projectId: string
-  ) {
+  private async atomicApplicationUpdate <F extends () => any>(
+    func: F,
+    projectId: string,
+    skipUpdateShadow?: boolean
+  ): Promise<ReturnType<F>> {
     // First try to create a backup, so that there is one available if something goes wrong in the next try:catch.
     if (await AgentConfigFile().isAppPresent({ projectId })) {
       try {
@@ -239,9 +244,9 @@ export class DeviceAgentCloudConnection {
     }
 
     try {
-      const out: R = await func(...args);
-      this.shadowHandler.clearAppConfig(projectId);
-      await this.shadowHandler.updateProjectShadow(projectId);
+      const out: ReturnType<F> = await func();
+      if (!skipUpdateShadow)
+        await this.shadowHandler.updateProjectShadow(projectId);
       return out;
     } catch (errorAppUpdate) {
       logger.error(
@@ -256,9 +261,9 @@ export class DeviceAgentCloudConnection {
       } catch (errorRollbackApp) {
         // and if that fails, uninstall the app as a last resort.
         try {
-          await uninstallApp({ projectId });
-        } finally {
-          this.shadowHandler.clearAppConfig(projectId);
+          await this.atomicApplicationUninstall(projectId);
+        } catch {
+          // atomicApplicationUninstall handles failing, so there's nothing to handle here.
         }
         logger.error(
           `Application update failed, rolled back to previous version: ${errorAppUpdate}`
@@ -273,15 +278,14 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  private handleAppConfigUpdate = async (
+  private handleProjectShadowConfigUpdate = async (
     update: ShadowUpdate,
     txId: string
   ): Promise<boolean> => {
     const { projectId, appCfgUpdate, envVarUpdate } = update;
 
     if (
-      appCfgUpdate &&
-      appCfgUpdate.updatedModels &&
+      appCfgUpdate?.updatedModels &&
       Object.keys(appCfgUpdate.updatedModels).length
     ) {
       // When there are model updates request signed URLs and wait to apply config changes
@@ -305,33 +309,97 @@ export class DeviceAgentCloudConnection {
       );
       this.publisher.publishToCloud(message);
 
-      this.appCfgUpdateQueue.push(update);
+      this.txnMgr.setAppCfgUpdateToTx(txId, update);
+
       return false;
     }
 
     if (appCfgUpdate) {
-      await this.atomicApplicationUpdate(
-        updateAppCfg,
-        [
-          {
-            projectId,
-            newAppCfg: appCfgUpdate.newAppCfg
-          }
-        ],
-        projectId
-      );
+      await this.atomicApplicationUpdate(async () => {
+        await pruneModels({
+          projectId,
+          appCfg: appCfgUpdate.newAppCfg
+        });
+        await updateAppCfg({
+          projectId,
+          newAppCfg: appCfgUpdate.newAppCfg
+        });
+      }, projectId);
     }
 
     if (envVarUpdate) {
       await this.atomicApplicationUpdate(
-        setEnv,
-        [{ projectId, envVars: envVarUpdate.envVars }],
-        projectId
+        async () =>
+          await this.shadowHandler.updateProjectEnvVars({
+            projectId,
+            envVars: envVarUpdate.envVars
+          }),
+        projectId,
+        true
       );
     }
     return true;
   };
 
+  private async handleProjectShadowMessage(topic: string, message: any) {
+    const shadowUpdates = await this.shadowHandler.handleProjectShadow({
+      topic,
+      payload: message,
+      clientToken: message.clientToken
+    });
+    if (shadowUpdates.length) {
+      const shadowUpdatePromises: Promise<void>[] = [];
+      for (const shadowUpdate of shadowUpdates) {
+        const projectId = shadowUpdate.projectId;
+        const txId = shadowUpdate.txId;
+        shadowUpdatePromises.push(
+          this.txnMgr
+            .runTransactionStep({
+              func: () =>
+                this.handleProjectShadowConfigUpdate(shadowUpdate, txId),
+              projectId,
+              txId,
+              start: true,
+              stepName: topic
+            })
+            .catch((e: Error) => {
+              logger.error(
+                `There was an issue updating project shadow config: ${JSON.stringify(
+                  e
+                )}`
+              );
+            })
+        );
+      }
+
+      await Promise.all(shadowUpdatePromises);
+    }
+  }
+
+  public async handleSecureTunnelMessage(payload: any): Promise<void> {
+    logger.info(`Received secure tunnel update: ${JSON.stringify(payload)}`);
+    const state = payload.state;
+    if (!state) {
+      logger.debug(`No state found in message: ${JSON.stringify(payload)}`);
+      return;
+    }
+    const valid = validateSecureTunnelShadowUpdate(state);
+    if (!valid) {
+      logger.error(
+        `Error validating message: ${JSON.stringify(
+          { payload, errors: validateSecureTunnelShadowUpdate.errors },
+          null,
+          2
+        )}`
+      );
+      return;
+    }
+    const secureTunnelUpdate =
+      await this.secureTunnelHandler.syncShadowToDeviceState(payload);
+    await this.shadowHandler.updateSecureTunnelShadow(secureTunnelUpdate);
+    return;
+  }
+
   /*=================================================================
                             Public interface
   =================================================================*/
@@ -359,11 +427,11 @@ export class DeviceAgentCloudConnection {
 
     this.subscribe(this.toDeviceTopic);
     this.subscribe(this.secureTunnelNotifyTopic);
-    this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
-    this.subscribe(this.shadowHandler.shadowTopics.projects.getRejected);
-    this.subscribe(this.shadowHandler.shadowTopics.projects.updateDelta);
-    this.subscribe(this.shadowHandler.shadowTopics.projects.updateAccepted);
-    this.subscribe(this.shadowHandler.shadowTopics.projects.updateRejected);
+    for (const topic of this.shadowHandler.projectShadowTopics) {
+      this.subscribe(topic);
+    }
+    this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.updateDelta);
+    this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted);
   }
 
   public getClientId(): string {
@@ -374,10 +442,6 @@ export class DeviceAgentCloudConnection {
     return this.toDeviceTopic;
   }
 
-  public getShadowTopics(): ShadowTopics {
-    return this.shadowHandler.shadowTopics;
-  }
-
   public isCmdInProgress(projectId: string): boolean {
     return this.txnMgr.isOngoingTransactionForProjectID(projectId);
   }
@@ -412,7 +476,8 @@ export class DeviceAgentCloudConnection {
       live_state_updates,
       app_install_response,
       models_install_response,
-      status_response
+      status_response,
+      device_action
     } = keyMirrors.toDeviceAgentMessageType;
     switch (message.messageType) {
       case app_state_control: {
@@ -492,7 +557,8 @@ export class DeviceAgentCloudConnection {
           );
         }
         await this.txnMgr.runTransactionStep({
-          func: () => this.handleModelsInstallCloudResponsePayload(payload),
+          func: () =>
+            this.handleModelsInstallCloudResponsePayload(payload, txId),
           projectId,
           txId,
           start: false,
@@ -520,8 +586,20 @@ export class DeviceAgentCloudConnection {
         }
         break;
       }
-      case keyMirrors.toDeviceAgentMessageType.device_action: {
+      case device_action: {
         try {
+          const statusResponsePayload: StatusResponsePayload = {
+            status: keyMirrors.statusResponse.in_progress
+          };
+          const statusResponseMessage = buildToClientStatusResponseMessage(
+            this.clientId,
+            statusResponsePayload,
+            txId
+          );
+          this.publisher.publishToClient(statusResponseMessage);
+
+          await this.handleDeviceAction(message.payload);
+
           const successStatusResponsePayload: StatusResponsePayload = {
             status: keyMirrors.statusResponse.success
           };
@@ -532,8 +610,6 @@ export class DeviceAgentCloudConnection {
               txId
             );
           this.publisher.publishToClient(successStatusResponseMessage);
-
-          await this.handleDeviceAction(message.payload);
         } catch (e) {
           logger.error(
             `There was a problem performing device action '${message.payload.action}': ${e.message}`
@@ -563,57 +639,33 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  public async handleMessage(
-    topic: string,
-    message: ToDeviceAgentMessage | any
-  ) {
+  public async handleMessage(topic: string, message: any) {
     logger.debug(
       `Received message: ${JSON.stringify({ topic, message }, null, 2)}`
     );
-    switch (topic) {
-      case this.shadowHandler.shadowTopics.projects.getAccepted:
-      case this.shadowHandler.shadowTopics.projects.updateAccepted: {
-        const shadowUpdates = await this.shadowHandler.handleShadowTopic({
-          topic,
-          payload: message.state,
-          clientToken: message.clientToken
-        });
-        if (shadowUpdates.length) {
-          for (const shadowUpdate of shadowUpdates) {
-            const projectId = shadowUpdate.projectId;
-            const txId = shadowUpdate.txId;
-            try {
-              await this.txnMgr.runTransactionStep({
-                func: () => this.handleAppConfigUpdate(shadowUpdate, txId),
-                projectId,
-                txId,
-                start: true,
-                stepName: topic
-              });
-            } catch (e) {
-              logger.error(`Error handling shadow message: ${e.message}`);
-            }
-          }
-        }
-        break;
-      }
-      case this.shadowHandler.shadowTopics.projects.getRejected:
-      case this.shadowHandler.shadowTopics.projects.updateDelta:
-      case this.shadowHandler.shadowTopics.projects.updateRejected:
-        // Not handling these for now
-        break;
-      case this.toDeviceTopic:
-        await this.handleDeviceAgentMessage({
-          topic,
-          message
-        });
-        break;
-
-      case this.secureTunnelNotifyTopic:
-        await secureTunnelNotifyHandler(message);
-        break;
-      default:
-        logger.error(`Unexpected topic, ignoring! ${topic}`);
+    // ProjectShadow messages
+    if (this.shadowHandler.projectShadowTopics.includes(topic)) {
+      await this.handleProjectShadowMessage(topic, message);
+    } else if (topic === this.toDeviceTopic) {
+      await this.handleDeviceAgentMessage({
+        topic,
+        message
+      });
+      // SecureTunnelNotify messages
+    } else if (topic === this.secureTunnelNotifyTopic) {
+      await this.secureTunnelHandler.secureTunnelNotifyHandler(message);
+      // SecureTunnel messages
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.updateDelta
+    ) {
+      await this.handleSecureTunnelMessage(message);
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted
+    ) {
+      logger.info(`Received secure tunnel deleteAccepted: ${message}`);
+      await this.secureTunnelHandler.destroy();
+    } else {
+      logger.error(`Unexpected topic, ignoring! ${topic}`);
     }
   }
 
@@ -710,15 +762,18 @@ export class DeviceAgentCloudConnection {
   }
 
   public async stop() {
-    // FIXME: This method is currently only used by the CLI, and shadow messages
-    // can be lost since we aren't waiting for responses so sleep for a short
-    // time to receive them
+    // This method is currently only used by the CLI, and shadow messages can be
+    // lost since we aren't waiting for responses so sleep for a short time to
+    // receive them
     await sleep(1000);
     this.device.end();
   }
 }
 
 export async function runDeviceAgentCloudInterface() {
+  logger.info(
+    `Starting alwaysAI Device Agent v${await getDeviceAgentVersion()}`
+  );
   if (cloudModeReady()) {
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
@@ -726,7 +781,6 @@ export async function runDeviceAgentCloudInterface() {
       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();