@alwaysai/device-agent 1.0.0 → 1.3.0

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

@@ -21,7 +21,8 @@ import {
   AppStateControlPayload,
   AppVersionControlInstallPayload,
   AppVersionControlUninstallPayload,
-  ToClientMessage
+  ToClientMessage,
+  DeviceActionPayload
 } from '@alwaysai/device-agent-schemas';
 import { getDeviceUuid } from '../util/get-device-id';
 import { logger } from '../util/logger';
@@ -49,19 +50,19 @@ import { getStatusResponsePayload } from './messages';
 import { ModelsInstallResponsePayload } from '@alwaysai/device-agent-schemas';
 import sleep from '../util/sleep';
 import { createAppBackup, rollbackApp } from '../application-control/backup';
-import { TransactionQueue } from './transaction-queue';
+import { TransactionManager } from './transaction-manager';
 import {
   buildSignedUrlsRequestMessage,
   buildStatusResponseMessage
 } from './message-builder';
-import { generateTxId } from '@alwaysai/device-agent-schemas';
+import { reboot } from '../device-control/device-control';
 
 export class DeviceAgentCloudConnection {
   private shadowHandler: ShadowHandler;
   public publisher: Publisher;
   private cmdStatusMgr: CmdStatusManager;
   private liveUpdatesHandler: LiveUpdatesHandler;
-  private txnQueue: TransactionQueue;
+  private txnMgr: TransactionManager;
   private device = awsIot.device;
 
   private clientId = getDeviceUuid();
@@ -185,6 +186,21 @@ export class DeviceAgentCloudConnection {
     return true;
   };
 
+  private async handleDeviceAction(payload: DeviceActionPayload) {
+    const { system_restart } = keyMirrors.deviceAction;
+    switch (payload.action) {
+      case system_restart: {
+        await reboot();
+        break;
+      }
+      default: {
+        logger.info(
+          `Unrecognized device action requested: '${payload.action}'.`
+        );
+      }
+    }
+  }
+
   private async publishCloudRequest(message: ToCloudMessage) {
     this.publisher.publishToCloud(message);
   }
@@ -223,6 +239,7 @@ export class DeviceAgentCloudConnection {
 
     try {
       const out: R = await func(...args);
+      this.shadowHandler.clearAppConfig(projectId);
       await this.shadowHandler.updateProjectShadow(projectId);
       return out;
     } catch (errorAppUpdate) {
@@ -274,13 +291,13 @@ export class DeviceAgentCloudConnection {
         await this.liveUpdatesHandler.disableTransactionStatus({
           txId
         });
-        const sucessStatusResponsePayload = await getStatusResponsePayload(
+        const successStatusResponsePayload = await getStatusResponsePayload(
           keyMirrors.statusResponse.success,
           ''
         );
         // Send final status message
         const message = await buildStatusResponseMessage(
-          sucessStatusResponsePayload,
+          successStatusResponsePayload,
           txId
         );
         this.publisher.publishToClient(message);
@@ -311,62 +328,60 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  private handleAppConfigUpdates = async (
-    updates: ShadowUpdate[],
+  private handleAppConfigUpdate = async (
+    update: ShadowUpdate,
     txId: string
   ): Promise<boolean> => {
-    for (const update of updates) {
-      const { projectId, appCfgUpdate, envVarUpdate } = update;
-
-      if (
-        appCfgUpdate &&
-        appCfgUpdate.updatedModels &&
-        Object.keys(appCfgUpdate.updatedModels).length
-      ) {
-        // When there are model updates request signed URLs and wait to apply config changes
-        const { updatedModels } = appCfgUpdate;
-
-        logger.debug(
-          `Requesting presigned urls from cloud for model versions: ${JSON.stringify(
-            updatedModels
-          )}`
-        );
-        const modelsOnlyUrlsRequestPayload: SignedUrlsRequestPayload = {
-          modelsOnlyUrlsRequest: {
-            projectId,
-            models: updatedModels
-          }
-        };
-        const message = await buildSignedUrlsRequestMessage(
-          modelsOnlyUrlsRequestPayload,
-          txId
-        );
-        this.publisher.publishToCloud(message);
+    const { projectId, appCfgUpdate, envVarUpdate } = update;
+
+    if (
+      appCfgUpdate &&
+      appCfgUpdate.updatedModels &&
+      Object.keys(appCfgUpdate.updatedModels).length
+    ) {
+      // When there are model updates request signed URLs and wait to apply config changes
+      const { updatedModels } = appCfgUpdate;
+
+      logger.debug(
+        `Requesting presigned urls from cloud for model versions: ${JSON.stringify(
+          updatedModels
+        )}`
+      );
+      const modelsOnlyUrlsRequestPayload: SignedUrlsRequestPayload = {
+        modelsOnlyUrlsRequest: {
+          projectId,
+          models: updatedModels
+        }
+      };
+      const message = await buildSignedUrlsRequestMessage(
+        modelsOnlyUrlsRequestPayload,
+        txId
+      );
+      this.publisher.publishToCloud(message);
 
-        this.appCfgUpdateQueue.push(update);
-        return false;
-      }
+      this.appCfgUpdateQueue.push(update);
+      return false;
+    }
 
-      if (appCfgUpdate) {
-        await this.atomicApplicationUpdate(
-          updateAppCfg,
-          [
-            {
-              projectId,
-              newAppCfg: appCfgUpdate.newAppCfg
-            }
-          ],
-          projectId
-        );
-      }
+    if (appCfgUpdate) {
+      await this.atomicApplicationUpdate(
+        updateAppCfg,
+        [
+          {
+            projectId,
+            newAppCfg: appCfgUpdate.newAppCfg
+          }
+        ],
+        projectId
+      );
+    }
 
-      if (envVarUpdate) {
-        await this.atomicApplicationUpdate(
-          setEnv,
-          [{ projectId, envVars: envVarUpdate.envVars }],
-          projectId
-        );
-      }
+    if (envVarUpdate) {
+      await this.atomicApplicationUpdate(
+        setEnv,
+        [{ projectId, envVars: envVarUpdate.envVars }],
+        projectId
+      );
     }
     return true;
   };
@@ -392,7 +407,7 @@ export class DeviceAgentCloudConnection {
       this.publisher,
       this.clientId
     );
-    this.txnQueue = new TransactionQueue();
+    this.txnMgr = new TransactionManager();
 
     this.subscribe(this.toDeviceTopic);
     this.subscribe(this.secureTunnelNotifyTopic);
@@ -450,7 +465,7 @@ export class DeviceAgentCloudConnection {
         const projectId = payload.projectId;
 
         try {
-          this.txnQueue.addTxIdToQueue(txId, projectId);
+          this.txnMgr.addTransaction(txId, projectId);
           const completed = await this.atomicCmd({
             func: this.handleAppStateControl,
             args: [message.payload],
@@ -458,7 +473,7 @@ export class DeviceAgentCloudConnection {
             txId
           });
           if (completed) {
-            this.txnQueue.completeTxn(txId);
+            this.txnMgr.completeTransaction(txId);
           }
         } catch (e) {
           logger.error(
@@ -477,7 +492,7 @@ export class DeviceAgentCloudConnection {
             ? payload.appReleaseHash
             : undefined;
         try {
-          this.txnQueue.addTxIdToQueue(txId, projectId);
+          this.txnMgr.addTransaction(txId, projectId);
           const completed = await this.atomicCmd({
             func: this.handleAppVersionControl,
             args: [payload, txId],
@@ -485,7 +500,7 @@ export class DeviceAgentCloudConnection {
             txId
           });
           if (completed) {
-            this.txnQueue.completeTxn(txId);
+            this.txnMgr.completeTransaction(txId);
           }
         } catch (e) {
           logger.error(`Error processing application install request: ${e}!`);
@@ -502,9 +517,11 @@ export class DeviceAgentCloudConnection {
       case keyMirrors.toDeviceAgentMessageType.app_install_response: {
         const payload = message.payload;
         const { projectId, appReleaseHash } = payload.appInstallResponse;
-        if (txId !== this.txnQueue.getCurrentTxId()) {
+        if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
           throw new Error(
-            `App install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnQueue.getCurrentTxId()})!`
+            `App install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(
+              projectId
+            )})!`
           );
         }
         const completed = await this.atomicCmd({
@@ -514,7 +531,7 @@ export class DeviceAgentCloudConnection {
           txId
         });
         if (completed) {
-          this.txnQueue.completeTxn(txId);
+          this.txnMgr.completeTransaction(txId);
         }
 
         break;
@@ -524,9 +541,11 @@ export class DeviceAgentCloudConnection {
         // atomicCmd should be able to read it from the installed app
         const payload = message.payload;
         const { projectId } = payload.modelsInstallResponse;
-        if (txId !== this.txnQueue.getCurrentTxId()) {
+        if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
           throw new Error(
-            `Model install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnQueue.getCurrentTxId()})!`
+            `Model install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(
+              projectId
+            )})!`
           );
         }
         const completed = await this.atomicCmd({
@@ -536,11 +555,40 @@ export class DeviceAgentCloudConnection {
           txId
         });
         if (completed) {
-          this.txnQueue.completeTxn(txId);
+          this.txnMgr.completeTransaction(txId);
         }
 
         break;
       }
+      case keyMirrors.toDeviceAgentMessageType.device_action: {
+        try {
+          const successStatusResponsePayload = await getStatusResponsePayload(
+            keyMirrors.statusResponse.success,
+            ''
+          );
+          const successStatusResponseMessage = await buildStatusResponseMessage(
+            successStatusResponsePayload,
+            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}`
+          );
+          const failureStatusResponsePayload = await getStatusResponsePayload(
+            keyMirrors.statusResponse.failure,
+            e.message
+          );
+          const failureStatusResponseMessage = await buildStatusResponseMessage(
+            failureStatusResponsePayload,
+            txId
+          );
+          this.publisher.publishToClient(failureStatusResponseMessage);
+        }
+        break;
+      }
       default:
         logger.error(
           `Invalid client message: '${JSON.stringify(
@@ -559,7 +607,6 @@ export class DeviceAgentCloudConnection {
     logger.debug(
       `Received message: ${JSON.stringify({ topic, message }, null, 2)}`
     );
-    const txId = message.txId || generateTxId(); // txId should be passed in for DeviceAgentMessage messages but shadow updates won't have this
     switch (topic) {
       case this.shadowHandler.shadowTopics.projects.getAccepted:
       case this.shadowHandler.shadowTopics.projects.updateDelta: {
@@ -569,26 +616,23 @@ export class DeviceAgentCloudConnection {
           clientToken: message.clientToken
         });
         if (shadowUpdates.length) {
-          // FIXME: Take project ID of first shadow update. Most likely there will only be one update
-          // so this should be sufficient for now.
-          const projectId = shadowUpdates[0].projectId;
-          try {
+          for (const shadowUpdate of shadowUpdates) {
+            const projectId = shadowUpdate.projectId;
+            const txId = shadowUpdate.txId;
             try {
-              this.txnQueue.addTxIdToQueue(txId, projectId);
+              this.txnMgr.addTransaction(txId, projectId);
               const completed = await this.atomicCmd({
-                func: this.handleAppConfigUpdates,
-                args: [shadowUpdates, txId],
+                func: this.handleAppConfigUpdate,
+                args: [shadowUpdate, txId],
                 projectId,
                 txId
               });
               if (completed) {
-                this.txnQueue.completeTxn(txId);
+                this.txnMgr.completeTransaction(txId);
               }
             } catch (e) {
-              logger.error(`Error processing model update request: ${e}!`);
+              logger.error(`Error handling shadow message: ${e.message}`);
             }
-          } catch (e) {
-            logger.error(`Error handling shadow message: ${e.message}`);
           }
         }
         break;
@@ -619,6 +663,7 @@ export class DeviceAgentCloudConnection {
       // FIXME: EI-709 Skip this request for now to prevent kicking off another
       // shadow update process if IoT Core disconnect occurs during app config update
       //this.shadowHandler.getShadowUpdates();
+      void this.shadowHandler.updateSystemInfoShadow();
     });
 
     this.device.on('disconnect', () => {

package/src/cloud-connection/live-updates-handler.test.ts

@@ -1,6 +1,8 @@
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { Publisher } from './publisher';
 
+global.setTimeout = jest.fn() as unknown as typeof setTimeout;
+
 const testTrueToggles = {
   deviceStats: true,
   appState: true
@@ -15,8 +17,6 @@ const mockClient = jest.fn();
 const clientId = 'test-client';
 const emptyTxId = '';
 
-jest.spyOn(global, 'setTimeout');
-
 // NOTE: this was the way I found to mock private class functions
 const mockStartPublishingLiveUpdates = jest.spyOn(
   LiveUpdatesHandler.prototype as any,

package/src/cloud-connection/live-updates-handler.ts

@@ -69,7 +69,7 @@ export class LiveUpdatesHandler {
         logChunk: logStr
       };
       const message = await buildAppLogsMessage(payload, this.clientId);
-      this.publisher.publishToClient(message);
+      this.publisher.publishToClient(message, logger.silly);
     });
 
     readable.on('error', (error) => {
@@ -153,14 +153,8 @@ export class LiveUpdatesHandler {
         const payload: ToClientMessagePayload = await payloadBuilderFunction(
           ...args
         );
-        logger.debug(
-          `payload returned from builder: ${JSON.stringify(payload)}`
-        );
         const message = await messageBuilderFunction(payload, txId);
-        logger.debug(
-          `message returned from builder: ${JSON.stringify(message)}`
-        );
-        this.publisher.publishToClient(message);
+        this.publisher.publishToClient(message, logger.silly);
       } catch (e) {
         logger.error(
           `Error publishing live updates for ${messageType}: ${e.message}`

package/src/cloud-connection/messages.ts

@@ -7,9 +7,9 @@ import {
 import { StatusResponseValue } from '@alwaysai/device-agent-schemas/lib/constants';
 import { getAppState } from '../application-control';
 import {
-  getCpuUtil,
-  getDiskUtil,
-  getMemUtil
+  getCpuDetails,
+  getDiskDetails,
+  getMemDetails
 } from '../device-control/device-control';
 import { AgentConfigFile } from '../infrastructure/agent-config';
 
@@ -39,14 +39,14 @@ export async function getStatusResponsePayload(
 }
 
 export async function getDeviceStatsPayload(): Promise<DeviceStatsPayload> {
-  const cpuUsage = await getCpuUtil();
-  const diskUtil = await getDiskUtil();
-  const memUtil = await getMemUtil();
+  const cpuDetails = await getCpuDetails();
+  const diskDetails = await getDiskDetails();
+  const memDetails = await getMemDetails();
 
   const deviceStatsPayload: DeviceStatsPayload = {
-    cpuUsage,
-    diskUtil,
-    usedMemoryPercentage: memUtil
+    cpuDetails,
+    diskDetails,
+    memDetails
   };
   return deviceStatsPayload;
 }

package/src/cloud-connection/passthrough-handler.ts

@@ -70,18 +70,51 @@ function processPublish(passthroughHandler: PassthroughHandler) {
   while (messageQueue.length > 0) {
     const entry = messageQueue.shift();
     const { packet, msg } = entry;
-    ackQueue.push(msg);
-    // FIXME: put real topic here
-    passthroughHandler.publisher.publishToCloudWithAck(packet, (errOrResp) => {
-      while (ackQueue.length > 0) {
-        const msg = ackQueue.shift();
-        if (errOrResp === true) {
-          passthroughHandler.channel.ack(msg); // acknowledge, allow queue to discard
-        } else if (errOrResp === false) {
-          passthroughHandler.channel.reject(msg, true); // reject and requeue
+    try {
+      const parsedPacket = JSON.parse(packet);
+      if (parsedPacket && parsedPacket['action']) {
+        switch (parsedPacket['action']) {
+          case 'analytics':
+            ackQueue.push(msg);
+            // FIXME: put real topic here
+            passthroughHandler.publisher.publishToCloudWithAck(
+              packet,
+              (errOrResp) => {
+                while (ackQueue.length > 0) {
+                  const msg = ackQueue.shift();
+                  if (errOrResp === true) {
+                    passthroughHandler.channel.ack(msg); // acknowledge, allow queue to discard
+                  } else if (errOrResp === false) {
+                    passthroughHandler.channel.reject(msg, true); // reject and requeue
+                  }
+                }
+              }
+            );
+            break;
+          case 'heartbeat':
+            passthroughHandler.channel.ack(msg);
+            logger.debug(
+              `Heartbeat package received & acknowledged: ${packet}`
+            );
+            break;
+          default:
+            passthroughHandler.channel.ack(msg);
+            logger.debug(
+              `Unknown 'action' package received & acknowledged: ${packet}`
+            );
+            break;
         }
+      } else {
+        passthroughHandler.channel.ack(msg);
+        logger.debug(
+          `Received & acknowledged a RabbitMQ Package of unknown structure: ${parsedPacket}`
+        );
       }
-    });
+    } catch (e) {
+      logger.error(`There was a problem parsing RabbitMQ packet ${e}`);
+      passthroughHandler.channel.ack(msg);
+      logger.debug(`Problematic packet was acknowledged`);
+    }
   }
 }
 

package/src/cloud-connection/publisher.ts

@@ -5,6 +5,7 @@ import {
   getToClientTopic,
   getToCloudTopic
 } from '@alwaysai/device-agent-schemas';
+import * as winston from 'winston';
 
 export class Publisher {
   private client: any;
@@ -19,8 +20,20 @@ export class Publisher {
     this.toCloudTopic = getToCloudTopic(this.clientId);
   }
 
-  public publish(topic: string, payload: string) {
+  public publish(
+    topic: string,
+    payload: string,
+    customLogger: winston.LeveledLogMethod = logger.debug
+  ) {
     // TODO: topic validation
+    // By default, log the published message at debug level, unless otherwise specified
+    customLogger(
+      `Publishing message:\nTopic: ${topic}\nMessage: ${JSON.stringify(
+        JSON.parse(payload),
+        null,
+        2
+      )}`
+    );
     this.client.publish(topic, payload, (err: any) => {
       if (err) {
         logger.error(
@@ -52,21 +65,25 @@ export class Publisher {
 
   public publishDeviceAgentMessage(
     topic: string,
-    message: ToClientMessage | ToCloudMessage
+    message: ToClientMessage | ToCloudMessage,
+    logger?: winston.LeveledLogMethod
   ) {
     const messageStr = JSON.stringify(message);
-    logger.debug(
-      `Publishing message:\n${JSON.stringify({ topic, message }, null, 2)}`
-    );
-    this.publish(topic, messageStr);
+    this.publish(topic, messageStr, logger);
   }
 
-  public publishToClient(message: ToClientMessage) {
-    this.publishDeviceAgentMessage(this.toClientTopic, message);
+  public publishToClient(
+    message: ToClientMessage,
+    logger?: winston.LeveledLogMethod
+  ) {
+    this.publishDeviceAgentMessage(this.toClientTopic, message, logger);
   }
 
-  public publishToCloud(message: ToCloudMessage) {
+  public publishToCloud(
+    message: ToCloudMessage,
+    logger?: winston.LeveledLogMethod
+  ) {
     // Can edit topic field in message here if we want
-    this.publishDeviceAgentMessage(this.toCloudTopic, message);
+    this.publishDeviceAgentMessage(this.toCloudTopic, message, logger);
   }
 }

package/src/cloud-connection/shadow-handler.test.ts

@@ -113,6 +113,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(1);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         appCfgUpdate: {
           newAppCfg: appCfg1,
           updatedModels: {
@@ -157,6 +158,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(1);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         appCfgUpdate: {
           newAppCfg: appCfg1,
           updatedModels: {
@@ -222,6 +224,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(2);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         appCfgUpdate: {
           newAppCfg: appCfg1,
           updatedModels: {
@@ -232,6 +235,7 @@ describe('Test Shadow Handler', () => {
       });
       expect(updates[1]).toEqual({
         projectId: projectId2,
+        txId: expect.any(String),
         appCfgUpdate: {
           newAppCfg: appCfg2,
           updatedModels: {
@@ -274,6 +278,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(1);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         appCfgUpdate: {
           newAppCfg: appCfg1
         }
@@ -337,6 +342,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(1);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         envVarUpdate: {
           envVars: envVars1
         }
@@ -361,6 +367,7 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(1);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         envVarUpdate: {
           envVars: envVars1
         }
@@ -391,12 +398,14 @@ describe('Test Shadow Handler', () => {
       expect(updates.length).toBe(2);
       expect(updates[0]).toEqual({
         projectId: projectId1,
+        txId: expect.any(String),
         envVarUpdate: {
           envVars: envVars1
         }
       });
       expect(updates[1]).toEqual({
         projectId: projectId2,
+        txId: expect.any(String),
         envVarUpdate: {
           envVars: envVars2
         }