@alwaysai/device-agent 0.0.13 → 0.0.15

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/bootstrap-provision.ts

@@ -1,28 +1,28 @@
-import { logger } from 'alwaysai/lib/util';
 import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
 import { rmBootstrapCertsAndClose } from '../util/clean-certs';
 import {
-  BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
-  BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
+  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
+  BOOTSTRAP_CERTIFICATE_FILE_PATH,
   AWS_ROOT_CERTIFICATE_FILE_PATH
 } from '../util/directories';
 import { getDeviceUuid } from '../util/get-device-id';
+import { logger } from '../util/logger';
 import { BootstrapAgent } from './device-agent';
 
-export function bootstrapProvision() {
+export async function bootstrapProvision() {
   setTimeout(rmBootstrapCertsAndClose, 60000);
 
   const clientId = getDeviceUuid();
   const bootstrapConfig = {
-    keyPath: BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH(),
-    certPath: BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH(),
+    keyPath: BOOTSTRAP_PRIVATE_KEY_FILE_PATH(),
+    certPath: BOOTSTRAP_CERTIFICATE_FILE_PATH(),
     caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
     clientId,
     host: getIoTCoreEndpointUrl()
   };
 
   const bootstrapAgent = new BootstrapAgent(bootstrapConfig);
-  bootstrapAgent.subscribeToAllTopics();
+  await bootstrapAgent.subscribeToAllTopics();
 
   bootstrapAgent.publishMessage('$aws/certificates/create/json', '');
 
@@ -30,9 +30,12 @@ export function bootstrapProvision() {
     logger.info('Your device is being provisioned');
   });
 
-  bootstrapAgent.device.on('message', (topic: string, payload: string) => {
-    bootstrapAgent.handleAwsCertificateTopics(topic, payload);
-  });
+  bootstrapAgent.device.on(
+    'message',
+    async (topic: string, payload: string) => {
+      await bootstrapAgent.handleAwsCertificateTopics(topic, payload);
+    }
+  );
 
   bootstrapAgent.device.on('packetsend', (packet: any) => {
     logger.debug(`Sending packet: ${JSON.stringify({ packet }, null, 2)}`);

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

@@ -0,0 +1,71 @@
+import { logger } from '../util/logger';
+
+type CmdStatusType = 'idle' | 'in_progress';
+
+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 async start(projectId: string) {
+    if (!(projectId in this.apps)) {
+      const cmdStatus = new CmdStatus(projectId, 'in_progress');
+      this.apps[projectId] = cmdStatus;
+    } else if (this.apps[projectId].getStatus() !== 'in_progress') {
+      this.apps[projectId].update('in_progress');
+    } else {
+      logger.debug(
+        `Ignoring start for ${projectId} since it already has a command in progress`
+      );
+      return;
+    }
+    logger.debug(`Started command for ${projectId}`);
+  }
+
+  public async stop(projectId: string) {
+    if (
+      !(projectId in this.apps) ||
+      this.apps[projectId].getStatus() === 'idle'
+    ) {
+      throw new Error(`No ongoing command to stop for ${projectId}`);
+    }
+    this.apps[projectId].update('idle');
+    logger.debug(`Stopped command for ${projectId}`);
+  }
+
+  public isCmdInProgress(projectId: string): boolean {
+    if (!(projectId in this.apps)) {
+      return false;
+    }
+    return this.apps[projectId].getStatus() === 'in_progress';
+  }
+
+  public anyCmdInProgress() {
+    for (const projectId in this.apps) {
+      if (this.apps[projectId].getStatus() === 'in_progress') {
+        return true;
+      }
+    }
+    return false;
+  }
+}