@alwaysai/device-agent 0.0.1-2.1-beta-provision

package/src/application-control/install.ts

@@ -0,0 +1,206 @@
+import * as rimraf from 'rimraf';
+import * as fs from 'fs';
+import * as path from 'path';
+import { JsSpawner, Spawner } from 'alwaysai/lib/util';
+import { getAppDir, downloadPackageUsingPresignedUrl, buildApp } from './utils';
+import { AppDetailsPacket, ModelInstallPayload } from '@alwaysai/device-agent-schemas';
+import { BACKUP_EXT, createAppBackup } from './backup';
+import { stopApp } from './status';
+import { AgentConfigFile } from '../infrastructure/agent-config';
+import { ProjectJsonFile } from 'alwaysai/lib/core/project';
+import {
+  getTargetHardwareType,
+  AppJsonFile,
+  TargetJsonFile,
+} from 'alwaysai/lib/core/app';
+import { appCleanDockerComponent, buildDocker } from 'alwaysai/lib/components/app';
+import {
+  appInstallComponent,
+  installVenv,
+} from 'alwaysai/lib/components/app/app-install-component';
+import { DOCKERFILE, DOCKER_IMAGE_ID_INITIAL_VALUE } from 'alwaysai/lib/constants';
+import { appReleasePullComponent } from 'alwaysai/lib/components/release';
+import { runInDir } from '../util/run-in-dir';
+import { installModelsWithPresignedURLs } from './models';
+import { logger } from '../util/logger';
+
+type SignedUrlPayloadType = {
+  appInstallPayload: {
+    appSignedUrl: string;
+  };
+  modelsInstallPayload: {
+    id: string;
+    version: number;
+    modelSignedUrl: string;
+  }[];
+};
+
+export async function getInstalledApps(): Promise<AppDetailsPacket[]> {
+  const apps = await AgentConfigFile().getApps();
+  const appDetails: AppDetailsPacket[] = [];
+  for (const app of apps) {
+    const { projectId, version } = app;
+    appDetails.push({ projectId, version });
+  }
+  return appDetails;
+}
+
+export async function installApp(props: {
+  projectId: string;
+  appReleaseHash: string;
+  signedUrlsPayload?: SignedUrlPayloadType;
+}): Promise<void> {
+  const { projectId, appReleaseHash, signedUrlsPayload } = props;
+
+  const appDir = getAppDir(projectId);
+  const spawner = JsSpawner();
+  if (await AgentConfigFile().isAppPresent({ projectId })) {
+    if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+      throw new Error('Application already has installation in progress!');
+    }
+    logger.info('Application is already installed, updating');
+    await AgentConfigFile().setAppInstalling({ projectId, version: appReleaseHash });
+    await spawner.rimraf(appDir);
+  } else {
+    await AgentConfigFile().setAppInstalling({ projectId, version: appReleaseHash });
+  }
+
+  await spawner.mkdirp(appDir);
+
+  // download app package
+  const localDest = path.join(appDir, `${path.basename(appReleaseHash)}.tgz`);
+  if (!signedUrlsPayload) {
+    await runInDir(
+      appReleasePullComponent,
+      [
+        {
+          yes: true,
+          project: projectId,
+          releaseHash: appReleaseHash,
+        },
+      ],
+      appDir,
+    );
+  } else {
+    const { appSignedUrl } = signedUrlsPayload.appInstallPayload;
+    await downloadPackageUsingPresignedUrl({ localDest, presignedUrl: appSignedUrl });
+  }
+
+  // Unpack app package and remove tar file
+  await unPackApp({ spawner, localDest, appDir });
+
+  // The following changes replace the runCliCmd for 'app configure'
+  // This part replaces findOrWriteProjectJsonFile() due to the
+  // calls that check the user is logged in and also for project collaboration
+  // NOTE: this process no longer checks project collaboration
+  await checkValidProjectFiles({ appDir });
+
+  // install models, python venv, and docker image
+  if (!signedUrlsPayload) {
+    await runInDir(
+      appInstallComponent,
+      [
+        {
+          yes: true,
+          pull: true,
+          clean: true,
+          skipModels: false,
+          source: false,
+        },
+      ],
+      appDir,
+    );
+  } else {
+    await installAppBuildReqs({ appDir });
+    await installModelsWithPresignedURLs(
+      signedUrlsPayload.modelsInstallPayload,
+      path.join(appDir, 'models'),
+    );
+  }
+
+  await buildApp({ appDir });
+
+  await AgentConfigFile().setAppInstalled({ projectId, version: appReleaseHash });
+
+  logger.info(
+    `Installed app version ${appReleaseHash} from project ${projectId} to ${appDir}.`,
+  );
+}
+
+async function installAppBuildReqs(props: { appDir: string }) {
+  const { appDir } = props;
+  const targetJsonFile = TargetJsonFile(appDir);
+  const targetJson = targetJsonFile.readIfExists();
+  if (!targetJson) {
+    throw new Error('Target json file does not exist!');
+  }
+
+  await runInDir(
+    async () => {
+      const targetHostSpawner = targetJsonFile.readHostSpawner();
+
+      await appCleanDockerComponent({ targetHostSpawner });
+
+      await buildDocker({
+        targetJson,
+        targetJsonFile,
+        targetHostSpawner,
+        pull: true,
+      });
+
+      await installVenv({
+        targetJson,
+        sourceSpawner: targetHostSpawner,
+        targetJsonFile,
+      });
+    },
+    [],
+    appDir,
+  );
+}
+
+async function unPackApp(props: { spawner: Spawner; localDest: string; appDir: string }) {
+  const { spawner, localDest, appDir } = props;
+  await spawner.untar(fs.createReadStream(localDest), appDir);
+  await spawner.rimraf(localDest);
+}
+
+async function checkValidProjectFiles({ appDir }) {
+  if (!ProjectJsonFile(appDir).readIfExists()) {
+    throw new Error('Project JSON file does not exist!');
+  }
+
+  // check for app json file and app.py files
+  if (!AppJsonFile(appDir).readIfExists()) {
+    throw new Error('App JSON file does not exist!');
+  }
+
+  // write target json
+  if (!fs.existsSync(path.join(appDir, DOCKERFILE))) {
+    throw new Error('No Dockerfile found for application!');
+  }
+  TargetJsonFile(appDir).write({
+    targetProtocol: 'docker:',
+    dockerImageId: DOCKER_IMAGE_ID_INITIAL_VALUE,
+    targetHardware: await getTargetHardwareType({}),
+  });
+}
+
+export async function uninstallApp(props: { projectId: string }): Promise<void> {
+  const { projectId } = props;
+  if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
+    logger.info(`Application ${projectId} not installed`);
+    return;
+  }
+  try {
+    await stopApp({ projectId });
+  } catch {
+    logger.info('Failed to stop app, may be left running...');
+  }
+  await AgentConfigFile().setAppUninstalled({ projectId });
+  // Delete application directory and backup
+  const appDir = getAppDir(projectId);
+  rimraf.sync(appDir);
+  rimraf.sync(`${appDir}${BACKUP_EXT}`);
+  logger.info('Uninstalled', projectId);
+}

package/src/application-control/models.ts

@@ -0,0 +1,194 @@
+import { keyMirrors, ModelInstallPayload } from '@alwaysai/device-agent-schemas';
+import { app } from 'alwaysai/lib/components';
+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 { getAppStatus, restartApp } from './status';
+
+import { ModelDetails } from './types';
+import {
+  buildApp,
+  downloadPackageUsingPresignedUrl,
+  getAppDir,
+  requireAppInstalled,
+} from './utils';
+
+export async function getAppModels(props: { projectId: string }) {
+  const { projectId } = props;
+  if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
+    throw new Error('Application is not installed');
+  }
+
+  const appDir = getAppDir(projectId);
+  const appCfgPath = join(appDir, 'alwaysai.app.json');
+  if (!existsSync(appCfgPath)) {
+    throw new Error('Application config not found!');
+  }
+  const appCfg = JSON.parse(await JsSpawner().readFile(appCfgPath));
+  const modelDetails: ModelDetails[] = [];
+  if (!('models' in appCfg)) {
+    return modelDetails;
+  }
+  for (const model in appCfg['models']) {
+    modelDetails.push({ modelId: model, version: appCfg['models'][model] });
+  }
+  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 });
+
+  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 requireAppInstalled({ projectId });
+
+  const appDir = getAppDir(projectId);
+
+  await runInDir(
+    appModelsRemoveAllComponent,
+    [
+      {
+        purge: true,
+        removeFromProject: false,
+      },
+    ],
+    appDir,
+  );
+  for (const modelId of modelIds) {
+    await appModelsAddComponent({
+      yes: false,
+      dir: appDir,
+      id: modelId,
+      addToProject: false,
+    });
+  }
+  await buildApp({ appDir });
+}
+
+export async function updateModels(props: { projectId: string }) {
+  const { projectId } = props;
+  await requireAppInstalled({ projectId });
+
+  const appDir = getAppDir(projectId);
+  await appModelsUpdateComponent({
+    yes: false,
+    dir: appDir,
+  });
+  await buildApp({ appDir });
+}
+
+export async function installModelsWithPresignedURLs(
+  modelPayloads: ModelInstallPayload[],
+  targetDir: string,
+) {
+  const spawner = JsSpawner();
+  await Promise.all(
+    modelPayloads.map(async (payload: ModelInstallPayload) => {
+      const modelDest = `${targetDir}/${payload.id}`;
+      await spawner.mkdirp(modelDest);
+      const localDest = `${modelDest}/${payload.version}.tar.gz`;
+      await downloadPackageUsingPresignedUrl({
+        localDest,
+        presignedUrl: payload.modelSignedUrl,
+      });
+      await spawner.untar(createReadStream(localDest), dirname(modelDest));
+      await spawner.rimraf(localDest);
+    }),
+  );
+}
+
+export async function updateModelsWithPresignedUrls(
+  project: string,
+  modelInstallPayloads: ModelInstallPayload[],
+) {
+  // create temp dir with all untouched models
+  const spawner = JsSpawner();
+  const appDir = getAppDir(project);
+  const ogDir = `${appDir}/models`;
+  const tmpDir = `${ogDir}.tmp`;
+  const restoreDir = `${ogDir}.restore`;
+  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}`,
+        });
+      }
+    }
+
+    // install model packages
+    await installModelsWithPresignedURLs(modelInstallPayloads, tmpDir);
+    await spawner.rimraf(ogDir);
+    await copyDir({ srcPath: tmpDir, destPath: ogDir });
+    await spawner.rimraf(tmpDir);
+
+    await buildApp({ appDir: getAppDir(project) });
+
+    const appStatus = await getAppStatus({ projectId: project });
+    const appIsRunning =
+      appStatus.services.length &&
+      appStatus.services[0].state !== keyMirrors.appState.stopped;
+
+    if (appIsRunning) {
+      restartApp({ projectId: project });
+    }
+
+    logger.info(`Models installed for project ${project}`);
+  } catch (e) {
+    logger.error(e, 'Error updating app models from presigned URL, restoring models.');
+    await spawner.rimraf(tmpDir);
+    await spawner.rimraf(ogDir);
+    await copyDir({ srcPath: restoreDir, destPath: ogDir });
+  }
+}

package/src/application-control/status.ts

@@ -0,0 +1,187 @@
+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 {
+  ServiceStatusPacket,
+  AppStatePacket,
+  keyMirrors,
+  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> {
+  const { projectId } = props;
+  if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
+    throw new Error('Application is not installed');
+  }
+
+  const appDetails = {
+    projectId,
+    version: await AgentConfigFile().getAppVersion({ projectId }),
+  };
+  if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+    // App is being installed or updated
+    return { appDetails, services: [] };
+  }
+
+  const appDir = getAppDir(projectId);
+  const composeServices = await compose.configServices({ cwd: appDir });
+
+  // Check if app is running
+  const status = await compose.ps({ cwd: appDir });
+
+  if (status.exitCode !== 0) {
+    throw new Error(
+      `Failed to get application status! stdout=${status.out} stderr=${status.err}`,
+    );
+  }
+
+  const services: ServiceStatusPacket[] = [];
+  const spawner = JsSpawner({ path: appDir });
+  for (const name of composeServices.data.services) {
+    // Get container name for service
+    const containerId = await spawner.run({
+      exe: 'docker-compose',
+      cwd: appDir,
+      args: ['ps', '-q', name],
+    });
+    if (containerId === '') {
+      // The service was not yet started or failed to start
+      services.push({ name, state: keyMirrors.appState.stopped });
+    } else {
+      const slashContainerName = await spawner.run({
+        exe: 'docker',
+        args: ['inspect', '-f', '{{.Name}}', containerId],
+      });
+      const containerName = slashContainerName.substring(1);
+
+      let foundContainer = false;
+      for (const container of status.data.services) {
+        if (container.name !== containerName) {
+          continue;
+        }
+        let state: AppStateValue;
+        if (container.state.includes('Up')) {
+          state = keyMirrors.appState.up;
+        } else if (
+          container.state.includes('Stopped') ||
+          container.state.includes('Exit')
+        ) {
+          state = keyMirrors.appState.stopped;
+        } else if (container.state.includes('Restarting')) {
+          state = keyMirrors.appState.restarting;
+        } else {
+          throw new Error(`Unknown state for service! (${container.state})`);
+        }
+        services.push({ name, state });
+        foundContainer = true;
+      }
+      if (!foundContainer) {
+        throw new Error(
+          `Unable to find container for ${name} in ${JSON.stringify(
+            status.data.services,
+            null,
+            2,
+          )}`,
+        );
+      }
+    }
+  }
+  return { appDetails, services };
+}
+
+export async function getAppLogs(props: {
+  projectId: string;
+  services?: string[];
+  args?: string[];
+}): Promise<NodeJS.ReadableStream> {
+  const { projectId, services, args } = props;
+  await requireAppInstalled({ projectId });
+
+  const appDir = getAppDir(projectId);
+
+  const serviceList = services
+    ? services
+    : await (async function () {
+        const composeServices = await compose.configServices({ cwd: appDir });
+        return composeServices.data.services;
+      })();
+
+  const argsList = args ? args : [];
+
+  // Use direct command with spawner in order to get a readable stream
+  return await JsSpawner().runStreaming({
+    exe: 'docker-compose',
+    args: ['logs', '-f', ...argsList, ...serviceList],
+    cwd: appDir,
+  });
+}
+
+export async function startApp(props: {
+  projectId: string;
+  dockerLoginToken?: string;
+}): Promise<void> {
+  const { projectId, dockerLoginToken } = props;
+  await requireAppInstalled({ projectId });
+
+  const appDir = getAppDir(projectId);
+  if (dockerLoginToken !== undefined) {
+    const result = await runDockerLogin({ token: dockerLoginToken });
+    logger.info(result);
+  }
+
+  // TODO: Check if app is running
+  // Start app
+  const upOut = await compose.upAll({ cwd: appDir });
+  logger.info(upOut);
+  if (upOut.exitCode !== 0) {
+    throw new Error(
+      `Failed to start application! stdout=${upOut.out} stderr=${upOut.err}`,
+    );
+  }
+  logger.info('Started', projectId);
+}
+
+export async function stopApp(props: { projectId: string }): Promise<void> {
+  const { projectId } = props;
+  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}`,
+    );
+  }
+  logger.info('Stopped', projectId);
+}
+
+export async function restartApp(props: { projectId: string }): Promise<void> {
+  const { projectId } = props;
+  await stopApp({ projectId });
+  await startApp({ projectId });
+}

package/src/application-control/types.ts

@@ -0,0 +1 @@
+export type ModelDetails = { modelId: string; version: number };

package/src/application-control/utils.ts

@@ -0,0 +1,95 @@
+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 { 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 { 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');
+
+export function getAppDir(projectId: string): string {
+  return path.join(APP_ROOT, projectId);
+}
+
+export async function requireAppInstalled(props: { projectId: string }) {
+  const { projectId } = props;
+  // Ensure an app that is being installed or updated is not modified
+  if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
+    throw new Error('Application is not installed');
+  }
+  if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+    throw new Error('Application is not done installing or updating');
+  }
+}
+
+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:') {
+    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,
+  );
+
+  const buildOut = await compose.buildAll({ cwd: appDir });
+  logger.info(buildOut);
+  if (buildOut.exitCode !== 0) {
+    throw new Error(
+      `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`,
+    );
+  }
+}
+
+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
+    throw new Error(
+      `Status Code: ${response.status}, ${response.statusText}. Response: ${response.body}`,
+    );
+  }
+
+  /**
+   * 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);
+  });
+}
+
+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));
+}