@alwaysai/device-agent 0.0.6 → 0.0.8

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

@@ -5,178 +5,162 @@ import {
   getCertificateFilePath,
   getRootCertificateFilePath,
 } from '../util/directories';
+import sleep from '../util/sleep';
 import {
   startApp,
   stopApp,
   restartApp,
-  getAppStatus,
   getAppLogs,
+  getAppStatus,
 } from '../application-control/status';
-import { installApp } from '../application-control/install';
-import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
+import { installApp, uninstallApp } from '../application-control/install';
 import {
-  DeviceAgentMessage,
+  keyMirrors,
+  validateClientMessage,
+  DeviceAgentMessagePayload,
+  AppInstallStatusPacket,
+  AppStateControlPacket,
+  AppVersionControlPacket,
+  LiveUpdatesToggles,
+  AppLogsPacket,
+  AppStatePacket,
+  LiveUpdatesToggleMessage,
   DeviceStatsMessage,
-  AppState,
   AppStateMessage,
-  ActionMessage,
-  AppLogs,
   AppLogsMessage,
-  InstallationStatusMessage,
-  InstallationStatus,
-  InstallationStatusEnum,
+  AppInstallStatusMessage,
+  AppInstallSignedUrlsRequestMessage,
+  DeviceAgentMessage,
+  ClientMessage,
 } from '@alwaysai/device-agent-schemas';
 import { getDeviceId } from '../util/get-device-id';
+import { logger } from 'alwaysai/lib/util';
+import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
 import { AgentConfigFile } from '../infrastructure/agent-config';
 
 export class DeviceAgentCloudConnection {
   private clientId = getDeviceId();
   private host = getIoTCoreEndpointUrl();
-  private publishable = false;
-  private readonly publishInterval = 10000;
-  private readonly installationStatusInterval = 5000;
-  private installationStatus: InstallationStatus;
-  private publishableTimeout: ReturnType<typeof setTimeout>;
-
-  public device = awsIot.device;
-  public agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
-  public cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
+  private appInstallStatus: AppInstallStatusPacket;
+  private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
+  private liveUpdatesAlive = {
+    [keyMirrors.agentMessageType.device_stats]: false,
+    [keyMirrors.agentMessageType.app_state]: false,
+    [keyMirrors.agentMessageType.app_logs]: false,
+  };
+  private liveUpdatesSleepIntervals = {
+    [keyMirrors.agentMessageType.device_stats]: 5000,
+    [keyMirrors.agentMessageType.app_state]: 5000,
+    [keyMirrors.agentMessageType.app_logs]: 5000,
+    [keyMirrors.agentMessageType.app_install_status]: 5000,
+  };
+  private appLogStreams = new Set<string>();
+  private readonly agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
+  private readonly cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
+  private readonly publishableTopics = {
+    deviceStats: `${this.cloudTopicPrefix}device-management`,
+    appState: `${this.cloudTopicPrefix}application-management`,
+    appLogs: `${this.cloudTopicPrefix}application-management`,
+    appInstallStatus: `${this.cloudTopicPrefix}installation-status`,
+    cloudRequest: `${this.cloudTopicPrefix}request`,
+  };
+  private readonly subsribedTopics = {
+    command: `${this.agentTopicPrefix}command`,
+    response: `${this.agentTopicPrefix}response`,
+  };
 
-  constructor() {
-    this.device = awsIot.device({
-      keyPath: getPrivateKeyFilePath(),
-      certPath: getCertificateFilePath(),
-      caPath: getRootCertificateFilePath(),
-      clientId: this.clientId,
-      host: this.host,
+  public async startAppLogStream(projectId: string) {
+    this.appLogStreams.add(projectId);
+    const readable = await getAppLogs({
+      projectId,
+      args: ['--tail', '100', '--no-log-prefix'],
+    });
+    readable.on('data', (chunk: Buffer) => {
+      if (!this.appLogStreams.has(projectId)) {
+        // why doesn't typescript know about this function?
+        // @ts-ignore
+        readable.destroy();
+        logger.info(`App log stream terminated for project ${projectId}`);
+        return;
+      }
+      const logStr = chunk.toString();
+      const message = {
+        messageType: keyMirrors.agentMessageType.app_logs,
+        appLogs: {
+          projectId,
+          logChunk: logStr,
+        },
+      };
+      const packet = this.buildMessagePacket(
+        this.getClientId(),
+        this.publishableTopics.appLogs,
+        message,
+      );
+      this.publishMessage(this.publishableTopics.appLogs, JSON.stringify(packet));
     });
 
-    this.device.subscribe(`${this.agentTopicPrefix}command`);
-    this.device.subscribe(`${this.agentTopicPrefix}response`);
-  }
-
-  public setInstallationStatus(installationStatus: InstallationStatus) {
-    this.installationStatus = installationStatus;
-  }
-
-  public getInstallationStatus(): InstallationStatus {
-    return this.installationStatus;
-  }
-
-  public getPublishable(): boolean {
-    return this.publishable;
-  }
-
-  public setPublishable(enabled: boolean) {
-    this.publishable = enabled;
-  }
+    readable.on('error', (error) => {
+      logger.error(`App log stream terminated for project ${projectId}: ${error}`);
+    });
 
-  public restartPublishableTimeout() {
-    clearTimeout(this.publishableTimeout);
-    this.publishableTimeout = setTimeout(() => {
-      this.setPublishable(false);
-    }, 600000); // 10 min
+    readable.on('finished', () => {
+      console.log(`App logs finished piping for project ${projectId}`);
+    });
   }
 
-  public getPublishInterval() {
-    return this.publishInterval;
+  // must contain app release hash
+  private initAppInstallStatus(installationStatus: AppInstallStatusPacket) {
+    this.appInstallStatus = installationStatus;
   }
 
-  public getInstallationStatusInterval() {
-    return this.installationStatusInterval;
+  private updateAppInstallStatus(
+    installationStatus: Omit<AppInstallStatusPacket, 'appReleaseHash'>,
+  ) {
+    this.appInstallStatus.status = installationStatus.status;
+    this.appInstallStatus.message = installationStatus.message;
   }
 
-  public getClientId(): string {
-    return this.clientId;
+  private getAppInstallStatus(): AppInstallStatusPacket {
+    return this.appInstallStatus;
   }
 
-  public publishMessage(topic: string, message: string) {
-    this.device.publish(topic, message);
-  }
-}
-
-export function runDeviceAgentCloudInterface() {
-  const deviceAgent = new DeviceAgentCloudConnection();
-
-  async function buildMessagePacket(
+  // Message Builders
+  private buildMessagePacket(
+    deviceId: string,
     topic: string,
-    payload:
-      | DeviceStatsMessage
-      | ActionMessage
-      | AppStateMessage
-      | AppLogsMessage
-      | InstallationStatusMessage,
-  ): Promise<DeviceAgentMessage> {
+    payload: DeviceAgentMessagePayload,
+  ): DeviceAgentMessage {
     const packet = {
       timestamp: new Date().toUTCString(),
-      deviceId: deviceAgent.getClientId(),
+      deviceId,
       topic,
       payload,
     };
     return packet;
   }
 
-  async function getAppLogsMessage(): Promise<AppLogsMessage> {
-    const appLogsList: AppLogs[] = [];
+  private async getAppStateMessage(): Promise<AppStateMessage> {
+    const appStateMessage: AppStatePacket[] = [];
     const apps = await AgentConfigFile().getReadyApps();
-    for (const app of apps) {
-      const projectId = app.projectId;
-      const readable = await getAppLogs({ projectId });
-      const logs: any[] = [];
-      readable.setEncoding('utf8');
-      for await (const chunk of readable) {
-        logs.push(chunk);
-      }
-      const appLogs = {
-        projectId,
-        logs,
-      };
-      appLogsList.push(appLogs);
-    }
-    const applicationStatePackage = {
-      applicationLogs: appLogsList,
-    };
-    return applicationStatePackage;
-  }
-
-  // * This was causing massive CPU overhead
-  // const publishAppLogs = setInterval(async function () {
-  //   const appLogsMessage = await getAppLogsMessage();
-  //   const topic = `device/${deviceAgent.getClientId()}/topic/application-management`;
-  //   const appLogsPacket = await buildMessagePacket(topic, appLogsMessage);
-
-  //   deviceAgent.publishMessage(topic, JSON.stringify({ appLogsPacket }));
-  // }, deviceAgent.getPublishInterval());
-
-  async function getAppStateMessage(): Promise<AppStateMessage> {
-    const appStateMessage: AppState[] = [];
-    const apps = await AgentConfigFile().getApps();
     for (const app of apps) {
       const projectId = app.projectId;
       const status = await getAppStatus({ projectId });
       appStateMessage.push(status);
     }
-    const applicationStatePackage = {
-      applicationState: appStateMessage,
+    const appStatePackage = {
+      messageType: keyMirrors.agentMessageType.app_state,
+      appState: appStateMessage,
     };
-    return applicationStatePackage;
+    return appStatePackage;
   }
 
-  const publishAppState = setInterval(async function () {
-    if (deviceAgent.getPublishable()) {
-      const topic = `${deviceAgent.cloudTopicPrefix}application-management`;
-      const appStateMessage = await getAppStateMessage();
-      const appStatePacket = await buildMessagePacket(topic, appStateMessage);
-      deviceAgent.publishMessage(topic, JSON.stringify({ appStatePacket }));
-    }
-  }, deviceAgent.getPublishInterval());
-
-  async function getDeviceStatsMessage(): Promise<DeviceStatsMessage> {
+  private async getDeviceStatsMessage(): Promise<DeviceStatsMessage> {
     const cpuUsage = await getCpuUtil();
     const diskUtil = await getDiskUtil();
     const memUtil = await getMemUtil();
 
     const deviceStatsMessage = {
+      messageType: keyMirrors.agentMessageType.device_stats,
       deviceStats: {
         cpuUsage,
         diskUtil,
@@ -186,124 +170,286 @@ export function runDeviceAgentCloudInterface() {
     return deviceStatsMessage;
   }
 
-  const publishDeviceStats = setInterval(async function () {
-    if (deviceAgent.getPublishable()) {
-      const topic = `${deviceAgent.cloudTopicPrefix}device-management`;
-      const deviceStatsMessage = await getDeviceStatsMessage();
-      const deviceStatsPacket = await buildMessagePacket(topic, deviceStatsMessage);
-      deviceAgent.publishMessage(topic, JSON.stringify({ deviceStatsPacket }));
-    }
-  }, deviceAgent.getPublishInterval());
-
-  const publishDeviceRequest = async ({ projectId, releaseHash }) => {
-    const topic = `${deviceAgent.cloudTopicPrefix}request`;
-    const deviceRequestPackage = {
-      timestamp: new Date().toUTCString(),
-      deviceId: deviceAgent.getClientId(),
-      projectId,
-      releaseHash,
-      topic,
+  // must be arrow function due to this context when function is passed as param
+  private getAppInstallStatusMessage = async (): Promise<AppInstallStatusMessage> => {
+    const appInstallStatus = this.getAppInstallStatus();
+    const appInstallStatusMessage = {
+      messageType: keyMirrors.agentMessageType.app_install_status,
+      appInstallStatus,
     };
-    deviceAgent.publishMessage(
-      topic,
-      JSON.stringify({ device_request: deviceRequestPackage }),
-    );
+    return appInstallStatusMessage;
   };
 
-  const publishInstallationStatus = async (interval: NodeJS.Timeout) => {
-    const topic = `${deviceAgent.cloudTopicPrefix}installation-status`;
-    const installationStatus = deviceAgent.getInstallationStatus();
-    const installationStatusPacket = await buildMessagePacket(topic, {
-      installationStatus,
-    });
-    deviceAgent.device.publish(topic, JSON.stringify({ installationStatusPacket }));
-    if (installationStatus.status !== InstallationStatusEnum.IN_PROGRESS) {
-      clearInterval(interval);
+  private async startPublishingLiveUpdates(
+    topic: string,
+    messageType: string,
+    getMessageData: () => Promise<DeviceAgentMessagePayload>,
+  ) {
+    while (true) {
+      try {
+        const message = await getMessageData();
+        const packet = this.buildMessagePacket(this.getClientId(), topic, message);
+        this.publishMessage(topic, JSON.stringify(packet));
+      } catch (e) {
+        logger.error(`Error publishing live updates for ${messageType}: ${e.message}`);
+        break;
+      }
+      if (!this.continuePublishing(messageType)) {
+        logger.info(`Turned off live updates for ${messageType}`);
+        break;
+      }
+      await sleep(this.getLiveUpdatesInterval(messageType));
     }
-  };
+  }
 
-  const handleMessageTopic = async ({ topic, payload }) => {
-    const action = payload['action'];
-    const actionPayload: any = payload[action];
-    const type = topic.split('/').slice(-1)[0];
+  private continuePublishing(flag: string): boolean {
+    switch (flag) {
+      case keyMirrors.agentMessageType.device_stats:
+      case keyMirrors.agentMessageType.app_state:
+        return this.liveUpdatesAlive[flag];
+      case keyMirrors.agentMessageType.app_install_status:
+        return this.appInstallStatus.status === keyMirrors.appInstallStatus.in_progress;
+      default:
+        logger.error(`Unrecognized publishable flag ${flag}`);
+        return false;
+    }
+  }
 
-    if (!type) {
-      return false;
+  private getLiveUpdatesInterval(flag: string): number {
+    const exists = this.liveUpdatesSleepIntervals[flag];
+    if (exists) {
+      return exists;
     }
+    logger.error(`Unrecognized live updates flag ${flag}`);
+    return -1;
+  }
 
-    switch (action) {
-      /**
-       * Install app package based on the given project ID
-       */
-      case 'install':
-        /**
-          {
-            "action": "install",
-            "install": {
-              "releaseHash": "7fb2a812f9e7aa193208dac353521965da50d755085162066c125592f1ed760b",
-              "projectId": "786e4686-a681-4cff-9e17-1e7d385c0fdb"
-            }
-          }
-         */
-        if (type === 'response') {
-          deviceAgent.setInstallationStatus({
-            status: InstallationStatusEnum.IN_PROGRESS,
-            applicationReleaseHash: actionPayload.releaseHash as string,
-          });
+  private setLiveUpdates(toggles: LiveUpdatesToggles) {
+    if (toggles.deviceStats) {
+      this.liveUpdatesAlive.device_stats = toggles.deviceStats;
+    }
+    if (toggles.appState) {
+      this.liveUpdatesAlive.app_state = toggles.appState;
+    }
+  }
 
-          const installationStatusPing = setInterval(
-            () => publishInstallationStatus(installationStatusPing),
-            deviceAgent.getInstallationStatusInterval(),
-          );
-
-          // Install the app with the given url
-          await (async () => {
-            try {
-              await installApp(actionPayload);
-              deviceAgent.setInstallationStatus({
-                status: InstallationStatusEnum.SUCCESS,
-                applicationReleaseHash: actionPayload.releaseHash as string,
-              });
-            } catch (e) {
-              const reason: string = e.message;
-              deviceAgent.setInstallationStatus({
-                status: InstallationStatusEnum.FAILURE,
-                reason,
-                applicationReleaseHash: actionPayload.releaseHash as string,
-              });
-            }
-          })();
-          break;
+  private async handleCloudResponse(message: ClientMessage) {
+    const payload = message.payload;
+    switch (payload.messageType) {
+      case keyMirrors.clientMessageType.app_install_cloud_response: {
+        const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } =
+          payload.appInstallCloudResponse;
+
+        this.initAppInstallStatus({
+          status: keyMirrors.appInstallStatus.in_progress,
+          appReleaseHash,
+        });
+
+        this.startPublishingLiveUpdates(
+          this.publishableTopics.appInstallStatus,
+          keyMirrors.agentMessageType.app_install_status,
+          this.getAppInstallStatusMessage,
+        );
+
+        // Install the app and models
+        try {
+          const signedUrlsPayload = {
+            appInstallPayload,
+            modelsInstallPayload,
+          };
+          await installApp({
+            projectId,
+            appReleaseHash,
+            signedUrlsPayload,
+          });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.success,
+          });
+        } catch (e) {
+          console.error(e);
+          const message: string = e.message;
+
+          // uninstall the failed app to put system back in good state
+          await uninstallApp({ projectId });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.failure,
+            message,
+          });
         }
-        publishDeviceRequest(actionPayload);
-        break;
-      case 'start':
-        startApp({ projectId: actionPayload.projectId });
         break;
-      case 'stop':
-        stopApp({ projectId: actionPayload.projectId });
+      }
+      default:
+        logger.error(`Invalid cloud response message type '${message}'`);
+    }
+  }
+
+  private handleClientMessage(message: ClientMessage) {
+    const payload = message.payload;
+    switch (payload.messageType) {
+      case keyMirrors.clientMessageType.app_state_control:
+        this.handleAppStateControl(payload.appStateControl);
         break;
-      case 'restart':
-        restartApp({ projectId: actionPayload.projectId });
+      case keyMirrors.clientMessageType.app_version_control:
+        this.handleAppVersionControl(payload.appVersionControl);
         break;
-      /**
-       * Allow/disallow publishing on this device. By default, (publishable = false)
-       */
-      case 'publishable':
-        /**
-          {
-            "action": "publishable",
-            "publishable": true | false
-          }
-         */
-        deviceAgent.setPublishable(actionPayload);
-        deviceAgent.restartPublishableTimeout();
+      case keyMirrors.clientMessageType.live_state_updates:
+        this.handleAgentCommand(payload);
         break;
       default:
+        logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
+    }
+  }
+
+  private handleAppStateControl(payload: AppStateControlPacket) {
+    const { baseCommand, projectId } = payload;
+    switch (baseCommand) {
+      case keyMirrors.appStateControl.start:
+        startApp({ projectId });
+        break;
+      case keyMirrors.appStateControl.stop:
+        stopApp({ projectId });
+        break;
+      case keyMirrors.appStateControl.restart:
+        restartApp({ projectId });
         break;
     }
+  }
+
+  private handleAppVersionControl(payload: AppVersionControlPacket) {
+    const { projectId, appReleaseHash } = payload;
+    const signedUrlsRequest = { projectId, appReleaseHash };
+    this.publishCloudRequest({
+      messageType: keyMirrors.agentMessageType.app_install_signed_urls_request,
+      signedUrlsRequest,
+    });
+  }
+
+  private handleDeviceCommand = async (packet: any) => {
+    // TODO
   };
 
+  private handleAgentCommand(message: LiveUpdatesToggleMessage) {
+    switch (message.messageType) {
+      case keyMirrors.clientMessageType.live_state_updates:
+        this.liveUpdatesBroker(message.liveUpdatesToggles);
+        break;
+      default:
+        logger.error(`Invalid agent action message type from message '${message}'`);
+    }
+  }
+
+  private restartLiveUpdatesTimeout() {
+    clearTimeout(this.liveUpdatesTimeout);
+    this.liveUpdatesTimeout = setTimeout(() => {
+      this.setLiveUpdates({
+        deviceStats: false,
+        appState: false,
+      });
+      this.appLogStreams.clear();
+      // TODO: Make constant, not hard coded
+    }, 600000); // 10 min
+  }
+
+  private async liveUpdatesBroker({
+    deviceStats,
+    appState,
+    appLogs,
+  }: {
+    deviceStats?: boolean;
+    appState?: boolean;
+    appLogs?: {
+      projectId: string;
+      toggle: boolean;
+    };
+  }) {
+    this.restartLiveUpdatesTimeout();
+
+    if (deviceStats !== undefined) {
+      this.liveUpdatesAlive.device_stats = deviceStats;
+      if (deviceStats) {
+        this.startPublishingLiveUpdates(
+          this.publishableTopics.deviceStats,
+          keyMirrors.agentMessageType.device_stats,
+          this.getDeviceStatsMessage,
+        );
+      }
+    }
+
+    if (appState !== undefined) {
+      this.liveUpdatesAlive.app_state = appState;
+      if (appState) {
+        this.startPublishingLiveUpdates(
+          this.publishableTopics.appState,
+          keyMirrors.agentMessageType.app_state,
+          this.getAppStateMessage,
+        );
+      }
+    }
+
+    if (appLogs !== undefined) {
+      if (appLogs.toggle) {
+        this.startAppLogStream(appLogs.projectId);
+      } else {
+        this.appLogStreams.delete(appLogs.projectId);
+      }
+    }
+  }
+
+  private async publishCloudRequest(payload: AppInstallSignedUrlsRequestMessage) {
+    const topic = this.publishableTopics.cloudRequest;
+    const deviceRequestPacket = this.buildMessagePacket(
+      this.getClientId(),
+      topic,
+      payload,
+    );
+    this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
+  }
+
+  // Public Methods
+
+  public device = awsIot.device;
+
+  constructor() {
+    this.device = awsIot.device({
+      keyPath: getPrivateKeyFilePath(),
+      certPath: getCertificateFilePath(),
+      caPath: getRootCertificateFilePath(),
+      clientId: this.clientId,
+      host: this.host,
+    });
+
+    Object.values(this.subsribedTopics).forEach((topic: string) => {
+      this.device.subscribe(topic);
+    });
+  }
+
+  public getClientId(): string {
+    return this.clientId;
+  }
+
+  public publishMessage(topic: string, message: string) {
+    // TODO: topic validation
+    this.device.publish(topic, message);
+  }
+
+  public handleMessageTopic({
+    topic,
+    message,
+  }: {
+    topic: string;
+    message: ClientMessage;
+  }) {
+    if (topic === this.subsribedTopics.response) {
+      this.handleCloudResponse(message);
+    } else {
+      this.handleClientMessage(message);
+    }
+  }
+}
+
+export function runDeviceAgentCloudInterface() {
+  const deviceAgent = new DeviceAgentCloudConnection();
+
   deviceAgent.device.on('connect', function () {
     deviceAgent.publishMessage('connection', deviceAgent.getClientId());
     console.log('Device Agent has connected to the cloud');
@@ -313,12 +459,17 @@ export function runDeviceAgentCloudInterface() {
     console.log('Device Agent has been disconnected from the cloud');
   });
 
-  deviceAgent.device.on('message', function (topic, payload) {
-    // ToDo: insert valdiation here for incoming messages.  Maybe we will use a JSON schema for the message structure.
+  deviceAgent.device.on('message', function (topic: string, payload: string) {
     try {
-      handleMessageTopic({ topic, payload: JSON.parse(payload) });
+      const jsonPacket = JSON.parse(payload);
+      const valid = validateClientMessage(jsonPacket);
+      if (!valid) {
+        logger.error(JSON.stringify(validateClientMessage.errors));
+      } else {
+        deviceAgent.handleMessageTopic({ topic, message: jsonPacket });
+      }
     } catch (error) {
-      console.error(error);
+      logger.error(error);
     }
   });
 }