@alwaysai/device-agent 0.0.11 → 0.0.13

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

@@ -1,316 +1,55 @@
-const awsIot = require("aws-iot-device-sdk");
-import { getIoTCoreEndpointUrl } from "../infrastructure/urls";
-import { existsSync, createReadStream } from "fs";
+// eslint-disable-next-line
+const awsIot = require('aws-iot-device-sdk');
+import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
+import { existsSync } from 'fs';
 import {
   getPrivateKeyFilePath,
   getCertificateFilePath,
-  getRootCertificateFilePath,
-  BOOTSTRAP_CLAIM_ID_FILE_PATH,
-  DEVICE_CLAIM_ID_FILE_PATH,
-  BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
   BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
   AWS_ROOT_CERTIFICATE_FILE_PATH,
-} from "../util/directories";
-
-import { BootstrapAgent } from "./device-agent";
-
-import sleep from "../util/sleep";
-import {
-  startApp,
-  stopApp,
-  restartApp,
-  getAppLogs,
-  getAppStatus,
-} from "../application-control/status";
-import {
-  getInstalledApps,
-  installApp,
-  uninstallApp,
-} from "../application-control/install";
+  BOOTSTRAP_CERTIFICATES_DIR_PATH
+} from '../util/directories';
 import {
   keyMirrors,
   validateClientMessage,
-  DeviceAgentMessagePayload,
-  AppInstallStatusPacket,
   AppStateControlPacket,
   AppVersionControlPacket,
-  LiveUpdatesToggles,
-  AppLogsPacket,
-  AppStatePacket,
   LiveUpdatesToggleMessage,
-  DeviceStatsMessage,
-  AppStateMessage,
-  AppLogsMessage,
-  AppInstallStatusMessage,
   SignedUrlsRequestMessage,
-  DeviceAgentMessage,
   ClientMessage,
-  AppDetailsPacket,
-} from "@alwaysai/device-agent-schemas";
-import { getDeviceId } from "../util/get-device-id";
-import { JsSpawner, logger } from "alwaysai/lib/util";
-import {
-  getCpuUtil,
-  getDiskUtil,
-  getMemUtil,
-} from "../device-control/device-control";
-import { AgentConfigFile } from "../infrastructure/agent-config";
+  getDeviceTopic
+} from '@alwaysai/device-agent-schemas';
+import { getDeviceUuid } from '../util/get-device-id';
+import { logger } from '../util/logger';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 import {
-  buildApp,
-  getAppConfig,
-  getAppDir,
-} from "../application-control/utils";
-import { updateModelsWithPresignedUrls } from "../application-control/models";
-import { updateAppConfig } from "../application-control/config";
+  startApp,
+  stopApp,
+  restartApp,
+  updateModelsWithPresignedUrls,
+  installApp,
+  uninstallApp,
+  updateAppCfg
+} from '../application-control';
+import { AppConfigUpdate, ShadowHandler } from './shadow-handler';
+import { Publisher } from './publisher';
+import { LiveUpdatesHandler } from './live-updates-handler';
+import { bootstrapProvision } from './bootstrap-provision';
+import { AppInstallStatusManager } from './app-install-status';
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 export class DeviceAgentCloudConnection {
-  private clientId = getDeviceId();
-  private host = getIoTCoreEndpointUrl();
-  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 deviceType = "aai-device";
-  private readonly shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
-  private readonly shadowTopics = {
-    projects: {
-      updateDelta: `${this.shadowPrefix}projects/update/delta`,
-      getAccepted: `${this.shadowPrefix}projects/get/accepted`,
-    },
-  };
-  private readonly toCloudTopic = `to-cloud/${this.deviceType}/${this.clientId}`;
-  private readonly toClientTopic = `to-client/${this.deviceType}/${this.clientId}`;
-  private readonly toDeviceTopic = `to-device/${this.deviceType}/${this.clientId}`;
-
-  // device shadow utils
-
-  public getShadowPrefix() {
-    return this.shadowPrefix;
-  }
-
-  private async handleNamedShadowUpdate({ payload }: { payload: string }) {
-    const delta = JSON.parse(payload);
-    const deltaKeys = Object.keys(delta);
-
-    for (const projectId of deltaKeys) {
-      const projectShadow = delta[projectId];
-      if (projectShadow.appConfig) {
-        const appConfig = projectShadow.appConfig;
-        const appDir = getAppDir(projectId);
-        await updateAppConfig(projectId, appConfig);
-
-        if (appConfig.models) {
-          this.publishCloudRequest({
-            messageType: keyMirrors.agentMessageType.signed_urls_request,
-            modelsOnlyUrlsRequest: {
-              projectId,
-              models: appConfig.models,
-            },
-          });
-        }
-
-        if (appConfig.scripts && !appConfig.models) {
-          const appState = await getAppStatus({ projectId });
-
-          await buildApp({ appDir });
-
-          if (
-            appState.services.length &&
-            appState.services[0].state !== keyMirrors.appState.stopped
-          ) {
-            restartApp({ projectId });
-          }
-          await this.publishReportedState(projectId);
-        }
-      }
-    }
-  }
-
-  private 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.toClientTopic,
-        message
-      );
-      this.publishMessage(this.toClientTopic, JSON.stringify(packet));
-    });
-
-    readable.on("error", (error) => {
-      logger.error(
-        `App log stream terminated for project ${projectId}: ${error}`
-      );
-    });
-
-    readable.on("finished", () => {
-      logger.info(`App logs finished piping for project ${projectId}`);
-    });
-  }
-
-  // must contain app release hash
-  private initAppInstallStatus(installationStatus: AppInstallStatusPacket) {
-    this.appInstallStatus = installationStatus;
-  }
+  private shadowHandler: ShadowHandler;
+  private publisher: Publisher;
+  private liveUpdatesHandler: LiveUpdatesHandler;
+  private appInstallStatusMgr: AppInstallStatusManager;
+  private device = awsIot.device;
 
-  private updateAppInstallStatus(
-    installationStatus: Omit<AppInstallStatusPacket, "appReleaseHash">
-  ) {
-    this.appInstallStatus.status = installationStatus.status;
-    this.appInstallStatus.message = installationStatus.message;
-  }
-
-  private getAppInstallStatus(): AppInstallStatusPacket {
-    return this.appInstallStatus;
-  }
-
-  // Message Builders
-  private buildMessagePacket(
-    deviceId: string,
-    topic: string,
-    payload: DeviceAgentMessagePayload
-  ): DeviceAgentMessage {
-    const packet = {
-      timestamp: new Date().toUTCString(),
-      deviceId,
-      topic,
-      payload,
-    };
-    return packet;
-  }
-
-  private async getAppStateMessage(): Promise<AppStateMessage> {
-    const appStateMessage: AppStatePacket[] = [];
-    const apps = await AgentConfigFile().getReadyApps();
-    for (const app of apps) {
-      const projectId = app.projectId;
-      const status = await getAppStatus({ projectId });
-      appStateMessage.push(status);
-    }
-    const appStatePackage = {
-      messageType: keyMirrors.agentMessageType.app_state,
-      appState: appStateMessage,
-    };
-    return appStatePackage;
-  }
-
-  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,
-        usedMemoryPercentage: memUtil,
-      },
-    };
-    return deviceStatsMessage;
-  }
-
-  // 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,
-      };
-      return appInstallStatusMessage;
-    };
-
-  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));
-    }
-  }
-
-  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;
-    }
-  }
-
-  private getLiveUpdatesInterval(flag: string): number {
-    const exists = this.liveUpdatesSleepIntervals[flag];
-    if (exists) {
-      return exists;
-    }
-    logger.error(`Unrecognized live updates flag ${flag}`);
-    return -1;
-  }
-
-  private setLiveUpdates(toggles: LiveUpdatesToggles) {
-    if (toggles.deviceStats) {
-      this.liveUpdatesAlive.device_stats = toggles.deviceStats;
-    }
-    if (toggles.appState) {
-      this.liveUpdatesAlive.app_state = toggles.appState;
-    }
-  }
+  private clientId = getDeviceUuid();
+  private host = getIoTCoreEndpointUrl();
+  private readonly toDeviceTopic = getDeviceTopic(this.clientId);
+  // FIXME: Add support for multiple simultaneous project updates
+  private newAppCfgQueue: AppConfig[] = [];
 
   private handleAppStateControl(payload: AppStateControlPacket) {
     const { baseCommand, projectId } = payload;
@@ -332,7 +71,7 @@ export class DeviceAgentCloudConnection {
     const signedUrlsRequest = { projectId, appReleaseHash };
     this.publishCloudRequest({
       messageType: keyMirrors.agentMessageType.signed_urls_request,
-      signedUrlsRequest,
+      signedUrlsRequest
     });
   }
 
@@ -343,7 +82,7 @@ export class DeviceAgentCloudConnection {
   private handleAgentCommand(message: LiveUpdatesToggleMessage) {
     switch (message.messageType) {
       case keyMirrors.clientMessageType.live_state_updates:
-        this.liveUpdatesBroker(message.liveUpdatesToggles);
+        this.liveUpdatesHandler.update(message.liveUpdatesToggles);
         break;
       default:
         logger.error(
@@ -352,91 +91,110 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  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 publishCloudRequest(payload: SignedUrlsRequestMessage) {
+    this.publisher.publishToCloud(payload);
   }
 
-  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.toClientTopic,
-          keyMirrors.agentMessageType.device_stats,
-          this.getDeviceStatsMessage
-        );
-      }
-    }
+  private subscribe(topic: string) {
+    logger.info(`Subscribing to ${topic}`);
+    this.device.subscribe(topic);
+  }
 
-    if (appState !== undefined) {
-      this.liveUpdatesAlive.app_state = appState;
-      if (appState) {
-        this.startPublishingLiveUpdates(
-          this.toClientTopic,
-          keyMirrors.agentMessageType.app_state,
-          this.getAppStateMessage
-        );
-      }
-    }
+  // eslint-disable-next-line
+  private async atomicApplicationUpdate<T extends any[], R extends any>(
+    func: (...args: T) => R,
+    args: T,
+    projectId: string,
+    appReleaseHash: string
+  ) {
+    this.appInstallStatusMgr.update(
+      appReleaseHash,
+      keyMirrors.appInstallStatus.in_progress
+    );
 
-    if (appLogs !== undefined) {
-      if (appLogs.toggle) {
-        this.startAppLogStream(appLogs.projectId);
-      } else {
-        this.appLogStreams.delete(appLogs.projectId);
-      }
+    this.liveUpdatesHandler.update({
+      appInstallStatus: { toggle: true, appReleaseHash }
+    });
+
+    // Install the app and models
+    try {
+      const out: R = await func(...args);
+      this.appInstallStatusMgr.update(
+        appReleaseHash,
+        keyMirrors.appInstallStatus.success
+      );
+      this.liveUpdatesHandler.update({
+        appInstallStatus: { toggle: false, appReleaseHash }
+      });
+
+      // update app config shadow for project
+      await this.shadowHandler.publishAppState(projectId);
+      return out;
+    } catch (e) {
+      logger.error(e);
+      const message: string = e.message;
+
+      // uninstall the failed app to put system back in good state
+      await uninstallApp({ projectId });
+      this.appInstallStatusMgr.update(
+        appReleaseHash,
+        keyMirrors.appInstallStatus.failure,
+        message
+      );
+      this.liveUpdatesHandler.update({
+        appInstallStatus: { toggle: false, appReleaseHash }
+      });
+
+      // delete shadow for project
+      // FIXME: Why do we delete the shadow? Doesn't this delete it for all projects?
+      this.shadowHandler.deleteProjectShadow();
     }
   }
 
-  private async publishReportedState(projectId) {
-    const newAppCfg = await getAppConfig(projectId);
-    const packet = {
-      state: {
-        reported: {
-          [projectId]: { appConfig: newAppCfg },
-        },
-      },
-    };
-    this.publishMessage(
-      `${this.shadowPrefix}projects/update`,
-      JSON.stringify(packet)
-    );
-  }
+  private async handleAppConfigUpdates(appConfgUpdates: AppConfigUpdate[]) {
+    for (const appConfigUpdate of appConfgUpdates) {
+      const { projectId, newAppCfg, updatedModels } = appConfigUpdate;
+      if (updatedModels && Object.keys(updatedModels).length) {
+        // Publish request for model urls
+        this.newAppCfgQueue.push(newAppCfg);
+
+        logger.debug(
+          `Requesting presigned urls from cloud for model versions: ${JSON.stringify(
+            updatedModels
+          )}`
+        );
+        this.publisher.publishToCloud({
+          messageType: keyMirrors.agentMessageType.signed_urls_request,
+          modelsOnlyUrlsRequest: {
+            projectId,
+            models: updatedModels
+          }
+        });
+      } else {
+        // FIXME: do we need to send this up to the cloud?
+        // should it be something other than appReleaseHash?
+        const appReleaseHash = await AgentConfigFile().getAppVersion({
+          projectId
+        });
 
-  private async publishCloudRequest(payload: SignedUrlsRequestMessage) {
-    const topic = this.toCloudTopic;
-    const deviceRequestPacket = this.buildMessagePacket(
-      this.getClientId(),
-      topic,
-      payload
-    );
-    this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
+        await this.atomicApplicationUpdate(
+          updateAppCfg,
+          [
+            {
+              projectId,
+              appReleaseHash,
+              newAppCfg
+            }
+          ],
+          projectId,
+          appReleaseHash
+        );
+      }
+    }
   }
 
   // Public Methods
 
-  public device = awsIot.device;
-
   constructor() {
     this.device = awsIot.device({
       keyPath: getPrivateKeyFilePath(),
@@ -445,25 +203,28 @@ export class DeviceAgentCloudConnection {
       clientId: this.clientId,
       host: this.host,
       port: 8883,
+      keepalive: 1 // time before re-connect attempt on dropped connection, default is 400 seconds
     });
+    this.publisher = new Publisher(this.device, this.clientId);
+    this.shadowHandler = new ShadowHandler(this.clientId, this.publisher);
+    this.appInstallStatusMgr = new AppInstallStatusManager();
+    this.liveUpdatesHandler = new LiveUpdatesHandler(
+      this.publisher,
+      this.appInstallStatusMgr
+    );
 
-    this.device.subscribe(this.toDeviceTopic);
-    this.device.subscribe(this.shadowTopics.projects.getAccepted);
-    this.device.subscribe(this.shadowTopics.projects.updateDelta);
+    this.subscribe(this.toDeviceTopic);
+    this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
+    this.subscribe(this.shadowHandler.shadowTopics.projects.updateDelta);
   }
 
   public getClientId(): string {
     return this.clientId;
   }
 
-  public publishMessage(topic: string, message: string) {
-    // TODO: topic validation
-    this.device.publish(topic, message, (err: any) => {});
-  }
-
   public async handleClientMessage({
     topic,
-    message,
+    message
   }: {
     topic: string;
     message: ClientMessage;
@@ -487,175 +248,145 @@ export class DeviceAgentCloudConnection {
           projectId,
           appReleaseHash,
           appInstallPayload,
-          modelsInstallPayload,
+          modelsInstallPayload
         } = payload.appInstallCloudResponse;
-
-        this.initAppInstallStatus({
-          status: keyMirrors.appInstallStatus.in_progress,
-          appReleaseHash,
-        });
-
-        this.startPublishingLiveUpdates(
-          this.toClientTopic,
-          keyMirrors.agentMessageType.app_install_status,
-          this.getAppInstallStatusMessage
+        const signedUrlsPayload = {
+          appInstallPayload,
+          modelsInstallPayload
+        };
+        await this.atomicApplicationUpdate(
+          installApp,
+          [{ projectId, appReleaseHash, signedUrlsPayload }],
+          projectId,
+          appReleaseHash
         );
 
-        // Install the app and models
-        try {
-          const signedUrlsPayload = {
-            appInstallPayload,
-            modelsInstallPayload,
-          };
-          await installApp({
-            projectId,
-            appReleaseHash,
-            signedUrlsPayload,
-          });
-          this.updateAppInstallStatus({
-            status: keyMirrors.appInstallStatus.success,
-          });
-
-          // update app config shadow for project
-          await this.publishReportedState(projectId);
-        } catch (e) {
-          logger.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,
-          });
-
-          // delete shadow for project
-          this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, "");
-        }
         break;
       }
       case keyMirrors.clientMessageType.models_install_cloud_response: {
         const { projectId, newModels } = payload.modelsInstallCloudResponse;
+        const appReleaseHash = await AgentConfigFile().getAppVersion({
+          projectId
+        });
 
-        try {
-          await updateModelsWithPresignedUrls(projectId, newModels);
-
-          await this.publishReportedState(projectId);
-        } catch (e) {
-          logger.error(e);
+        const newAppCfg = this.newAppCfgQueue.shift();
+        if (newAppCfg === undefined) {
+          throw new Error(
+            'Unknown error while updating models via application config! No config present for model update.'
+          );
         }
+
+        await this.atomicApplicationUpdate(
+          updateModelsWithPresignedUrls,
+          [
+            {
+              projectId,
+              modelInstallPayloads: newModels,
+              newAppCfg,
+              appReleaseHash
+            }
+          ],
+          projectId,
+          appReleaseHash
+        );
+
         break;
       }
       default:
-        logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
+        logger.error(
+          `Invalid client message: '${JSON.stringify(
+            { topic, message },
+            null,
+            2
+          )}'`
+        );
     }
   }
 
-  public async handleShadowTopic({
-    topic,
-    payload,
-  }: {
-    topic: string;
-    payload: string;
-  }) {
-    const shadowName = topic.split("/")[5];
-    const message = JSON.parse(payload);
-    if (topic === this.shadowTopics.projects.updateDelta) {
-      this.handleNamedShadowUpdate({ payload });
-    } else if (topic === this.shadowTopics.projects.getAccepted) {
-      if (message.delta) {
-        this.handleNamedShadowUpdate({
-          payload: JSON.stringify(message.delta),
-        });
-      } else {
-        logger.info(`No delta updates in shadow ${shadowName}`);
-      }
-    }
-  }
-}
+  public async setupHandlers() {
+    this.device.on('connect', (connack: any) => {
+      logger.info('Device Agent has connected to the cloud');
 
-export async function runDeviceAgentCloudInterface() {
-  switch (existsSync(getCertificateFilePath())) {
-    case true:
-      {
-        const deviceAgent = new DeviceAgentCloudConnection();
-
-        deviceAgent.device.on("connect", function (connack: any) {
-          logger.info("Device Agent has connected to the cloud");
-
-          // Get shadow updates
-          deviceAgent.publishMessage(
-            `${deviceAgent.getShadowPrefix()}projects/get`,
-            ""
-          );
-        });
+      // Get shadow updates
+      this.shadowHandler.getShadowUpdates();
+    });
 
-        deviceAgent.device.on("disconnect", function () {
-          logger.info("Device Agent has been disconnected from the cloud");
-        });
+    this.device.on('disconnect', () => {
+      logger.warn('Device Agent has been disconnected from the cloud');
+    });
 
-        deviceAgent.device.on(
-          "message",
-          function (topic: string, payload: string) {
-            console.log(topic);
-            console.log(JSON.parse(payload));
-            try {
-              const jsonPacket = JSON.parse(payload);
-              if (jsonPacket.hasOwnProperty("state")) {
-                deviceAgent.handleShadowTopic({
-                  topic,
-                  payload: JSON.stringify(jsonPacket.state),
-                });
-              } else {
-                const valid = validateClientMessage(jsonPacket);
-                if (!valid) {
-                  console.error(JSON.stringify(validateClientMessage.errors));
-                } else {
-                  deviceAgent.handleClientMessage({
-                    topic,
-                    message: jsonPacket,
-                  });
-                }
-              }
-            } catch (error) {
-              logger.error(error);
-            }
-          }
+    this.device.on('reconnect', () => {
+      logger.info(
+        `Device Agent attempting to re-connect ${new Date().toLocaleString()}`
+      );
+    });
+
+    this.device.on('message', async (topic: string, payload: string) => {
+      try {
+        const jsonPacket = JSON.parse(payload);
+        logger.debug(
+          `Received message: ${JSON.stringify({ topic, jsonPacket }, null, 2)}`
         );
 
-        deviceAgent.device.on("packetsend", (packet: any) => {
-          //console.log({ packet: packet });
-        });
-      }
+        if (Object.prototype.hasOwnProperty.call(jsonPacket, 'state')) {
+          if (jsonPacket.clientToken === this.getClientId()) {
+            logger.debug(
+              `Ignoring message sent from self: ${JSON.stringify(
+                { topic, jsonPacket },
+                null,
+                2
+              )}`
+            );
+            return;
+          }
 
-      break;
-    case false: {
-      //set timer
-      const clientId = getDeviceId();
-      const bootstrapConfig = {
-        keyPath: BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
-        certPath: BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
-        caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
-        clientId,
-        host: getIoTCoreEndpointUrl(),
-      };
-
-      const bootstrapAgent = new BootstrapAgent(bootstrapConfig);
-      bootstrapAgent.subscribeToAllTopics();
-
-      bootstrapAgent.publishMessage("$aws/certificates/create/json", "");
-
-      bootstrapAgent.device.on("connect", () => {
-        console.log("Your device is being provisioned");
-      });
+          const appConfigUpdates = await this.shadowHandler.handleShadowTopic({
+            topic,
+            payload: jsonPacket.state
+          });
+          await this.handleAppConfigUpdates(appConfigUpdates);
+        } else {
+          const valid = validateClientMessage(jsonPacket);
+          if (!valid) {
+            logger.error(
+              `Error validating message: ${JSON.stringify(
+                validateClientMessage.errors,
+                null,
+                2
+              )}`
+            );
+          } else {
+            this.handleClientMessage({
+              topic,
+              message: jsonPacket
+            });
+          }
+        }
+      } catch (error) {
+        logger.error(`Error parsing message: ${error}`);
+      }
+    });
 
-      bootstrapAgent.device.on("message", (topic: string, payload: string) => {
-        bootstrapAgent.handleAwsCertificateTopics(topic, payload);
-      });
+    this.device.on('offline', () => {
+      logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
+    });
+  }
+}
 
-      bootstrapAgent.device.on("packetsend", (packet: any) => {
-        console.log({ packet: packet.subscriptions });
-      });
-    }
+export async function runDeviceAgentCloudInterface() {
+  // FIXME: Check for KeyPath as well
+  if (existsSync(getCertificateFilePath())) {
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+  } else if (existsSync(BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH())) {
+    bootstrapProvision();
+  } else if (existsSync(BOOTSTRAP_CERTIFICATES_DIR_PATH())) {
+    throw new Error(
+      "Device has not been created using 'aai-agent device init' or there has been an issue with device initialization"
+    );
+  } else {
+    throw new Error(
+      "Set device agent to local mode and retry the 'aai-agent device init' command"
+    );
   }
 }