@alwaysai/device-agent 1.3.0 → 1.3.1-2

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

@@ -3,6 +3,11 @@ import { Publisher } from './publisher';
 
 global.setTimeout = jest.fn() as unknown as typeof setTimeout;
 
+// https://github.com/facebook/react-native/issues/35701
+Object.defineProperty(global, 'performance', {
+  writable: true
+});
+
 const testTrueToggles = {
   deviceStats: true,
   appState: true
@@ -66,4 +71,19 @@ describe('Test Live Updates Handler', () => {
     expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
     expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
   });
+
+  test('timeout turns off live updates', async () => {
+    jest.useFakeTimers({ legacyFakeTimers: true });
+
+    void liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
+    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(true);
+    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(true);
+    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+
+    jest.runAllTimers();
+
+    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(false);
+    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
+    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+  });
 });

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

@@ -1,27 +1,21 @@
 import {
   AppLogsPayload,
-  ToClientMessagePayload,
   keyMirrors,
   LiveStateUpdatesTogglePayload,
-  ToClientMessage
+  ToClientMessage,
+  buildAppLogsMessage,
+  buildAppStateMessage,
+  buildDeviceStatsMessage,
+  StatusResponsePayload,
+  buildToClientStatusResponseMessage
 } from '@alwaysai/device-agent-schemas';
 import { getAppLogs } from '../application-control';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
-import {
-  getStatusResponsePayload,
-  getAppStatePayload,
-  getDeviceStatsPayload
-} from './messages';
+import { getAppStatePayload, getDeviceStatsPayload } from './messages';
 import { ToClientMessageTypeValue } from '@alwaysai/device-agent-schemas';
 import { ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS } from '../environment';
-import {
-  buildAppLogsMessage,
-  buildAppStateMessage,
-  buildDeviceStatsMessage,
-  buildStatusResponseMessage
-} from './message-builder';
 
 const LIVE_UPDATES_TIMEOUT = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
   ? parseInt(ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS)
@@ -48,8 +42,9 @@ export class LiveUpdatesHandler {
   private appLogStreams = new Set<string>();
   private transactionStatuses = new Set<string>();
 
-  private async startAppLogStream(projectId: string) {
+  private async startAppLogStream(projectId: string, txId: string) {
     logger.info(`Starting log stream for ${projectId}`);
+
     this.appLogStreams.add(projectId);
     const readable = await getAppLogs({
       projectId,
@@ -68,7 +63,7 @@ export class LiveUpdatesHandler {
         projectId,
         logChunk: logStr
       };
-      const message = await buildAppLogsMessage(payload, this.clientId);
+      const message = buildAppLogsMessage(this.clientId, payload, txId);
       this.publisher.publishToClient(message, logger.silly);
     });
 
@@ -117,7 +112,7 @@ export class LiveUpdatesHandler {
       this.liveUpdatesAlive.device_stats = toggles.deviceStats;
     }
     if (toggles.appState !== undefined) {
-      this.liveUpdatesAlive.app_logs = toggles.appState;
+      this.liveUpdatesAlive.app_state = toggles.appState;
     }
   }
 
@@ -132,36 +127,25 @@ export class LiveUpdatesHandler {
     }, LIVE_UPDATES_TIMEOUT);
   }
 
-  private async startPublishingLiveUpdates<T extends any[]>(
+  private async startPublishingLiveUpdates(
     messageType: ToClientMessageTypeValue,
-    payloadBuilderFunction: (...args: T) => Promise<ToClientMessagePayload>,
-    messageBuilderFunction: (
-      payload: ToClientMessagePayload,
-      txId: string
-    ) => Promise<ToClientMessage>,
-    args: T,
+    getMessage: () => Promise<ToClientMessage>,
     txId: string
   ) {
     logger.info(`Turned on live updates for ${messageType}`);
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      try {
-        if (!this.continuePublishing(messageType, txId)) {
-          logger.info(`Turned off live updates for ${messageType}`);
-          break;
-        }
-        const payload: ToClientMessagePayload = await payloadBuilderFunction(
-          ...args
-        );
-        const message = await messageBuilderFunction(payload, txId);
+    try {
+      while (this.continuePublishing(messageType, txId)) {
+        const message = await getMessage();
         this.publisher.publishToClient(message, logger.silly);
-      } catch (e) {
-        logger.error(
-          `Error publishing live updates for ${messageType}: ${e.message}`
-        );
+
+        await sleep(this.getLiveUpdatesInterval(messageType));
       }
-      await sleep(this.getLiveUpdatesInterval(messageType));
+    } catch (e) {
+      logger.error(
+        `Error publishing live updates for ${messageType}: ${e.message}`
+      );
     }
+    logger.info(`Turned off live updates for ${messageType}`);
   }
 
   /*=================================================================
@@ -196,9 +180,16 @@ export class LiveUpdatesHandler {
       // Don't wait for this call to finish since it loops until disabled
       void this.startPublishingLiveUpdates(
         keyMirrors.toClientMessageType.status_response,
-        getStatusResponsePayload,
-        buildStatusResponseMessage,
-        [keyMirrors.statusResponse.in_progress, ''],
+        async () => {
+          const payload: StatusResponsePayload = {
+            status: keyMirrors.statusResponse.in_progress
+          };
+          return buildToClientStatusResponseMessage(
+            this.clientId,
+            payload,
+            txId
+          );
+        },
         txId
       );
     }
@@ -220,41 +211,43 @@ export class LiveUpdatesHandler {
     const { deviceStats, appState, appLogs } = toggles;
     this.restartLiveUpdatesTimeout();
 
-    const currentDeviceStats = this.getDeviceStatsLiveUpdates();
     if (deviceStats !== undefined) {
+      const currentDeviceStats = this.getDeviceStatsLiveUpdates();
       this.liveUpdatesAlive.device_stats = deviceStats;
       if (deviceStats && currentDeviceStats !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
           keyMirrors.toClientMessageType.device_stats,
-          getDeviceStatsPayload,
-          buildDeviceStatsMessage,
-          [],
+          async () => {
+            const payload = await getDeviceStatsPayload();
+            return buildDeviceStatsMessage(this.clientId, payload, txId);
+          },
           txId
         );
       }
     }
 
-    const currentAppState = this.getAppStateLiveUpdates();
     if (appState !== undefined) {
+      const currentAppState = this.getAppStateLiveUpdates();
       this.liveUpdatesAlive.app_state = appState;
       if (appState && currentAppState !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
           keyMirrors.toClientMessageType.app_state,
-          getAppStatePayload,
-          buildAppStateMessage,
-          [],
+          async () => {
+            const payload = await getAppStatePayload();
+            return buildAppStateMessage(this.clientId, payload, txId);
+          },
           txId
         );
       }
     }
 
-    const currentAppLogs = this.getAppLogsLiveUpdates();
     if (appLogs !== undefined) {
+      const currentAppLogs = this.getAppLogsLiveUpdates();
       if (appLogs.toggle && currentAppLogs !== true) {
         // Don't wait for this call to finish since it loops until disabled
-        void this.startAppLogStream(appLogs.projectId);
+        void this.startAppLogStream(appLogs.projectId, txId);
       } else {
         this.appLogStreams.delete(appLogs.projectId);
       }

package/src/cloud-connection/messages.ts

@@ -1,10 +1,8 @@
 import {
   AppState,
   AppStatePayload,
-  DeviceStatsPayload,
-  StatusResponsePayload
+  DeviceStatsPayload
 } from '@alwaysai/device-agent-schemas';
-import { StatusResponseValue } from '@alwaysai/device-agent-schemas/lib/constants';
 import { getAppState } from '../application-control';
 import {
   getCpuDetails,
@@ -27,17 +25,6 @@ export async function getAppStatePayload(): Promise<AppStatePayload> {
   return appStatePayload;
 }
 
-export async function getStatusResponsePayload(
-  status: StatusResponseValue,
-  message: string
-): Promise<StatusResponsePayload> {
-  const statusResponsePayload: StatusResponsePayload = {
-    status,
-    message
-  };
-  return statusResponsePayload;
-}
-
 export async function getDeviceStatsPayload(): Promise<DeviceStatsPayload> {
   const cpuDetails = await getCpuDetails();
   const diskDetails = await getDiskDetails();

package/src/cloud-connection/publisher.ts

@@ -86,4 +86,8 @@ export class Publisher {
     // Can edit topic field in message here if we want
     this.publishDeviceAgentMessage(this.toCloudTopic, message, logger);
   }
+
+  public getClientId(): string {
+    return this.clientId;
+  }
 }

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

@@ -2,6 +2,9 @@ import { AppConfig } from '@alwaysai/app-configuration-schemas';
 import { readAppCfgFile } from '../application-control';
 import { Publisher } from './publisher';
 import { ShadowHandler } from './shadow-handler';
+import { Logger } from 'winston';
+import { logger } from '../util/logger';
+import { getShadowTopic } from '@alwaysai/device-agent-schemas';
 
 jest.mock('../application-control');
 jest.mock('./publisher');
@@ -22,8 +25,8 @@ describe('Test Shadow Handler', () => {
   test.skip('reject buffer payload', async () => {
     //FIXME: Invalid input is silently ignored, need input validation
     expect(async () => {
-      await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload: Buffer.from('test-payload'),
         clientToken: ''
       });
@@ -55,8 +58,8 @@ describe('Test Shadow Handler', () => {
       }
     };
 
-    const updates = await shadowHandler.handleShadowTopic({
-      topic: shadowHandler.shadowTopics.projects.updateDelta,
+    const updates = await shadowHandler.handleProjectShadow({
+      topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
       payload,
       clientToken: clientId
     });
@@ -65,11 +68,13 @@ describe('Test Shadow Handler', () => {
 
   test('handle project shadow empty delta', async () => {
     const payload = {
-      [projectId1]: {}
+      desired: {
+        [projectId1]: {}
+      }
     };
 
-    const updates = await shadowHandler.handleShadowTopic({
-      topic: shadowHandler.shadowTopics.projects.updateDelta,
+    const updates = await shadowHandler.handleProjectShadow({
+      topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
       payload,
       clientToken: ''
     });
@@ -98,15 +103,17 @@ describe('Test Shadow Handler', () => {
       };
 
       const payload = {
-        delta: {
-          [projectId1]: {
-            appConfig: JSON.stringify(appCfg1)
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: JSON.stringify(appCfg1)
+            }
           }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.getAccepted,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -145,13 +152,17 @@ describe('Test Shadow Handler', () => {
       };
 
       const payload = {
-        [projectId1]: {
-          appConfig: JSON.stringify(appCfg1)
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: JSON.stringify(appCfg1)
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -208,16 +219,20 @@ describe('Test Shadow Handler', () => {
         }
       };
       const payload = {
-        [projectId1]: {
-          appConfig: JSON.stringify(appCfg1)
-        },
-        [projectId2]: {
-          appConfig: JSON.stringify(appCfg2)
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: JSON.stringify(appCfg1)
+            },
+            [projectId2]: {
+              appConfig: JSON.stringify(appCfg2)
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -265,13 +280,17 @@ describe('Test Shadow Handler', () => {
       };
 
       const payload = {
-        [projectId1]: {
-          appConfig: JSON.stringify(appCfg1)
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: JSON.stringify(appCfg1)
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -307,60 +326,110 @@ describe('Test Shadow Handler', () => {
       };
 
       const payload = {
-        [projectId1]: {
-          appConfig: JSON.stringify(appCfg1)
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: JSON.stringify(appCfg1)
+            }
+          }
+        }
+      };
+
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        payload,
+        clientToken: ''
+      });
+      expect(updates.length).toBe(0);
+    });
+
+    test('handles an unparsable object in a project shadow appCfg delta', async () => {
+      const ogAppCfg1: AppConfig = {
+        scripts: {
+          start: 'python app.py'
+        },
+        models: {}
+      };
+      jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+      // This appCfg is invalid on it's own (see values below)
+      const appCfg1 = {
+        scripts: {
+          start: 'python app.py'
+        },
+        models: {
+          'alwaysai/mobilenet_ssd': '3', // string instead of int
+          'alwaysai/yolo_v4': '5' // string instead of int
+        }
+      };
+
+      const payload = {
+        state: {
+          desired: {
+            [projectId1]: {
+              appConfig: appCfg1 // This is missing JSON.stringify() making this an unparsable object.
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const loggerSpy = jest
+        .spyOn(logger, 'error')
+        .mockReturnValue({} as unknown as Logger);
+
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
+
       expect(updates.length).toBe(0);
+      expect(loggerSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Error validating shadow update')
+      );
     });
   });
 
   describe('handle project shadow env vars', () => {
-    test('handle project shadow env vars get response with delta', async () => {
+    test('handle a response from the getAccepted from the cloud', async () => {
       const envVars1 = {
         VAR0: 'value0'
       };
       const payload = {
-        delta: {
-          [projectId1]: {
-            envVars: envVars1
+        state: {
+          reported: {
+            [projectId1]: {
+              envVars: { service: envVars1 }
+            }
           }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.getAccepted,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'get/accepted'),
         payload,
-        clientToken: ''
-      });
-      expect(updates.length).toBe(1);
-      expect(updates[0]).toEqual({
-        projectId: projectId1,
-        txId: expect.any(String),
-        envVarUpdate: {
-          envVars: envVars1
-        }
+        clientToken: clientId
       });
+      expect(updates.length).toBe(0);
     });
-
     test('handle project shadow env vars update delta', async () => {
       const envVars1 = {
         VAR1: 'value1'
       };
       const payload = {
-        [projectId1]: {
-          envVars: envVars1
+        state: {
+          desired: {
+            [projectId1]: {
+              envVars: {
+                service: envVars1
+              }
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -369,29 +438,36 @@ describe('Test Shadow Handler', () => {
         projectId: projectId1,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: envVars1
+          envVars: { service: envVars1 }
         }
       });
     });
 
     test('handle project shadow env vars update delta for two projects', async () => {
-      const envVars1 = {
+      const service1 = {
         VAR1: 'value1'
       };
-      const envVars2 = {
-        VAR2: null
+      const service2 = {
+        VAR2: 'value2'
       };
+
       const payload = {
-        [projectId1]: {
-          envVars: envVars1
-        },
-        [projectId2]: {
-          envVars: envVars2
+        state: {
+          desired: {
+            [projectId1]: {
+              envVars: {
+                service: service1
+              }
+            },
+            [projectId2]: {
+              envVars: { service: service2 }
+            }
+          }
         }
       };
 
-      const updates = await shadowHandler.handleShadowTopic({
-        topic: shadowHandler.shadowTopics.projects.updateDelta,
+      const updates = await shadowHandler.handleProjectShadow({
+        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
         payload,
         clientToken: ''
       });
@@ -400,34 +476,35 @@ describe('Test Shadow Handler', () => {
         projectId: projectId1,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: envVars1
+          envVars: { service: service1 }
         }
       });
       expect(updates[1]).toEqual({
         projectId: projectId2,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: envVars2
+          envVars: { service: service2 }
         }
       });
     });
   });
 
   test('clear project shadow', async () => {
-    shadowHandler.clearAppConfig(projectId1);
+    await shadowHandler.clearProjectShadow(projectId1);
+    // The order of reported and desired in the packet does not matter for the device agent, but the test is checking literal equality of expected output, and therefore the order matters here with reported being first.
     const packet = {
+      clientToken: clientId,
       state: {
-        desired: {
+        reported: {
           [projectId1]: null
         },
-        reported: {
+        desired: {
           [projectId1]: null
         }
-      },
-      clientToken: clientId
+      }
     };
     expect(jest.mocked(publisher.publish)).toBeCalledWith(
-      shadowHandler.shadowTopics.projects.update,
+      getShadowTopic(clientId, 'projects', 'update'),
       JSON.stringify(packet)
     );
   });
@@ -453,15 +530,15 @@ describe('Test Shadow Handler', () => {
       clientToken: clientId
     };
     expect(jest.mocked(publisher.publish)).toBeCalledWith(
-      shadowHandler.shadowTopics.projects.update,
+      getShadowTopic(clientId, 'projects', 'update'),
       JSON.stringify(packet)
     );
   });
 
   test('get shadow updates', async () => {
-    shadowHandler.getShadowUpdates();
+    shadowHandler.getProjectShadowUpdates();
     expect(jest.mocked(publisher.publish)).toBeCalledWith(
-      shadowHandler.shadowTopics.projects.get,
+      getShadowTopic(clientId, 'projects', 'get'),
       JSON.stringify({
         clientToken: clientId
       })