@alwaysai/device-agent 1.5.0 → 2.0.1

package/src/application-control/environment-variables.ts

@@ -4,17 +4,13 @@ import { buildApp, getAppDir, requireAppReady } from './utils';
 import { logger } from '../util/logger';
 import { AgentConfigFile } from '../infrastructure/agent-config';
 import { isAppStarted, restartApp } from './status';
-import { replaceFalseyWithNull } from '../util/parsing';
+import { EnvVars } from '@alwaysai/device-agent-schemas';
 
-export interface EnvVars {
-  [service: string]: {
-    [name: string]: string | null;
-  };
-}
-
-export async function setEnv(props: { projectId: string; envVars: EnvVars }) {
+export async function setEnv(props: {
+  projectId: string;
+  envVars: EnvVars;
+}): Promise<void> {
   const { projectId, envVars } = props;
-  await requireAppReady({ projectId });
   const appReleaseHash = await AgentConfigFile().getAppVersion({
     projectId
   });
@@ -22,52 +18,7 @@ export async function setEnv(props: { projectId: string; envVars: EnvVars }) {
     projectId,
     version: appReleaseHash
   });
-
-  const composeParsed = await readDockerCompose({ projectId });
-  if (!('services' in composeParsed)) {
-    throw new Error(`Docker compose file for ${projectId} has no services!`);
-  }
-  const services: string[] = Object.keys(envVars);
-  for (const s of services) {
-    if (!Object.keys(composeParsed['services']).includes(s)) {
-      throw new Error(
-        `Service ${s} not found in ${JSON.stringify(
-          composeParsed['services'],
-          null,
-          2
-        )}`
-      );
-    }
-
-    const service = composeParsed['services'][s];
-    const oldEnv: string[] | undefined = service['environment'];
-    const envVarsForService = envVars[s];
-
-    const newEnvVarsObj = {};
-    oldEnv?.forEach((envVarStr: string) => {
-      const envVarSplit = envVarStr.split('=');
-      const key = envVarSplit[0];
-      const value = envVarSplit[1];
-      if (envVarsForService[key] !== null) {
-        newEnvVarsObj[key] = value;
-      }
-    });
-
-    for (const envVar of Object.keys(envVarsForService)) {
-      if (envVarsForService[envVar] !== null) {
-        newEnvVarsObj[envVar] = envVarsForService[envVar];
-      }
-    }
-
-    const envVarList: string[] = [];
-    for (const envVar of Object.keys(newEnvVarsObj)) {
-      envVarList.push(`${envVar}=${newEnvVarsObj[envVar]}`);
-    }
-
-    service['environment'] = envVarList;
-  }
-
-  await writeDockerCompose({ projectId, dockerCompose: composeParsed });
+  await setEnvInternal({ projectId, envVars });
 
   const appDir = getAppDir(projectId);
   await buildApp({ appDir });
@@ -89,6 +40,42 @@ export async function setEnv(props: { projectId: string; envVars: EnvVars }) {
   );
 }
 
+export async function setEnvInternal(props: {
+  projectId: string;
+  envVars: EnvVars;
+}): Promise<void> {
+  const { projectId, envVars } = props;
+
+  const composeParsed = await readDockerCompose({ projectId });
+  if (!('services' in composeParsed)) {
+    throw new Error(`Docker compose file for ${projectId} has no services!`);
+  }
+  const services: string[] = Object.keys(envVars);
+  const composeServices = composeParsed['services'];
+
+  services.forEach((s) => {
+    if (!Object.keys(composeServices).includes(s)) {
+      throw new Error(
+        `Service ${s} not found in ${JSON.stringify(composeServices, null, 2)}`
+      );
+    }
+
+    const service = composeServices[s];
+    const envVarsForService = envVars[s];
+
+    const envVarList: string[] = Object.keys(envVarsForService).map(
+      (envVar) => {
+        const value = envVarsForService[envVar];
+        return `${envVar}=${value}`;
+      }
+    );
+
+    service['environment'] = envVarList;
+  });
+
+  await writeDockerCompose({ projectId, dockerCompose: composeParsed });
+}
+
 export function convertStringEnvsToKeyVal(stringEnvs: string[]) {
   const envVars = {};
   stringEnvs.forEach((env: string) => {
@@ -138,9 +125,5 @@ export async function getAllEnvs(props: {
       }
     }
   }
-
-  // Device shadow needs null to delete
-  replaceFalseyWithNull(envVars, true);
-
   return envVars;
 }

package/src/application-control/index.ts

@@ -9,7 +9,7 @@ import {
   restartApp
 } from './status';
 import { ModelDetails } from './types';
-import { EnvVars, getAllEnvs, setEnv } from './environment-variables';
+import { getAllEnvs, setEnv } from './environment-variables';
 
 export {
   readAppCfgFile,
@@ -23,24 +23,11 @@ export {
   stopApp,
   restartApp,
   ModelDetails,
-  EnvVars,
   getAllEnvs,
   setEnv
 };
 
 // CLI-mode only
-import {
-  getAppModels,
-  removeModel,
-  replaceModels,
-  updateModels,
-  updateModelsWithPresignedUrls
-} from './models';
+import { getAppModels, updateModelsWithPresignedUrls } from './models';
 
-export {
-  getAppModels,
-  removeModel,
-  replaceModels,
-  updateModels,
-  updateModelsWithPresignedUrls
-};
+export { getAppModels, updateModelsWithPresignedUrls };

package/src/application-control/install.ts

@@ -2,9 +2,9 @@ import { rimraf } from 'rimraf';
 import * as fs from 'fs';
 import * as path from 'path';
 import { buildDockerImage } from 'alwaysai/lib/util/docker';
-import { JsSpawner, Spawner } from 'alwaysai/lib/util';
-import { getAppDir, downloadPackageUsingPresignedUrl, buildApp } from './utils';
-import { AppDetails } from '@alwaysai/device-agent-schemas';
+import { JsSpawner, Spawner, stringifyError } from 'alwaysai/lib/util';
+import { getAppDir, buildApp } from './utils';
+import { AppDetails, EnvVars } from '@alwaysai/device-agent-schemas';
 import { BACKUP_EXT } from './backup';
 import { startApp, stopApp, isAppStarted } from './status';
 import { AgentConfigFile } from '../infrastructure/agent-config';
@@ -15,20 +15,23 @@ import {
   TargetJsonFile,
   appCleanDocker,
   getPythonVenvPaths,
-  installPythonVenv,
+  createPythonVenv,
   installPythonReqs
 } from 'alwaysai/lib/core/app';
 import { DOCKER_IMAGE_ID_INITIAL_VALUE } from 'alwaysai/lib/constants';
 import { runInDir } from '../util/run-in-dir';
 import { installModelsWithPresignedURLs } from './models';
 import { logger } from '../util/logger';
-import { updateAppCfgFile } from './config';
+import { updateAppCfgFile, writeAppCfgFile } from './config';
 import {
   LOCAL_CONNECTION_HOST,
   LOCAL_CONNECTION_PORT,
   LOCAL_CONNECTION_ROUTING_KEY
 } from '../local-connection/constants';
 import { DOCKERFILE, PYTHON_REQUIREMENTS_FILE_NAME } from 'alwaysai/lib/paths';
+import { downloadToFile } from '../util/file';
+import { setEnvInternal } from './environment-variables';
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 type SignedUrlPayloadType = {
   appInstallPayload: {
@@ -55,8 +58,11 @@ export async function installApp(props: {
   projectId: string;
   appReleaseHash: string;
   signedUrlsPayload: SignedUrlPayloadType;
+  appCfg?: AppConfig;
+  envVars?: EnvVars;
 }): Promise<void> {
-  const { projectId, appReleaseHash, signedUrlsPayload } = props;
+  const { projectId, appReleaseHash, signedUrlsPayload, appCfg, envVars } =
+    props;
   logger.info(`Installing ${projectId}:${appReleaseHash}`);
 
   const appDir = getAppDir(projectId);
@@ -72,9 +78,11 @@ export async function installApp(props: {
       logger.info('Application currently running. Stopping...');
       try {
         await stopApp({ projectId });
-      } catch (error) {
+      } catch (e) {
         logger.error(
-          'Could not stop the application. Old container might still be present after installation.'
+          `Could not stop the application. Old container might still be present after installation.\n${stringifyError(
+            e
+          )}`
         );
       }
     }
@@ -96,9 +104,9 @@ export async function installApp(props: {
   // download app package
   const localDest = path.join(appDir, `${path.basename(appReleaseHash)}.tgz`);
   const { appSignedUrl } = signedUrlsPayload.appInstallPayload;
-  await downloadPackageUsingPresignedUrl({
-    localDest,
-    presignedUrl: appSignedUrl
+  await downloadToFile({
+    path: localDest,
+    url: appSignedUrl
   });
 
   // Unpack app package and remove tar file
@@ -124,6 +132,22 @@ export async function installApp(props: {
     path.join(appDir, 'models')
   );
 
+  // See if there's appCfg or envVars in the transaction, and if so, apply it
+
+  if (appCfg) {
+    logger.debug(`applying appCfg: ${JSON.stringify(appCfg)}`);
+    await writeAppCfgFile({ projectId, appCfg });
+  }
+
+  if (envVars) {
+    logger.debug(`applying envVarUpdate: ${JSON.stringify(envVars)}`);
+    try {
+      await setEnvInternal({ projectId, envVars });
+    } catch (error) {
+      logger.error(`error is : ${error}`);
+    }
+  }
+
   await installAppBuildReqs({ appDir });
   await buildApp({ appDir });
 
@@ -176,7 +200,7 @@ async function installAppBuildReqs(props: { appDir: string }) {
 
       const targetSpawner = targetJsonFile.readContainerSpawner();
       const pythonVenvPaths = await getPythonVenvPaths({ targetCfg });
-      await installPythonVenv({ targetSpawner, pythonVenvPaths, logger });
+      await createPythonVenv({ targetSpawner, pythonVenvPaths, logger });
       if (await hostSpawner.exists(PYTHON_REQUIREMENTS_FILE_NAME)) {
         await installPythonReqs({
           reqFilePath: PYTHON_REQUIREMENTS_FILE_NAME,
@@ -236,7 +260,9 @@ export async function uninstallApp(props: {
     await stopApp({ projectId });
   } catch (e) {
     logger.warn(
-      `Failed to stop ${projectId}, may be left running...\n${e.message}`
+      `Failed to stop ${projectId}, may be left running...\n${stringifyError(
+        e
+      )}`
     );
   }
   await AgentConfigFile().setAppUninstalled({ projectId });

package/src/application-control/models.ts

@@ -1,29 +1,17 @@
 import { ModelInstallPayload } from '@alwaysai/device-agent-schemas';
-import {
-  appModelsAddComponent,
-  appModelsRemoveAllComponent,
-  appModelsRemoveComponent,
-  appModelsUpdateComponent
-} from 'alwaysai/lib/components/app';
 import { JsSpawner } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
 import { existsSync, createReadStream } from 'fs';
 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 { isAppStarted, restartApp } from './status';
 import { ModelDetails } from './types';
-import {
-  buildApp,
-  downloadPackageUsingPresignedUrl,
-  getAppDir,
-  requireAppReady
-} from './utils';
+import { buildApp, getAppDir, requireAppReady } from './utils';
 import { MODEL_JSON_FILE_NAME } from 'alwaysai/lib/core/model';
 import { writeAppCfgFile } from './config';
 import { APP_MODELS_DIRECTORY_NAME } from 'alwaysai/lib/paths';
-import { pruneDir } from '../util/file';
+import { downloadToFile, pruneDir } from '../util/file';
 import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 export async function getAppModels(props: { projectId: string }) {
@@ -48,75 +36,6 @@ export async function getAppModels(props: { projectId: string }) {
   return modelDetails;
 }
 
-export async function removeModel(props: {
-  projectId: string;
-  modelId: string;
-}) {
-  const { projectId, modelId } = props;
-  await requireAppReady({ projectId });
-
-  const appDir = getAppDir(projectId);
-
-  await runInDir(
-    appModelsRemoveComponent,
-    [
-      {
-        id: modelId,
-        purge: true,
-        removeFromProject: false
-      }
-    ],
-    appDir
-  );
-}
-
-export async function replaceModels(props: {
-  projectId: string;
-  modelIds: string[];
-}) {
-  const { projectId, modelIds } = props;
-  await requireAppReady({ projectId });
-
-  const appDir = getAppDir(projectId);
-
-  await runInDir(
-    appModelsRemoveAllComponent,
-    [
-      {
-        purge: true,
-        removeFromProject: false
-      }
-    ],
-    appDir
-  );
-  const modelsAddPromises: Promise<void>[] = [];
-  for (const modelId of modelIds) {
-    modelsAddPromises.push(
-      appModelsAddComponent({
-        yes: false,
-        dir: appDir,
-        id: modelId,
-        addToProject: false
-      })
-    );
-  }
-  await Promise.all(modelsAddPromises);
-
-  await buildApp({ appDir });
-}
-
-export async function updateModels(props: { projectId: string }) {
-  const { projectId } = props;
-  await requireAppReady({ projectId });
-
-  const appDir = getAppDir(projectId);
-  await appModelsUpdateComponent({
-    yes: false,
-    dir: appDir
-  });
-  await buildApp({ appDir });
-}
-
 export async function installModelsWithPresignedURLs(
   modelPayloads: ModelInstallPayload[],
   targetDir: string
@@ -130,9 +49,9 @@ export async function installModelsWithPresignedURLs(
       const modelDest = join(targetDir, payload.id);
       await spawner.mkdirp(modelDest);
       const localDest = join(modelDest, `${payload.version}.tar.gz`);
-      await downloadPackageUsingPresignedUrl({
-        localDest,
-        presignedUrl: payload.modelSignedUrl
+      await downloadToFile({
+        path: localDest,
+        url: payload.modelSignedUrl
       });
       await spawner.untar(createReadStream(localDest), dirname(modelDest));
       await updateModelJson(modelDest, (modelJson) => ({
@@ -222,7 +141,7 @@ export async function pruneModels(props: {
 }) {
   const { projectId, appCfg, path } = props;
 
-  const modelsPath = path || join(getAppDir(projectId), 'models');
+  const modelsPath = path ?? join(getAppDir(projectId), 'models');
 
   if (!existsSync(modelsPath)) {
     logger.error(

package/src/application-control/utils.ts

@@ -1,9 +1,7 @@
 import { compose } from '../docker/docker-compose';
 import * as path from 'path';
-import * as fs from 'fs';
 
 import { AgentConfigFile } from '../infrastructure/agent-config';
-import { fetchWithTimeout } from '../util/fetch-with-timeout';
 import {
   getDockerComposeCmdForApp,
   TargetJsonFile,
@@ -76,30 +74,17 @@ export async function buildApp(props: { appDir: string }) {
       `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`
     );
   }
-}
 
-export async function downloadPackageUsingPresignedUrl(props: {
-  localDest: string;
-  presignedUrl: string;
-}): Promise<void> {
-  const { localDest, presignedUrl } = props;
-  logger.debug(`Downloading package from ${presignedUrl}`);
-  let response: any;
+  // Prune unused Docker resources after a successful build
+  logger.debug('Pruning docker system');
   try {
-    response = await fetchWithTimeout(presignedUrl);
-  } catch (e) {
-    const errorBody = e.type === 'aborted' ? e : await e.response.text();
-    throw new Error(
-      `downloadPackageUsingPresignedUrl: Error=${e}\n${errorBody}`
-    );
+    const spawner = JsSpawner();
+    const pruneOut = await spawner.run({
+      exe: 'docker',
+      args: ['system', 'prune', '-f']
+    });
+    logger.debug(pruneOut);
+  } catch (error) {
+    logger.error(`Stderr occurred when pruning docker system: ${error}`);
   }
-
-  /**
-   * Write the app package to the hash directory
-   */
-  const stream = response.body.pipe(fs.createWriteStream(localDest));
-  await new Promise((resolve, reject) => {
-    stream.on('finish', resolve);
-    stream.on('error', reject);
-  });
 }

package/src/cloud-connection/base-message-handler.ts

@@ -0,0 +1,118 @@
+import { logger, stringifyError } from 'alwaysai/lib/util';
+import { uninstallApp, rollbackApp } from '../application-control';
+import { createAppBackup } from '../application-control/backup';
+import { AgentConfigFile } from '../infrastructure/agent-config';
+import { SecureTunnelHandlerSingleton } from '../secure-tunneling/secure-tunneling';
+import AaiError from '../util/aai-error';
+import { LiveUpdatesHandler } from './live-updates-handler';
+import { Publisher } from './publisher';
+import { ShadowHandler } from './shadow-handler';
+import {
+  TransactionManager,
+  ErrorFunction,
+  SuccessFunction
+} from './transaction-manager';
+
+export interface HandlerContext {
+  clientId: string;
+  txnMgr: TransactionManager;
+  publisher: Publisher;
+  shadowHandler: ShadowHandler;
+  liveUpdatesHandler: LiveUpdatesHandler;
+  secureTunnelHandler: SecureTunnelHandlerSingleton;
+}
+
+export abstract class BaseHandler {
+  protected clientId: string;
+  protected txnMgr: TransactionManager;
+  protected publisher: Publisher;
+  protected shadowHandler: ShadowHandler;
+  protected liveUpdatesHandler: LiveUpdatesHandler;
+  protected secureTunnelHandler: SecureTunnelHandlerSingleton;
+  protected readonly errorFn?: ErrorFunction;
+  protected readonly successFn?: SuccessFunction;
+
+  constructor(
+    context: HandlerContext,
+    errorFn?: ErrorFunction,
+    successFn?: SuccessFunction
+  ) {
+    this.clientId = context.clientId;
+    this.txnMgr = context.txnMgr;
+    this.publisher = context.publisher;
+    this.shadowHandler = context.shadowHandler;
+    this.liveUpdatesHandler = context.liveUpdatesHandler;
+    this.secureTunnelHandler = context.secureTunnelHandler;
+    this.errorFn = errorFn;
+    this.successFn = successFn;
+  }
+
+  protected async atomicApplicationUninstall(projectId: string) {
+    try {
+      await uninstallApp({ projectId });
+      this.shadowHandler.clearProjectShadow(projectId);
+    } catch (e) {
+      logger.error(`Failed to uninstall ${projectId}!\n${stringifyError(e)}`);
+      throw e;
+    }
+  }
+
+  protected async atomicApplicationUpdate<F extends () => any>(
+    func: F,
+    projectId: string,
+    skipUpdateShadow?: boolean
+  ): Promise<ReturnType<F>> {
+    if (await AgentConfigFile().isAppPresent({ projectId })) {
+      // Reject the application update if app is present but not ready
+      if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+        throw new Error('Application already has installation in progress!');
+      }
+
+      // Try to create a backup, so that there is one available if something goes wrong in the next try:catch.
+      try {
+        await createAppBackup({ projectId });
+      } catch (e) {
+        logger.error(
+          `Could not create a backup for the project: ${projectId}!\n${stringifyError(
+            e
+          )}`
+        );
+      }
+    }
+
+    try {
+      const out: ReturnType<F> = await func();
+      if (!skipUpdateShadow)
+        await this.shadowHandler.updateProjectShadow(projectId);
+      return out;
+    } catch (errorAppUpdate) {
+      logger.error(
+        `Failed to update ${projectId}!\n${stringifyError(errorAppUpdate)}`
+      );
+      // If something goes wrong, first try to rollback
+      try {
+        await rollbackApp({ projectId });
+      } catch (errorRollbackApp) {
+        logger.error(
+          `Application rollback failed for ${projectId}!\n${stringifyError(
+            errorRollbackApp
+          )}`
+        );
+        // and if that fails, uninstall the app as a last resort.
+        try {
+          await this.atomicApplicationUninstall(projectId);
+        } catch {
+          // atomicApplicationUninstall logs failure, so there's nothing to do here.
+        }
+        throw new AaiError(
+          'Application update and rollback failed, uninstalled the application!',
+          { cause: errorAppUpdate }
+        );
+      }
+      throw new AaiError(
+        'Application update failed, rolled the application back!',
+        { cause: errorAppUpdate }
+      );
+    }
+  }
+}

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

@@ -1,10 +1,10 @@
+import {
+  getBootstrapCertificateFilePath,
+  getBootstrapPrivateKeyFilePath
+} from '../infrastructure/device-certificate';
 import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
 import { rmBootstrapCertsAndClose } from '../util/clean-certs';
-import {
-  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
-  BOOTSTRAP_CERTIFICATE_FILE_PATH,
-  AWS_ROOT_CERTIFICATE_FILE_PATH
-} from '../util/directories';
+import { 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';
@@ -14,8 +14,8 @@ export async function bootstrapProvision() {
 
   const clientId = getDeviceUuid();
   const bootstrapConfig = {
-    keyPath: BOOTSTRAP_PRIVATE_KEY_FILE_PATH(),
-    certPath: BOOTSTRAP_CERTIFICATE_FILE_PATH(),
+    keyPath: getBootstrapPrivateKeyFilePath(),
+    certPath: getBootstrapCertificateFilePath(),
     caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
     clientId,
     host: getIoTCoreEndpointUrl()