@alwaysai/device-agent 0.0.13 → 0.0.15

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

@@ -8,13 +8,15 @@ import { getAppLogs } from '../application-control';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
-import { getAppStateMessage, getDeviceStatsMessage } from './messages';
+import {
+  getAppInstallStatusMessage,
+  getAppStateMessage,
+  getDeviceStatsMessage
+} from './messages';
 import { AgentMessageTypeValue } from '@alwaysai/device-agent-schemas/lib/constants';
-import { AppInstallStatusManager } from './app-install-status';
 
 export class LiveUpdatesHandler {
   private publisher: Publisher;
-  private appInstallStatusMgr: AppInstallStatusManager;
 
   private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
   private liveUpdatesAlive = {
@@ -32,14 +34,6 @@ export class LiveUpdatesHandler {
   private appLogStreams = new Set<string>();
   private appInstallStatuses = new Set<string>();
 
-  constructor(
-    publisher: Publisher,
-    appInstallStatusMgr: AppInstallStatusManager
-  ) {
-    this.publisher = publisher;
-    this.appInstallStatusMgr = appInstallStatusMgr;
-  }
-
   private async startAppLogStream(projectId: string) {
     logger.info(`Starting log stream for ${projectId}`);
     this.appLogStreams.add(projectId);
@@ -77,50 +71,19 @@ export class LiveUpdatesHandler {
     });
   }
 
-  // Use arrow function to allow `this` to be accessed
-  private getAppInstallStatusMessage = async (appReleaseHash: string) => {
-    const appInstallStatus =
-      this.appInstallStatusMgr.getStatusPacket(appReleaseHash);
-    const appInstallStatusMessage = {
-      messageType: keyMirrors.agentMessageType.app_install_status,
-      appInstallStatus
-    };
-    return appInstallStatusMessage;
-  };
-
-  public async startPublishingLiveUpdates<T extends any[]>(
-    messageType: AgentMessageTypeValue,
-    getMessageData: (...args: T) => Promise<DeviceAgentMessagePayload>,
-    args: T
-  ) {
-    logger.info(`Turned on live updates for ${messageType}`);
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      try {
-        const message = await getMessageData(...args);
-        this.publisher.publishToClient(message);
-      } catch (e) {
-        logger.error(
-          `Error publishing live updates for ${messageType}: ${e.message}`
-        );
-        break;
-      }
-      if (!this.continuePublishing(messageType, ...args)) {
-        logger.info(`Turned off live updates for ${messageType}`);
-        break;
-      }
-      await sleep(this.getLiveUpdatesInterval(messageType));
-    }
-  }
-
-  private continuePublishing(flag: AgentMessageTypeValue, data?: any): boolean {
+  private continuePublishing(
+    flag: AgentMessageTypeValue,
+    projectId?: string
+  ): boolean {
     switch (flag) {
       case keyMirrors.agentMessageType.device_stats:
       case keyMirrors.agentMessageType.app_state:
         return this.liveUpdatesAlive[flag];
       case keyMirrors.agentMessageType.app_install_status: {
-        const appReleaseHash: string = data;
-        return this.appInstallStatuses.has(appReleaseHash);
+        if (!projectId) {
+          throw new Error(`Project ID not provided to continuePublishing!`);
+        }
+        return this.appInstallStatuses.has(projectId);
       }
       default:
         logger.error(`Unrecognized publishable flag ${flag}`);
@@ -158,28 +121,73 @@ export class LiveUpdatesHandler {
     }, 600000); // 10 min
   }
 
-  public async update({
-    deviceStats,
-    appState,
-    appLogs,
-    appInstallStatus
-  }: {
-    deviceStats?: boolean;
-    appState?: boolean;
-    appLogs?: {
-      projectId: string;
-      toggle: boolean;
-    };
-    appInstallStatus?: {
-      appReleaseHash: string;
-      toggle: boolean;
-    };
+  private async startPublishingLiveUpdates<T extends any[]>(
+    messageType: AgentMessageTypeValue,
+    getMessageData: (...args: T) => Promise<DeviceAgentMessagePayload>,
+    args: T,
+    projectId?: string
+  ) {
+    logger.info(`Turned on live updates for ${messageType}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        const message = await getMessageData(...args);
+        this.publisher.publishToClient(message);
+      } catch (e) {
+        logger.error(
+          `Error publishing live updates for ${messageType}: ${e.message}`
+        );
+        break;
+      }
+      if (!this.continuePublishing(messageType, projectId)) {
+        logger.info(`Turned off live updates for ${messageType}`);
+        break;
+      }
+      await sleep(this.getLiveUpdatesInterval(messageType));
+    }
+  }
+
+  /*=================================================================
+                            Public interface
+  =================================================================*/
+
+  constructor(publisher: Publisher) {
+    this.publisher = publisher;
+  }
+
+  public async enableAppInstallStatus(props: {
+    projectId: string;
+    appReleaseHash: string;
   }) {
+    const { projectId, appReleaseHash } = props;
+    this.liveUpdatesAlive.app_install_status = true;
+    this.appInstallStatuses.add(projectId);
+    // Don't wait for this call to finish since it loops until disabled
+    void this.startPublishingLiveUpdates(
+      keyMirrors.agentMessageType.app_install_status,
+      getAppInstallStatusMessage,
+      [keyMirrors.appInstallStatus.in_progress, '', appReleaseHash],
+      projectId
+    );
+  }
+
+  public async disableAppInstallStatus(props: { projectId: string }) {
+    const { projectId } = props;
+    this.appInstallStatuses.delete(projectId);
+
+    if (this.appInstallStatuses.size === 0) {
+      this.liveUpdatesAlive.app_install_status = false;
+    }
+  }
+
+  public async handleToggles(toggles: LiveUpdatesToggles) {
+    const { deviceStats, appState, appLogs } = toggles;
     this.restartLiveUpdatesTimeout();
     if (deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = deviceStats;
       if (deviceStats) {
-        this.startPublishingLiveUpdates(
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.device_stats,
           getDeviceStatsMessage,
           []
@@ -190,7 +198,8 @@ export class LiveUpdatesHandler {
     if (appState !== undefined) {
       this.liveUpdatesAlive.app_state = appState;
       if (appState) {
-        this.startPublishingLiveUpdates(
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.app_state,
           getAppStateMessage,
           []
@@ -200,27 +209,11 @@ export class LiveUpdatesHandler {
 
     if (appLogs !== undefined) {
       if (appLogs.toggle) {
-        this.startAppLogStream(appLogs.projectId);
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startAppLogStream(appLogs.projectId);
       } else {
         this.appLogStreams.delete(appLogs.projectId);
       }
     }
-
-    if (appInstallStatus !== undefined) {
-      if (appInstallStatus.toggle) {
-        this.liveUpdatesAlive.app_install_status = appInstallStatus.toggle;
-        this.appInstallStatuses.add(appInstallStatus.appReleaseHash);
-        this.startPublishingLiveUpdates(
-          keyMirrors.agentMessageType.app_install_status,
-          this.getAppInstallStatusMessage,
-          [appInstallStatus.appReleaseHash]
-        );
-      } else {
-        this.appInstallStatuses.delete(appInstallStatus.appReleaseHash);
-      }
-      if (this.appInstallStatuses.size === 0) {
-        this.liveUpdatesAlive.app_install_status = false;
-      }
-    }
   }
 }

package/src/cloud-connection/messages.ts

@@ -1,4 +1,9 @@
-import { AppStatePacket, keyMirrors } from '@alwaysai/device-agent-schemas';
+import {
+  AppInstallStatusMessage,
+  AppStatePacket,
+  keyMirrors
+} from '@alwaysai/device-agent-schemas';
+import { AppInstallStatusValue } from '@alwaysai/device-agent-schemas/lib/constants';
 import { getAppStatus } from '../application-control';
 import {
   getCpuUtil,
@@ -22,6 +27,22 @@ export async function getAppStateMessage() {
   return appStatePackage;
 }
 
+export async function getAppInstallStatusMessage(
+  status: AppInstallStatusValue,
+  message: string,
+  appReleaseHash: string
+): Promise<AppInstallStatusMessage> {
+  const appInstallStatusMessage: AppInstallStatusMessage = {
+    messageType: keyMirrors.agentMessageType.app_install_status,
+    appInstallStatus: {
+      status,
+      message,
+      appReleaseHash
+    }
+  };
+  return appInstallStatusMessage;
+}
+
 export async function getDeviceStatsMessage() {
   const cpuUsage = await getCpuUtil();
   const diskUtil = await getDiskUtil();

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

@@ -0,0 +1,67 @@
+// eslint-disable-next-line
+const amqp = require('amqplib');
+import { setupRabbitMQContainer } from '../local-connection/rabbitmq-connection';
+import { logger } from '../util/logger';
+import { Publisher } from './publisher';
+
+const messageQueue: any[] = [];
+const ackQueue: any[] = [];
+
+export class PassthroughHandler {
+  public publisher: Publisher;
+  public connection;
+  public channel;
+  public packetQueue;
+
+  constructor(publisher: Publisher) {
+    this.publisher = publisher;
+  }
+
+  public async setup() {
+    await setupRabbitMQContainer();
+    this.connection = await amqp.connect('amqp://localhost');
+    this.channel = await this.connection.createChannel();
+    this.channel.prefetch(1); // This ensures we only get one packet at a time! This appears to have prevented throttling
+    this.packetQueue = 'edgeiq-analytics-publish';
+    await this.channel.assertQueue(this.packetQueue, {
+      durable: true
+    });
+  }
+}
+
+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) => {
+      logger.debug('packet published to cloud?', 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
+        }
+      }
+    });
+  }
+}
+
+export async function runChannel(passthroughHandler: PassthroughHandler) {
+  logger.debug('Beginning to consume packets');
+  passthroughHandler.channel.consume(
+    passthroughHandler.packetQueue,
+    function (msg) {
+      if (msg.content !== undefined) {
+        const packet = JSON.parse(msg.content.toString());
+        messageQueue.push({ packet, msg });
+        processPublish(passthroughHandler);
+      }
+    },
+    {
+      noAck: false // When true, RabbitMQ deletes message as soon as it is consumed
+    }
+  );
+}

package/src/cloud-connection/publisher.ts

@@ -43,6 +43,27 @@ export class Publisher {
     });
   }
 
+  public publishToCloudWithAck(
+    payload: string,
+    ackNackCallback: CallableFunction
+  ) {
+    const topic = this.toCloudTopic;
+    logger.debug('payload received to publishWithAck', payload);
+    this.client.publish(topic, payload, { qos: 1 }, (err: any, resp: any) => {
+      if (err) {
+        logger.error(
+          `Error publishing message: \nTopic: ${topic}\nMessage: ${payload}\nError: ${err}`
+        );
+        ackNackCallback(false);
+      } else if (resp) {
+        logger.debug(
+          `Successfully published message: \nTopic: ${topic}\nMessage: ${payload}`
+        );
+        ackNackCallback(true);
+      }
+    });
+  }
+
   public publishDeviceAgentPayload(
     topic: string,
     payload: DeviceAgentMessagePayload

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

@@ -0,0 +1,361 @@
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
+import { readAppCfgFile } from '../application-control';
+import { Publisher } from './publisher';
+import { ShadowHandler } from './shadow-handler';
+
+jest.mock('../application-control');
+jest.mock('./publisher');
+const mockClient = jest.fn();
+const clientId = 'test-client';
+const projectId1 = 'test-project';
+const projectId2 = 'test-project-2';
+
+describe('Test Shadow Handler', () => {
+  let publisher: Publisher;
+  let shadowHandler: ShadowHandler;
+
+  beforeEach(() => {
+    publisher = new Publisher(mockClient, clientId);
+    shadowHandler = new ShadowHandler(clientId, publisher);
+  });
+
+  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,
+        payload: Buffer.from('test-payload')
+      });
+    }).toThrow(Error);
+  });
+
+  test('ignore message from self', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v3': 4
+      }
+    };
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      },
+      clientToken: clientId
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test('handle shadow get response with updated models', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v3': 4
+      }
+    };
+
+    const payload = {
+      delta: {
+        [projectId1]: {
+          appConfig: JSON.stringify(appCfg1)
+        }
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.getAccepted,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/yolo_v3': 4
+      }
+    });
+  });
+
+  test('handle shadow delta without app config', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const payload = {
+      [projectId1]: {}
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test('handle shadow delta with updated models', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    });
+  });
+
+  test('handle shadow delta with updated models for two apps', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValueOnce(ogAppCfg1);
+    const ogAppCfg2: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v4': 5
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValueOnce(ogAppCfg2);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    };
+    const appCfg2: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v4': 5,
+        'alwaysai/human_pose': 7
+      }
+    };
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      },
+      [projectId2]: {
+        appConfig: JSON.stringify(appCfg2)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(2);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    });
+    expect(appCfgUpdates[1]).toEqual({
+      projectId: projectId2,
+      newAppCfg: appCfg2,
+      updatedModels: {
+        'alwaysai/human_pose': 7
+      }
+    });
+  });
+
+  test('handle shadow delta with updated analytics', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {}
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {},
+      analytics: {
+        enable_cloud_publish: true
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1
+    });
+  });
+
+  test('handle shadow delta with invalid app config', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1 = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': '3',
+        'alwaysai/yolo_v4': '5'
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test.skip('publish app state', async () => {
+    // FIXME: For some reason publisher is not being called...
+    const testAppCfg: AppConfig = {
+      scripts: {
+        start: ''
+      },
+      models: {}
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(testAppCfg);
+
+    await shadowHandler.publishAppState(projectId1);
+    expect(jest.mocked(readAppCfgFile)).toBeCalledWith({ projectId1 });
+    const packet = {
+      state: {
+        reported: {
+          [projectId1]: { appConfig: JSON.stringify(testAppCfg) }
+        }
+      },
+      clientToken: clientId
+    };
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.update,
+      JSON.stringify(packet)
+    );
+  });
+
+  test('get shadow updates', async () => {
+    shadowHandler.getShadowUpdates();
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.get,
+      JSON.stringify({
+        clientToken: clientId
+      })
+    );
+  });
+
+  test('delete project shadow', async () => {
+    shadowHandler.deleteProjectShadow(projectId1);
+    const packet = {
+      state: {
+        reported: {
+          [projectId1]: null
+        }
+      },
+      clientToken: clientId
+    };
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.update,
+      JSON.stringify(packet)
+    );
+  });
+});