@alwaysai/device-agent 0.0.13 → 0.0.14

package/src/application-control/models.ts

@@ -20,11 +20,11 @@ import {
   buildApp,
   downloadPackageUsingPresignedUrl,
   getAppDir,
-  requireAppInstalled
+  requireAppReady
 } from './utils';
 import { MODEL_JSON_FILE_NAME } from 'alwaysai/lib/core/model';
 import { APP_MODELS_DIRECTORY_NAME } from 'alwaysai/lib/constants';
-import { readAppCfgFile, updateAppCfgFile, writeAppCfgFile } from './config';
+import { readAppCfgFile, writeAppCfgFile } from './config';
 import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 export async function getAppModels(props: { projectId: string }) {
@@ -49,26 +49,12 @@ export async function getAppModels(props: { projectId: string }) {
   return modelDetails;
 }
 
-export async function addModel(props: { projectId: string; modelId: string }) {
-  const { projectId, modelId } = props;
-  await requireAppInstalled({ projectId });
-
-  const appDir = getAppDir(projectId);
-  await appModelsAddComponent({
-    yes: false,
-    dir: appDir,
-    id: modelId,
-    addToProject: false
-  });
-  await buildApp({ appDir });
-}
-
 export async function removeModel(props: {
   projectId: string;
   modelId: string;
 }) {
   const { projectId, modelId } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
 
@@ -90,7 +76,7 @@ export async function replaceModels(props: {
   modelIds: string[];
 }) {
   const { projectId, modelIds } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
 
@@ -117,7 +103,7 @@ export async function replaceModels(props: {
 
 export async function updateModels(props: { projectId: string }) {
   const { projectId } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
   await appModelsUpdateComponent({
@@ -223,6 +209,7 @@ export async function updateModelsWithPresignedUrls(props: {
     await restartApp({ projectId });
 
     logger.info(`Models installed for project ${projectId}`);
+    /* Leave error handling to higher level so errors are sent to cloud
   } catch (e) {
     logger.error(
       'Error updating app models from presigned URL, restoring models.',
@@ -231,6 +218,7 @@ export async function updateModelsWithPresignedUrls(props: {
     await spawner.rimraf(ogDir);
     await copyDir({ srcPath: restoreDir, destPath: ogDir });
     await writeAppCfgFile({ projectId, appCfg: ogAppCfg });
+    */
   } finally {
     await spawner.rimraf(tmpDir);
     await spawner.rimraf(restoreDir);

package/src/application-control/status.ts

@@ -1,9 +1,8 @@
 import compose from 'docker-compose';
-import { fetchAppReleaseHistory } from 'alwaysai/lib/infrastructure';
 import { JsSpawner } from 'alwaysai/lib/util';
 
 import { runDockerLogin } from '../docker/docker-cmd';
-import { getAppDir, requireAppInstalled } from './utils';
+import { getAppDir, requireAppInstalled, requireAppReady } from './utils';
 import {
   ServiceStatusPacket,
   AppStatePacket,
@@ -13,21 +12,6 @@ import {
 import { AgentConfigFile } from '../infrastructure/agent-config';
 import { logger } from '../util/logger';
 
-export async function listAppReleases(props: { projectId: string }) {
-  const { projectId } = props;
-  const releaseHistory = await fetchAppReleaseHistory(projectId);
-  return releaseHistory;
-}
-
-export async function listAppLatestRelease(props: { projectId: string }) {
-  const { projectId } = props;
-  const releaseHistory = await fetchAppReleaseHistory(projectId);
-  if (releaseHistory.length >= 1) {
-    return releaseHistory[0]['releaseHash'];
-  }
-  return undefined;
-}
-
 export async function getAppStatus(props: {
   projectId: string;
 }): Promise<AppStatePacket> {
@@ -117,7 +101,7 @@ export async function getAppLogs(props: {
   args?: string[];
 }): Promise<NodeJS.ReadableStream> {
   const { projectId, services, args } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
 
@@ -143,7 +127,7 @@ export async function startApp(props: {
   dockerLoginToken?: string;
 }): Promise<void> {
   const { projectId, dockerLoginToken } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
   if (dockerLoginToken !== undefined) {

package/src/application-control/utils.ts

@@ -1,15 +1,24 @@
 import compose from 'docker-compose';
 import * as path from 'path';
 import * as fs from 'fs';
-import { TARGET_JSON_FILE_NAME } from 'alwaysai/lib/constants';
+import {
+  DOCKER_COMPOSE_FILE,
+  TARGET_JSON_FILE_NAME
+} from 'alwaysai/lib/constants';
 
 import { AgentConfigFile } from '../infrastructure/agent-config';
-import nodeFetch from 'node-fetch';
-import { TargetJsonFile } from 'alwaysai/lib/core/app';
-import { appDeployLinuxAndRemoteDevice } from 'alwaysai/lib/components/app';
+import { fetchWithTimeout } from '../util/fetch-with-timeout';
+import {
+  getDockerComposeCmdForApp,
+  TargetJsonFile,
+  updateDockerComposeTargetHw,
+  writeDockerComposeFile,
+  writeStandaloneDockerfile
+} from 'alwaysai/lib/core/app';
 import { runInDir } from '../util/run-in-dir';
 import { logger } from '../util/logger';
 import { APP_ROOT } from '../util/directories';
+import { JsSpawner } from 'alwaysai/lib/util/spawner';
 
 export function getAppDir(projectId: string): string {
   return path.join(APP_ROOT, projectId);
@@ -21,6 +30,11 @@ export async function requireAppInstalled(props: { projectId: string }) {
   if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
     throw new Error('Application is not installed');
   }
+}
+
+export async function requireAppReady(props: { projectId: string }) {
+  const { projectId } = props;
+  await requireAppInstalled({ projectId });
   if (!(await AgentConfigFile().isAppReady({ projectId }))) {
     throw new Error('Application is not done installing or updating');
   }
@@ -30,23 +44,28 @@ export async function buildApp(props: { appDir: string }) {
   const { appDir } = props;
 
   // Build standalone image and docker-compose
-  const targetJson = TargetJsonFile(appDir);
-  const targetConfig = targetJson.read();
-  if (targetConfig.targetProtocol !== 'docker:') {
+  const targetJsonFile = TargetJsonFile(appDir);
+  const targetCfg = targetJsonFile.read();
+  if (targetCfg.targetProtocol !== 'docker:') {
     throw new Error(`${TARGET_JSON_FILE_NAME} is not properly configured!`);
   }
   await runInDir(
-    appDeployLinuxAndRemoteDevice,
-    [
-      {
-        yes: true,
-        generateDockerCompose: true,
-        logs: false,
-        stop: false,
-        targetJson,
-        targetConfig
+    async () => {
+      await writeStandaloneDockerfile();
+      const spawner = JsSpawner();
+      const targetHardware = targetCfg.targetHardware;
+      if (await spawner.exists(DOCKER_COMPOSE_FILE)) {
+        await updateDockerComposeTargetHw({
+          targetHardware
+        });
+      } else {
+        await writeDockerComposeFile({
+          spawner: JsSpawner(),
+          cmd: await getDockerComposeCmdForApp({ targetHardware })
+        });
       }
-    ],
+    },
+    [],
     appDir
   );
 
@@ -59,17 +78,37 @@ export async function buildApp(props: { appDir: string }) {
   }
 }
 
+class HTTPResponseError extends Error {
+  public response;
+  constructor(response) {
+    super(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    this.response = response;
+  }
+}
+
+const checkStatus = (response) => {
+  if (response.ok) {
+    // response.status >= 200 && response.status < 300
+    return response;
+  } else {
+    throw new HTTPResponseError(response);
+  }
+};
+
 export async function downloadPackageUsingPresignedUrl(props: {
   localDest: string;
   presignedUrl: string;
 }): Promise<void> {
   const { localDest, presignedUrl } = props;
-  logger.info(`Downloading app package from ${presignedUrl}`);
-  const response = await nodeFetch(presignedUrl);
-  if (response.status !== 200) {
-    // If the URL is invalid; I think we shouldn't get here with the new changes
+  logger.debug(`Downloading package from ${presignedUrl}`);
+  let response: any;
+  try {
+    response = await fetchWithTimeout(presignedUrl);
+  } catch (error) {
+    const errorBody =
+      error.type === 'aborted' ? error : await error.response.text();
     throw new Error(
-      `Status Code: ${response.status}, ${response.statusText}. Response: ${response.body}`
+      `downloadPackageUsingPresignedUrl: Error=${error}\n${errorBody}`
     );
   }
 

package/src/cloud-connection/cmd-status.ts

@@ -0,0 +1,52 @@
+export type CmdStatusType = 'idle' | 'in_progress';
+
+export class CmdStatus {
+  private projectId: string;
+  private status: CmdStatusType;
+
+  constructor(projectId: string, status: CmdStatusType) {
+    this.projectId = projectId;
+    this.status = status;
+  }
+
+  public getProjectId() {
+    return this.projectId;
+  }
+
+  public update(status: CmdStatusType) {
+    this.status = status;
+  }
+
+  public getStatus(): CmdStatusType {
+    return this.status;
+  }
+}
+
+export class CmdStatusManager {
+  private apps: { [projectId: string]: CmdStatus } = {};
+
+  public update(projectId: string, status: CmdStatusType) {
+    if (projectId in this.apps) {
+      this.apps[projectId].update(status);
+    } else {
+      const cmdStatus = new CmdStatus(projectId, status);
+      this.apps[projectId] = cmdStatus;
+    }
+  }
+
+  public getAppCmdStatus(projectId: string) {
+    if (projectId in this.apps) {
+      return this.apps[projectId].getStatus();
+    }
+    throw new Error(`No status for ${projectId}`);
+  }
+
+  public anyCmdInProgress() {
+    for (const projectId in this.apps) {
+      if (this.apps[projectId].getStatus() === 'in_progress') {
+        return true;
+      }
+    }
+    return false;
+  }
+}

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

@@ -31,16 +31,20 @@ import {
   uninstallApp,
   updateAppCfg
 } from '../application-control';
-import { AppConfigUpdate, ShadowHandler } from './shadow-handler';
+import { AppConfigUpdate, ShadowHandler, ShadowTopics } 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';
+import { CmdStatusManager, CmdStatusType } from './cmd-status';
+import { PassthroughHandler, runChannel } from './passthrough-handler';
+import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
 
 export class DeviceAgentCloudConnection {
   private shadowHandler: ShadowHandler;
-  private publisher: Publisher;
+  public publisher: Publisher;
+  private cmdStatusMgr: CmdStatusManager;
   private liveUpdatesHandler: LiveUpdatesHandler;
   private appInstallStatusMgr: AppInstallStatusManager;
   private device = awsIot.device;
@@ -67,12 +71,26 @@ export class DeviceAgentCloudConnection {
   }
 
   private handleAppVersionControl(payload: AppVersionControlPacket) {
-    const { projectId, appReleaseHash } = payload;
-    const signedUrlsRequest = { projectId, appReleaseHash };
-    this.publishCloudRequest({
-      messageType: keyMirrors.agentMessageType.signed_urls_request,
-      signedUrlsRequest
-    });
+    switch (payload.baseCommand) {
+      case keyMirrors.appVersionControl.install: {
+        const { projectId, appReleaseHash } = payload;
+        this.cmdStatusMgr.update(projectId, 'in_progress');
+        const signedUrlsRequest = { projectId, appReleaseHash };
+        this.publishCloudRequest({
+          messageType: keyMirrors.agentMessageType.signed_urls_request,
+          signedUrlsRequest
+        });
+        break;
+      }
+      default:
+        logger.warn(
+          `Ignore App Version Control packet: ${JSON.stringify(
+            payload,
+            null,
+            2
+          )}`
+        );
+    }
   }
 
   private handleDeviceCommand = async (packet: any) => {
@@ -126,6 +144,7 @@ export class DeviceAgentCloudConnection {
       this.liveUpdatesHandler.update({
         appInstallStatus: { toggle: false, appReleaseHash }
       });
+      this.cmdStatusMgr.update(projectId, 'idle');
 
       // update app config shadow for project
       await this.shadowHandler.publishAppState(projectId);
@@ -144,16 +163,17 @@ export class DeviceAgentCloudConnection {
       this.liveUpdatesHandler.update({
         appInstallStatus: { toggle: false, appReleaseHash }
       });
+      this.cmdStatusMgr.update(projectId, 'idle');
 
       // delete shadow for project
-      // FIXME: Why do we delete the shadow? Doesn't this delete it for all projects?
-      this.shadowHandler.deleteProjectShadow();
+      this.shadowHandler.deleteProjectShadow(projectId);
     }
   }
 
   private async handleAppConfigUpdates(appConfgUpdates: AppConfigUpdate[]) {
     for (const appConfigUpdate of appConfgUpdates) {
       const { projectId, newAppCfg, updatedModels } = appConfigUpdate;
+      this.cmdStatusMgr.update(projectId, 'in_progress');
       if (updatedModels && Object.keys(updatedModels).length) {
         // Publish request for model urls
         this.newAppCfgQueue.push(newAppCfg);
@@ -207,6 +227,7 @@ export class DeviceAgentCloudConnection {
     });
     this.publisher = new Publisher(this.device, this.clientId);
     this.shadowHandler = new ShadowHandler(this.clientId, this.publisher);
+    this.cmdStatusMgr = new CmdStatusManager();
     this.appInstallStatusMgr = new AppInstallStatusManager();
     this.liveUpdatesHandler = new LiveUpdatesHandler(
       this.publisher,
@@ -222,6 +243,18 @@ export class DeviceAgentCloudConnection {
     return this.clientId;
   }
 
+  public getToDeviceTopic() {
+    return this.toDeviceTopic;
+  }
+
+  public getShadowTopics(): ShadowTopics {
+    return this.shadowHandler.shadowTopics;
+  }
+
+  public getCmdStatus(projectId: string): CmdStatusType {
+    return this.cmdStatusMgr.getAppCmdStatus(projectId);
+  }
+
   public async handleClientMessage({
     topic,
     message
@@ -229,6 +262,17 @@ export class DeviceAgentCloudConnection {
     topic: string;
     message: ClientMessage;
   }) {
+    const valid = validateClientMessage(message);
+    if (!valid) {
+      logger.error(
+        `Error validating message: ${JSON.stringify(
+          { topic, message, errors: validateClientMessage.errors },
+          null,
+          2
+        )}`
+      );
+      return;
+    }
     const payload = message.payload;
     switch (payload.messageType) {
       case keyMirrors.clientMessageType.app_state_control: {
@@ -271,9 +315,10 @@ export class DeviceAgentCloudConnection {
 
         const newAppCfg = this.newAppCfgQueue.shift();
         if (newAppCfg === undefined) {
-          throw new Error(
+          logger.error(
             'Unknown error while updating models via application config! No config present for model update.'
           );
+          return;
         }
 
         await this.atomicApplicationUpdate(
@@ -303,11 +348,32 @@ export class DeviceAgentCloudConnection {
     }
   }
 
+  public async handleMessage(topic: string, message: ClientMessage | any) {
+    switch (topic) {
+      case this.shadowHandler.shadowTopics.projects.getAccepted:
+      case this.shadowHandler.shadowTopics.projects.updateDelta: {
+        const appConfigUpdates = await this.shadowHandler.handleShadowTopic({
+          topic,
+          payload: message.state
+        });
+        await this.handleAppConfigUpdates(appConfigUpdates);
+        break;
+      }
+      case this.toDeviceTopic:
+        this.handleClientMessage({
+          topic,
+          message
+        });
+        break;
+      default:
+        logger.error(`Unexpected topic, ignoring! ${topic}`);
+    }
+  }
+
   public async setupHandlers() {
     this.device.on('connect', (connack: any) => {
       logger.info('Device Agent has connected to the cloud');
 
-      // Get shadow updates
       this.shadowHandler.getShadowUpdates();
     });
 
@@ -321,47 +387,18 @@ export class DeviceAgentCloudConnection {
       );
     });
 
+    this.device.on('error', function (error) {
+      const errorString = error.message.toString();
+      logger.error(`${errorString}`);
+    });
+
     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)}`
         );
-
-        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;
-          }
-
-          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
-            });
-          }
-        }
+        await this.handleMessage(topic, jsonPacket);
       } catch (error) {
         logger.error(`Error parsing message: ${error}`);
       }
@@ -371,6 +408,10 @@ export class DeviceAgentCloudConnection {
       logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
     });
   }
+
+  public stop() {
+    this.device.end();
+  }
 }
 
 export async function runDeviceAgentCloudInterface() {
@@ -378,6 +419,12 @@ export async function runDeviceAgentCloudInterface() {
   if (existsSync(getCertificateFilePath())) {
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
+    if (ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
+      const publisher = deviceAgent.publisher;
+      const passthroughHandler = new PassthroughHandler(publisher);
+      await passthroughHandler.setup();
+      runChannel(passthroughHandler);
+    }
   } else if (existsSync(BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH())) {
     bootstrapProvision();
   } else if (existsSync(BOOTSTRAP_CERTIFICATES_DIR_PATH())) {

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
+    });
+  }
+}
+
+async 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