@alwaysai/device-agent 0.0.12 → 0.0.14

package/src/application-control/models.ts

@@ -1,10 +1,10 @@
-import { keyMirrors, ModelInstallPayload } from '@alwaysai/device-agent-schemas';
-import { app } from 'alwaysai/lib/components';
+import * as path from 'path';
+import { ModelInstallPayload } from '@alwaysai/device-agent-schemas';
 import {
   appModelsAddComponent,
   appModelsRemoveAllComponent,
   appModelsRemoveComponent,
-  appModelsUpdateComponent,
+  appModelsUpdateComponent
 } from 'alwaysai/lib/components/app';
 import { JsSpawner } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
@@ -13,15 +13,19 @@ import { join, dirname } from 'path';
 import { AgentConfigFile } from '../infrastructure/agent-config';
 import { copyDir } from '../util/copy-dir';
 import { runInDir } from '../util/run-in-dir';
-import { getAppStatus, restartApp } from './status';
+import { restartApp } from './status';
 
 import { ModelDetails } from './types';
 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, writeAppCfgFile } from './config';
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 export async function getAppModels(props: { projectId: string }) {
   const { projectId } = props;
@@ -45,23 +49,12 @@ export async function getAppModels(props: { projectId: string }) {
   return modelDetails;
 }
 
-export async function addModel(props: { projectId: string; modelId: string }) {
+export async function removeModel(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);
 
@@ -71,16 +64,19 @@ export async function removeModel(props: { projectId: string; modelId: string })
       {
         id: modelId,
         purge: true,
-        removeFromProject: false,
-      },
+        removeFromProject: false
+      }
     ],
-    appDir,
+    appDir
   );
 }
 
-export async function replaceModels(props: { projectId: string; modelIds: string[] }) {
+export async function replaceModels(props: {
+  projectId: string;
+  modelIds: string[];
+}) {
   const { projectId, modelIds } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
 
@@ -89,17 +85,17 @@ export async function replaceModels(props: { projectId: string; modelIds: string
     [
       {
         purge: true,
-        removeFromProject: false,
-      },
+        removeFromProject: false
+      }
     ],
-    appDir,
+    appDir
   );
   for (const modelId of modelIds) {
     await appModelsAddComponent({
       yes: false,
       dir: appDir,
       id: modelId,
-      addToProject: false,
+      addToProject: false
     });
   }
   await buildApp({ appDir });
@@ -107,88 +103,124 @@ export async function replaceModels(props: { projectId: string; modelIds: string
 
 export async function updateModels(props: { projectId: string }) {
   const { projectId } = props;
-  await requireAppInstalled({ projectId });
+  await requireAppReady({ projectId });
 
   const appDir = getAppDir(projectId);
   await appModelsUpdateComponent({
     yes: false,
-    dir: appDir,
+    dir: appDir
   });
   await buildApp({ appDir });
 }
 
 export async function installModelsWithPresignedURLs(
   modelPayloads: ModelInstallPayload[],
-  targetDir: string,
+  targetDir: string
 ) {
   const spawner = JsSpawner();
+  await spawner.mkdirp(targetDir);
   await Promise.all(
     modelPayloads.map(async (payload: ModelInstallPayload) => {
+      logger.info(`Installing ${payload.id}: ${payload.version}`);
+      const version = payload.version;
       const modelDest = `${targetDir}/${payload.id}`;
       await spawner.mkdirp(modelDest);
       const localDest = `${modelDest}/${payload.version}.tar.gz`;
       await downloadPackageUsingPresignedUrl({
         localDest,
-        presignedUrl: payload.modelSignedUrl,
+        presignedUrl: payload.modelSignedUrl
       });
       await spawner.untar(createReadStream(localDest), dirname(modelDest));
+      await updateModelJson(modelDest, (modelJson) => ({
+        ...modelJson,
+        version
+      }));
       await spawner.rimraf(localDest);
-    }),
+    })
   );
+
+  async function readModelJson(dir: string) {
+    const filePath = spawner.resolvePath(dir, MODEL_JSON_FILE_NAME);
+    const output = await spawner.readFile(filePath);
+    const parsed = JSON.parse(output);
+    return parsed;
+  }
+
+  async function updateModelJson(dir: string, updater: (current: any) => any) {
+    const parsed = await readModelJson(dir);
+    const updated = updater(parsed);
+    const filePath = spawner.resolvePath(dir, MODEL_JSON_FILE_NAME);
+    const serialized = JSON.stringify(updated, null, 2);
+    await spawner.writeFile(filePath, serialized);
+  }
 }
 
-export async function updateModelsWithPresignedUrls(
-  project: string,
-  modelInstallPayloads: ModelInstallPayload[],
-) {
-  // create temp dir with all untouched models
+export async function updateModelsWithPresignedUrls(props: {
+  projectId: string;
+  modelInstallPayloads: ModelInstallPayload[];
+  appReleaseHash: string;
+  newAppCfg: AppConfig;
+}) {
+  const { projectId, modelInstallPayloads, appReleaseHash, newAppCfg } = props;
+  logger.info(`Installing models for ${projectId}`);
   const spawner = JsSpawner();
-  const appDir = getAppDir(project);
-  const ogDir = `${appDir}/models`;
-  const tmpDir = `${ogDir}.tmp`;
+  const appDir = getAppDir(projectId);
+
+  if (await AgentConfigFile().isAppPresent({ projectId })) {
+    if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+      throw new Error('Application already has installation in progress!');
+    }
+    logger.info('Updating installed application');
+    await AgentConfigFile().setAppInstalling({
+      projectId,
+      version: appReleaseHash
+    });
+  } else {
+    throw new Error('Application is not installed!');
+  }
+  const ogAppCfg = await readAppCfgFile({ projectId });
+
+  const ogDir = path.join(appDir, APP_MODELS_DIRECTORY_NAME);
+  // Copy all current models to restore dir in case of failure
   const restoreDir = `${ogDir}.restore`;
+  await spawner.rimraf(restoreDir);
   await copyDir({ srcPath: ogDir, destPath: restoreDir });
-  await spawner.rimraf(tmpDir);
 
-  try {
-    // Move unchanged models
-    const existingModels = await getAppModels({ projectId: project });
-    for (const model of existingModels) {
-      if (
-        !modelInstallPayloads
-          .map((newModel: ModelInstallPayload) => newModel.id)
-          .includes(model.modelId)
-      ) {
-        // model does not need to be updated
-        await copyDir({
-          srcPath: `${ogDir}/${model.modelId}`,
-          destPath: `${tmpDir}/${model.modelId}`,
-        });
-      }
-    }
+  // Create temp dir to install new models
+  const tmpDir = `${ogDir}.tmp`;
 
-    // install model packages
+  try {
+    await spawner.rimraf(tmpDir);
+    await copyDir({ srcPath: ogDir, destPath: tmpDir });
     await installModelsWithPresignedURLs(modelInstallPayloads, tmpDir);
+    // TODO: Purge outdated models
     await spawner.rimraf(ogDir);
     await copyDir({ srcPath: tmpDir, destPath: ogDir });
     await spawner.rimraf(tmpDir);
 
-    await buildApp({ appDir: getAppDir(project) });
+    await writeAppCfgFile({ projectId, appCfg: newAppCfg });
+    await buildApp({ appDir });
 
-    const appStatus = await getAppStatus({ projectId: project });
-    const appIsRunning =
-      appStatus.services.length &&
-      appStatus.services[0].state !== keyMirrors.appState.stopped;
+    await AgentConfigFile().setAppInstalled({
+      projectId,
+      version: appReleaseHash
+    });
 
-    if (appIsRunning) {
-      restartApp({ projectId: project });
-    }
+    await restartApp({ projectId });
 
-    logger.info(`Models installed for project ${project}`);
+    logger.info(`Models installed for project ${projectId}`);
+    /* Leave error handling to higher level so errors are sent to cloud
   } catch (e) {
-    logger.error(e, 'Error updating app models from presigned URL, restoring models.');
-    await spawner.rimraf(tmpDir);
+    logger.error(
+      'Error updating app models from presigned URL, restoring models.',
+      e
+    );
     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,33 +1,17 @@
 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,
   keyMirrors,
-  AppStateValue,
+  AppStateValue
 } from '@alwaysai/device-agent-schemas';
 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> {
@@ -38,7 +22,7 @@ export async function getAppStatus(props: {
 
   const appDetails = {
     projectId,
-    version: await AgentConfigFile().getAppVersion({ projectId }),
+    version: await AgentConfigFile().getAppVersion({ projectId })
   };
   if (!(await AgentConfigFile().isAppReady({ projectId }))) {
     // App is being installed or updated
@@ -53,7 +37,7 @@ export async function getAppStatus(props: {
 
   if (status.exitCode !== 0) {
     throw new Error(
-      `Failed to get application status! stdout=${status.out} stderr=${status.err}`,
+      `Failed to get application status! stdout=${status.out} stderr=${status.err}`
     );
   }
 
@@ -64,7 +48,7 @@ export async function getAppStatus(props: {
     const containerId = await spawner.run({
       exe: 'docker-compose',
       cwd: appDir,
-      args: ['ps', '-q', name],
+      args: ['ps', '-q', name]
     });
     if (containerId === '') {
       // The service was not yet started or failed to start
@@ -72,7 +56,7 @@ export async function getAppStatus(props: {
     } else {
       const slashContainerName = await spawner.run({
         exe: 'docker',
-        args: ['inspect', '-f', '{{.Name}}', containerId],
+        args: ['inspect', '-f', '{{.Name}}', containerId]
       });
       const containerName = slashContainerName.substring(1);
 
@@ -102,8 +86,8 @@ export async function getAppStatus(props: {
           `Unable to find container for ${name} in ${JSON.stringify(
             status.data.services,
             null,
-            2,
-          )}`,
+            2
+          )}`
         );
       }
     }
@@ -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);
 
@@ -134,7 +118,7 @@ export async function getAppLogs(props: {
   return await JsSpawner().runStreaming({
     exe: 'docker-compose',
     args: ['logs', '-f', ...argsList, ...serviceList],
-    cwd: appDir,
+    cwd: appDir
   });
 }
 
@@ -143,24 +127,24 @@ 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) {
     const result = await runDockerLogin({ token: dockerLoginToken });
-    logger.info(result);
+    logger.debug(`docker login: ${result}`);
   }
 
   // TODO: Check if app is running
   // Start app
   const upOut = await compose.upAll({ cwd: appDir });
-  logger.info(upOut);
+  logger.debug(`docker-compose up: ${JSON.stringify(upOut, null, 2)}`);
   if (upOut.exitCode !== 0) {
     throw new Error(
-      `Failed to start application! stdout=${upOut.out} stderr=${upOut.err}`,
+      `Failed to start application! stdout=${upOut.out} stderr=${upOut.err}`
     );
   }
-  logger.info('Started', projectId);
+  logger.info(`Started ${projectId}`);
 }
 
 export async function stopApp(props: { projectId: string }): Promise<void> {
@@ -168,16 +152,21 @@ export async function stopApp(props: { projectId: string }): Promise<void> {
   await requireAppInstalled({ projectId });
 
   const appDir = getAppDir(projectId);
-  // TODO: Check if app is running
-  // Stop app
-  const output = await compose.down({ cwd: appDir });
-  logger.info(output);
-  if (output.exitCode !== 0) {
-    throw new Error(
-      `Failed to stop application! stdout=${output.out} stderr=${output.err}`,
-    );
+  const appStatus = await getAppStatus({ projectId });
+  const appIsRunning =
+    appStatus.services.length &&
+    appStatus.services[0].state !== keyMirrors.appState.stopped;
+  if (appIsRunning) {
+    // Stop app
+    const output = await compose.down({ cwd: appDir });
+    logger.debug(`docker-compose down: ${JSON.stringify(output, null, 2)}`);
+    if (output.exitCode !== 0) {
+      throw new Error(
+        `Failed to stop application! stdout=${output.out} stderr=${output.err}`
+      );
+    }
+    logger.info(`Stopped ${projectId}`);
   }
-  logger.info('Stopped', projectId);
 }
 
 export async function restartApp(props: { projectId: string }): Promise<void> {

package/src/application-control/utils.ts

@@ -1,17 +1,24 @@
 import compose from 'docker-compose';
 import * as path from 'path';
 import * as fs from 'fs';
-import { AAI_DIR, 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 { JsSpawner } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
-
-export const APP_ROOT = path.join(AAI_DIR, 'applications');
+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);
@@ -23,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');
   }
@@ -32,46 +44,71 @@ 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,
-      },
-    ],
-    appDir,
+    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
   );
 
   const buildOut = await compose.buildAll({ cwd: appDir });
-  logger.info(buildOut);
+  logger.debug(`docker-compose build: ${JSON.stringify(buildOut, null, 2)}`);
   if (buildOut.exitCode !== 0) {
     throw new Error(
-      `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`,
+      `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`
     );
   }
 }
 
+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> {
-  logger.info('downloading URL');
   const { localDest, presignedUrl } = props;
-  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}`
     );
   }
 
@@ -84,12 +121,3 @@ export async function downloadPackageUsingPresignedUrl(props: {
     stream.on('error', reject);
   });
 }
-
-export async function getAppConfig(project: string) {
-  const appCfgPath = path.join(getAppDir(project), 'alwaysai.app.json');
-  if (!fs.existsSync(appCfgPath)) {
-    throw new Error(`Application config not found for project ${project}`);
-  }
-
-  return JSON.parse(await JsSpawner().readFile(appCfgPath));
-}

package/src/cloud-connection/app-install-status.ts

@@ -0,0 +1,62 @@
+import { AppInstallStatusPacket } from '@alwaysai/device-agent-schemas';
+import { AppInstallStatusValue } from '@alwaysai/device-agent-schemas/lib/constants';
+
+export class AppInstallStatus {
+  private appReleaseHash: string;
+  private status: AppInstallStatusValue;
+  private message?: string;
+
+  constructor(appReleaseHash, status, message?) {
+    this.appReleaseHash = appReleaseHash;
+    this.status = status;
+    this.message = message;
+  }
+
+  public getAppReleaseHash() {
+    return this.appReleaseHash;
+  }
+
+  public update(status, message?) {
+    this.status = status;
+    this.message = message;
+  }
+
+  public getStatusPacket(): AppInstallStatusPacket {
+    return {
+      status: this.status,
+      message: this.message,
+      appReleaseHash: this.appReleaseHash
+    };
+  }
+}
+
+export class AppInstallStatusManager {
+  private appList: AppInstallStatus[] = [];
+
+  public update(appReleaseHash, status, message?) {
+    // Update status if existing
+    // TODO: Reimplement this as a map
+    for (const app of this.appList) {
+      if (app.getAppReleaseHash() === appReleaseHash) {
+        app.update(status, message);
+        return;
+      }
+    }
+    // App was not found, so add to list
+    const appInstallStatus = new AppInstallStatus(
+      appReleaseHash,
+      status,
+      message
+    );
+    this.appList.push(appInstallStatus);
+  }
+
+  public getStatusPacket(appReleaseHash) {
+    for (const app of this.appList) {
+      if (app.getAppReleaseHash() === appReleaseHash) {
+        return app.getStatusPacket();
+      }
+    }
+    throw new Error(`No status for ${appReleaseHash}`);
+  }
+}

package/src/cloud-connection/bootstrap-provision.ts

@@ -0,0 +1,40 @@
+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,
+  AWS_ROOT_CERTIFICATE_FILE_PATH
+} from '../util/directories';
+import { getDeviceUuid } from '../util/get-device-id';
+import { BootstrapAgent } from './device-agent';
+
+export function bootstrapProvision() {
+  setTimeout(rmBootstrapCertsAndClose, 60000);
+
+  const clientId = getDeviceUuid();
+  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', () => {
+    logger.info('Your device is being provisioned');
+  });
+
+  bootstrapAgent.device.on('message', (topic: string, payload: string) => {
+    bootstrapAgent.handleAwsCertificateTopics(topic, payload);
+  });
+
+  bootstrapAgent.device.on('packetsend', (packet: any) => {
+    logger.debug(`Sending packet: ${JSON.stringify({ packet }, null, 2)}`);
+  });
+}