@alwaysai/device-agent 0.0.4 → 0.0.5

package/src/application-control/install.ts

@@ -1,92 +1,114 @@
 import * as rimraf from 'rimraf';
 import * as fs from 'fs';
-import { join } from 'path';
+import * as path from 'path';
+import nodeFetch, { Response } from 'node-fetch';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 import { runCliCmd } from '../util/run-cli-cmd';
-import { JsSpawner } from '../util/spawner/js-spawner';
-import {
-  APP_ROOT,
-  buildApp,
-  getAppDir,
-  getAppVersion,
-  isAppInstalled,
-  setAppVersion,
-} from './utils';
-import { AppDetails } from './types';
+import { buildApp, getAppDir } from './utils';
+import { AppDetails } from '@alwaysai/device-agent-schemas';
 import { BACKUP_EXT, createAppBackup } from './backup';
 import { stopApp } from './status';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 
 export async function getInstalledApps(): Promise<AppDetails[]> {
-  if (!fs.existsSync(APP_ROOT)) {
-    return [];
-  }
-
-  const projectIds = fs.readdirSync(APP_ROOT).filter(file => {
-    const isDir = fs.statSync(`${APP_ROOT}/${file}`).isDirectory();
-    const isBak = `${APP_ROOT}/${file}`.includes(BACKUP_EXT);
-    return isDir && !isBak;
-  });
-
+  const apps = await AgentConfigFile().getApps();
   const appDetails: AppDetails[] = [];
-  for (const projectId of projectIds) {
-    const appDir = getAppDir(projectId);
-    const version = await getAppVersion({ appDir });
+  for (const app of apps) {
+    const { projectId, version } = app;
     appDetails.push({ projectId, version });
   }
   return appDetails;
 }
 
-export async function installApp(props: {
+export type InstallAppProps = {
   projectId: string;
   releaseHash: string;
-}): Promise<void> {
-  const { projectId, releaseHash } = props;
-  console.log(`Installing ${projectId}`);
+  presignedAppUrl?: string;
+};
+
+export async function installAppPackage({ localDest, presignedUrl }): Promise<void> {
+  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 installApp(props: InstallAppProps): Promise<void> {
+  const { projectId, releaseHash, presignedAppUrl } = props;
   const appDir = getAppDir(projectId);
-  const TEMP_DIR = join(APP_ROOT, 'temp');
   const spawner = JsSpawner();
-  await spawner.mkdirp(TEMP_DIR);
-  // TODO Check valid projectId
-  // Check if app is installed
-  if (await isAppInstalled({ appDir })) {
+  if (await AgentConfigFile().isAppPresent({ projectId })) {
+    if (!(await AgentConfigFile().isAppReady({ projectId }))) {
+      throw new Error('Application already has installation in progress!');
+    }
+    await AgentConfigFile().setAppInstalling({ projectId, version: releaseHash });
     console.log('Application is already installed, updating');
     await createAppBackup({ projectId });
     await spawner.rimraf(appDir);
+  } else {
+    await AgentConfigFile().setAppInstalling({ projectId, version: releaseHash });
   }
-  // Create app directory
-  await spawner.mkdirp(appDir);
 
-  // download the application
-  await runCliCmd({
-    cmd: [
-      'release',
-      'pull',
-      '--yes',
-      '--project',
-      projectId,
-      '--releaseHash',
-      releaseHash,
-    ],
-    cwd: TEMP_DIR,
-  });
+  /**
+   * Prep directory and fetch the app package
+   */
+  await spawner.mkdirp(appDir);
+  const localDest = path.join(appDir, `${path.basename(releaseHash)}.tgz`);
+  if (!presignedAppUrl) {
+    // Download the application using the CLI
+    await runCliCmd({
+      cmd: [
+        'release',
+        'pull',
+        '--yes',
+        '--project',
+        projectId,
+        '--releaseHash',
+        releaseHash,
+      ],
+      cwd: appDir,
+    });
+  } else {
+    await installAppPackage({ localDest, presignedUrl: presignedAppUrl });
+  }
 
-  // Unpack app package and move to install dir
-  await spawner.untar(fs.createReadStream(join(TEMP_DIR, `${releaseHash}.tgz`)), appDir);
+  /**
+   * Unpack app package
+   */
+  await spawner.untar(fs.createReadStream(localDest), appDir);
   console.log(`Unpacked application to ${appDir}`);
 
-  await setAppVersion({ appDir, version: releaseHash });
-
+  /**
+   * Build app
+   * ToDo: migrate the model pull to use MQTT workflow
+   */
   await buildApp({ appDir });
 
-  await spawner.rimraf(TEMP_DIR);
+  /**
+   * Remove tar file
+   */
+  await spawner.rimraf(localDest);
 
+  await AgentConfigFile().setAppInstalled({ projectId, version: releaseHash });
   console.log(`Installed ${projectId} to ${appDir}`);
 }
 
 export async function uninstallApp(props: { projectId: string }): Promise<void> {
   const { projectId } = props;
-  const appDir = getAppDir(projectId);
-  if (!(await isAppInstalled({ appDir }))) {
+  if (!(await AgentConfigFile().isAppPresent({ projectId }))) {
     console.log(`Application ${projectId} not installed`);
     return;
   }
@@ -95,7 +117,9 @@ export async function uninstallApp(props: { projectId: string }): Promise<void>
   } catch {
     console.log('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}`);
   console.log('Uninstalled', projectId);

package/src/application-control/models.ts

@@ -1,17 +1,16 @@
+import { JsSpawner } from 'alwaysai/lib/util';
 import { existsSync } from 'fs';
 import { join } from 'path';
 
 import { runCliCmd } from '../util/run-cli-cmd';
-import { JsSpawner } from '../util/spawner/js-spawner';
 import { ModelDetails } from './types';
-import { buildApp, getAppDir, isAppInstalled } from './utils';
+import { buildApp, getAppDir, requireAppInstalled } from './utils';
 
 export async function getAppModels(props: { projectId: string }) {
   const { projectId } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   const appCfgPath = join(appDir, 'alwaysai.app.json');
   if (!existsSync(appCfgPath)) {
     throw new Error('Application config not found!');
@@ -29,10 +28,9 @@ export async function getAppModels(props: { projectId: string }) {
 
 export async function addModel(props: { projectId: string; modelId: string }) {
   const { projectId, modelId } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   await runCliCmd({
     cmd: ['app', 'models', 'add', modelId],
     cwd: appDir,
@@ -42,10 +40,9 @@ 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);
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   await runCliCmd({
     cmd: ['app', 'models', 'remove', modelId, '--purge'],
     cwd: appDir,
@@ -54,10 +51,9 @@ export async function removeModel(props: { projectId: string; modelId: string })
 
 export async function replaceModels(props: { projectId: string; modelIds: string[] }) {
   const { projectId, modelIds } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   await runCliCmd({
     cmd: ['app', 'models', 'remove-all', '--purge'],
     cwd: appDir,
@@ -73,10 +69,9 @@ export async function replaceModels(props: { projectId: string; modelIds: string
 
 export async function updateModels(props: { projectId: string }) {
   const { projectId } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   await runCliCmd({
     cmd: ['app', 'models', 'update'],
     cwd: appDir,

package/src/application-control/status.ts

@@ -1,10 +1,11 @@
 import compose from 'docker-compose';
-import { fetchAppReleaseHistory } from 'alwaysai';
+import { fetchAppReleaseHistory } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 import { runDockerLogin } from '../docker/docker-cmd';
-import { JsSpawner } from '../util/spawner/js-spawner';
-import { getAppDir, getAppVersion, isAppInstalled } from './utils';
-import { AppStatus, ServiceState, ServiceStatus } from './types';
+import { getAppDir, requireAppInstalled } from './utils';
+import { AppStateValue, ServiceStatus, AppState } from '@alwaysai/device-agent-schemas';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 
 export async function listAppReleases(props: { projectId: string }) {
   const { projectId } = props;
@@ -21,14 +22,23 @@ export async function listAppLatestRelease(props: { projectId: string }) {
   return undefined;
 }
 
-export async function getAppStatus(props: { projectId: string }): Promise<AppStatus> {
+export async function getAppStatus(props: { projectId: string }): Promise<AppState> {
   const { projectId } = props;
-  const appDir = getAppDir(projectId);
-
-  if (!(await isAppInstalled({ appDir }))) {
+  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);
+
   // Check if app is running
   const output = await compose.ps({ cwd: appDir });
 
@@ -38,7 +48,6 @@ export async function getAppStatus(props: { projectId: string }): Promise<AppSta
     );
   }
 
-  const appDetails = { projectId, version: await getAppVersion({ appDir }) };
   const services: ServiceStatus[] = [];
   if (output.data.services.length === 0) {
     // If the app has never been started (or has an empty docker-compose.yaml)
@@ -54,7 +63,7 @@ export async function getAppStatus(props: { projectId: string }): Promise<AppSta
         .replace(/\d+$/, '')
         .replace(/_/g, '');
 
-      let state: ServiceState;
+      let state: AppStateValue;
       if (service.state.includes('Up')) {
         state = 'Up';
       } else if (service.state.includes('Stopped') || service.state.includes('Exit')) {
@@ -75,15 +84,13 @@ export async function getAppLogs(props: {
   services?: string[];
 }): Promise<NodeJS.ReadableStream> {
   const { projectId, services } = props;
-  const appDir = getAppDir(projectId);
+  await requireAppInstalled({ projectId });
 
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
+  const appDir = getAppDir(projectId);
 
   const serviceList = services
     ? services
-    : await (async function() {
+    : await (async function () {
         const appStatus = await getAppStatus({ projectId });
         const services: string[] = [];
         for (const service of appStatus.services) {
@@ -105,11 +112,9 @@ export async function startApp(props: {
   dockerLoginToken?: string;
 }): Promise<void> {
   const { projectId, dockerLoginToken } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  // Check if app is installed
-  if (!(await isAppInstalled({ appDir }))) {
-    throw new Error('Application is not installed');
-  }
   if (dockerLoginToken !== undefined) {
     const result = await runDockerLogin({ token: dockerLoginToken });
     console.log(result);
@@ -129,12 +134,9 @@ export async function startApp(props: {
 
 export async function stopApp(props: { projectId: string }): Promise<void> {
   const { projectId } = props;
+  await requireAppInstalled({ projectId });
+
   const appDir = getAppDir(projectId);
-  // Check if app is installed
-  if (!(await isAppInstalled({ appDir }))) {
-    console.log('Application is not installed');
-    return;
-  }
   // TODO: Check if app is running
   // Stop app
   const output = await compose.down({ cwd: appDir });

package/src/application-control/types.ts

@@ -1,5 +1 @@
-export type AppDetails = { projectId: string; version: string };
-export type ServiceState = 'Stopped' | 'Up' | 'Restarting';
-export type ServiceStatus = { name: string; state: ServiceState };
-export type AppStatus = { appDetails: AppDetails; services: ServiceStatus[] };
 export type ModelDetails = { modelId: string; version: number };

package/src/application-control/utils.ts

@@ -1,41 +1,27 @@
 import compose from 'docker-compose';
 import * as path from 'path';
 import * as fs from 'fs';
+import { AAI_DIR } from 'alwaysai/lib/constants';
 
-import { JsSpawner } from '../util/spawner/js-spawner';
-import { AAI_DIR } from 'alwaysai';
 import { runCliCmd } from '../util/run-cli-cmd';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 
 export const APP_ROOT = path.join(AAI_DIR, 'applications');
-const RELEASE_FILENAME = 'alwaysai.release.json';
 const DOCKER_COMPOSE_FILENAME = 'docker-compose.yaml';
 
 export function getAppDir(projectId: string): string {
   return path.join(APP_ROOT, projectId);
 }
 
-export async function isAppInstalled(props: { appDir: string }): Promise<boolean> {
-  const { appDir } = props;
-  // TODO: Could do more sophisticated check
-  if (fs.existsSync(appDir)) {
-    return true;
+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');
   }
-  return false;
-}
-
-export async function setAppVersion(props: { appDir: string; version: string }) {
-  const { appDir, version } = props;
-  // TODO: Switch to node-config
-  const versionPath = path.join(appDir, RELEASE_FILENAME);
-  const versionData = { version };
-  await JsSpawner().writeFile(versionPath, JSON.stringify(versionData, null, 2));
-}
-
-export async function getAppVersion(props: { appDir: string }) {
-  const { appDir } = props;
-  const versionPath = path.join(appDir, RELEASE_FILENAME);
-  const releaseData = JSON.parse(await JsSpawner().readFile(versionPath));
-  return releaseData.version;
 }
 
 export async function buildApp(props: { appDir: string }) {
@@ -55,7 +41,6 @@ export async function buildApp(props: { appDir: string }) {
   }
 
   const buildOut = await compose.buildAll({ cwd: appDir });
-  console.log(buildOut);
   if (buildOut.exitCode !== 0) {
     throw new Error(
       `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`,