@alwaysai/device-agent 2.0.2-0 → 2.0.3

package/src/jobs/job-handler.ts

@@ -36,7 +36,7 @@ export class JobHandler extends BaseHandler implements MessageHandler {
   private jobId = '';
 
   public async handle(message: any, topic: string): Promise<void> {
-    const TOPICS = this.getJobTopic();
+    const TOPICS = this.getJobTopics();
 
     try {
       switch (topic) {
@@ -54,7 +54,7 @@ export class JobHandler extends BaseHandler implements MessageHandler {
     }
   }
 
-  getJobTopic() {
+  getJobTopics() {
     const TOPICS = {
       NOTIFY_NEXT: `$aws/things/${this.clientId}/jobs/notify-next`,
       START_NEXT: `$aws/things/${this.clientId}/jobs/start-next`,
@@ -67,7 +67,7 @@ export class JobHandler extends BaseHandler implements MessageHandler {
   private async notifyNext(message: any): Promise<void> {
     // Triggers when a job is completed and we need to notify the next job
     logger.info('Invoking NOTIFY_NEXT handler');
-    const TOPICS = this.getJobTopic();
+    const TOPICS = this.getJobTopics();
     this.publisher.publish(TOPICS.START_NEXT, JSON.stringify({}));
   }
 
@@ -121,7 +121,7 @@ export class JobHandler extends BaseHandler implements MessageHandler {
   }
 
   private updateJobStatus(status: string, message?: string): void {
-    const { UPDATE } = this.getJobTopic();
+    const { UPDATE } = this.getJobTopics();
     const payload = {
       status,
       statusDetails: {

package/src/local-connection/rabbitmq-container.test.ts

@@ -0,0 +1,255 @@
+import {
+  checkRabbitMQContainerRunning,
+  runRabbitMQContainer,
+  stopRabbitMQContainer
+} from './rabbitmq-container';
+
+const mockJsSpawner = {
+  exists: jest.fn(),
+  mkdirp: jest.fn(),
+  writeFile: jest.fn()
+};
+jest.mock('alwaysai/lib/util/spawner', () => {
+  return {
+    JsSpawner: jest.fn(() => mockJsSpawner)
+  };
+});
+
+jest.mock('../docker/docker-compose', () => {
+  return {
+    compose: {
+      ps: jest.fn(),
+      upAll: jest.fn(),
+      down: jest.fn()
+    }
+  };
+});
+import { compose } from '../docker/docker-compose';
+
+describe('Test check RabbitMQ container running', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose file not found', async () => {
+    mockJsSpawner.exists.mockResolvedValue(false);
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container not found', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: []
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container is not up', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container is up', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Up',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeTruthy();
+  });
+});
+
+describe('Test run RabbitMQ container', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose file write fails', async () => {
+    mockJsSpawner.exists.mockResolvedValueOnce(false);
+    mockJsSpawner.mkdirp.mockImplementation(async () => {
+      return;
+    });
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      throw new Error('Failed to write file!');
+    });
+
+    const running = await runRabbitMQContainer();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Compose up fails', async () => {
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 1,
+      out: '',
+      err: ''
+    });
+
+    const running = await runRabbitMQContainer();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container fails to come up', async () => {
+    // exists(deviceAgentConfigPath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+    // exists(deviceAgentDockerComposePath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await runRabbitMQContainer({ max_attempts: 2 });
+
+    expect(jest.mocked(compose.ps)).toBeCalledTimes(2);
+    expect(running).toBeFalsy();
+  });
+
+  test('Container comes up successfully', async () => {
+    // exists(deviceAgentConfigPath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+    // exists(deviceAgentDockerComposePath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    // Check status twice, one with container still down and next up
+    jest.mocked(compose.ps).mockResolvedValueOnce({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+    jest.mocked(compose.ps).mockResolvedValueOnce({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Up',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await runRabbitMQContainer({ max_attempts: 2 });
+
+    expect(jest.mocked(compose.ps)).toBeCalledTimes(2);
+    expect(running).toBeTruthy();
+  });
+});
+
+describe('Test stopping RabbitMQ container', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose down fails', async () => {
+    jest.mocked(compose.down).mockResolvedValue({
+      exitCode: 1,
+      out: '',
+      err: ''
+    });
+
+    const stopped = await stopRabbitMQContainer();
+
+    expect(stopped).toBeFalsy();
+  });
+
+  test('Stop succeeds', async () => {
+    jest.mocked(compose.down).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+
+    const stopped = await stopRabbitMQContainer();
+
+    expect(stopped).toBeTruthy();
+  });
+});

package/src/local-connection/rabbitmq-container.ts

@@ -0,0 +1,151 @@
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
+import * as YAML from 'yaml';
+import { compose } from '../docker/docker-compose';
+import {
+  getDeviceAgentConfigPath,
+  getDeviceAgentDockerComposePath
+} from '../util/directories';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
+import { LOCAL_CONNECTION_PORT } from './constants';
+
+const rabbitMQServiceName = 'alwaysAIRabbitMQ';
+const rabbitMQContainerName = 'alwaysAIRabbitMQContainer';
+
+/*
+Utility functions to control the Local Connection container (RabbitMQ).
+
+All exported functions handle their own errors and log their status, returning a
+boolean indicating whether the action was successful.
+*/
+
+export async function checkRabbitMQContainerRunning(): Promise<boolean> {
+  logger.debug('Checking Local Connection Container status');
+  const spawner = JsSpawner();
+  if (!(await spawner.exists(getDeviceAgentDockerComposePath()))) {
+    logger.warn('Local Connection configuration file is not present');
+    return false;
+  }
+  const containerData = await compose.ps({ cwd: getDeviceAgentConfigPath() });
+  for (const service of containerData.data.services) {
+    if (service?.name === rabbitMQContainerName) {
+      if (service.state.includes('Up')) {
+        logger.debug('Local Connection container is up.');
+        return true;
+      }
+      logger.debug(
+        `Local Connection container is not up. Status: ${service.state}`
+      );
+      return false;
+    }
+  }
+  logger.warn(
+    `Local Connection container not found in container data: ${JSON.stringify(
+      containerData,
+      null,
+      2
+    )}`
+  );
+  return false;
+}
+
+async function writeRabbitMQDockerComposeFile() {
+  const spawner = JsSpawner();
+  if (!(await spawner.exists(getDeviceAgentConfigPath()))) {
+    await JsSpawner().mkdirp(getDeviceAgentConfigPath());
+  }
+
+  logger.debug(
+    `Writing Local Connection Docker compose files with Local Connection port: ${LOCAL_CONNECTION_PORT}`
+  );
+
+  const rabbitmqDockerComposeCmd = {
+    services: {
+      [rabbitMQServiceName]: {
+        container_name: rabbitMQContainerName,
+        image: 'rabbitmq:3.11',
+        ports: [`${LOCAL_CONNECTION_PORT}:${LOCAL_CONNECTION_PORT}`],
+        hostname: 'my-rabbit',
+        restart: 'on-failure',
+        environment: [`RABBITMQ_NODE_PORT=${LOCAL_CONNECTION_PORT}`],
+        volumes: [
+          './rabbitmq/:/var/lib/rabbitmq/',
+          './rabbitmq/log/:/var/log/rabbitmq/'
+        ]
+      }
+    }
+  };
+
+  const RabbitMQDockerComposeYaml = YAML.stringify(rabbitmqDockerComposeCmd);
+  await spawner.writeFile(
+    getDeviceAgentDockerComposePath(),
+    RabbitMQDockerComposeYaml
+  );
+}
+
+export async function runRabbitMQContainer(opts?: {
+  max_attempts: number;
+}): Promise<boolean> {
+  const max_attempts = opts?.max_attempts || 10;
+  logger.debug('Starting the Local Connection container');
+  try {
+    await writeRabbitMQDockerComposeFile();
+    const upOut = await compose.upAll({
+      cwd: getDeviceAgentConfigPath()
+    });
+    logger.debug(
+      `Docker compose up for Local Connection:\n${JSON.stringify(
+        upOut,
+        null,
+        2
+      )}`
+    );
+    if (upOut.exitCode !== 0) {
+      throw new Error(
+        `Failed to start Local Connection! stdout=${upOut.out} stderr=${upOut.err}`
+      );
+    }
+    // check if the container is up
+    let attempts = 0;
+    while (!(await checkRabbitMQContainerRunning())) {
+      attempts++;
+      if (attempts >= max_attempts) {
+        throw new Error(
+          'Local Connection container failed to come up after start!'
+        );
+      }
+      await sleep(1000);
+    }
+    return true;
+  } catch (e) {
+    logger.error(
+      `Unable to start Local Connection container!\n${stringifyError(e)}`
+    );
+    return false;
+  }
+}
+
+export async function stopRabbitMQContainer(): Promise<boolean> {
+  logger.debug(`Stopping alwaysAI Local Connection container`);
+  try {
+    const downOut = await compose.down({ cwd: getDeviceAgentConfigPath() });
+    logger.debug(
+      `Local Connection docker-compose down: ${JSON.stringify(
+        downOut,
+        null,
+        2
+      )}`
+    );
+    if (downOut.exitCode !== 0) {
+      throw new Error(
+        `Failed to stop Local Connection! stdout=${downOut.out} stderr=${downOut.err}`
+      );
+    }
+    return true;
+  } catch (e) {
+    logger.error(
+      `Unable to stop Local Connection Container:\n${stringifyError(e)}`
+    );
+    return false;
+  }
+}

package/src/subcommands/app/analytics.ts

@@ -80,6 +80,7 @@ export const setAnalyticsCfgCliLeaf = CliLeaf({
         appConfig: JSON.stringify(appCfg) // Pack app config as string as dictated by schema
       }
     };
+    await deviceAgent.waitForConnection();
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
@@ -92,9 +93,7 @@ export const setAnalyticsCfgCliLeaf = CliLeaf({
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(project)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(project);
     await deviceAgent.stop();
   }
 });

package/src/subcommands/app/env-vars.ts

@@ -66,6 +66,7 @@ export const setEnvCliLeaf = CliLeaf({
         envVars: JSON.stringify(envVars)
       }
     };
+    await deviceAgent.waitForConnection();
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
@@ -78,9 +79,7 @@ export const setEnvCliLeaf = CliLeaf({
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(projectId)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(projectId);
     await deviceAgent.stop();
   }
 });
@@ -128,6 +127,7 @@ export const rmEnvCliLeaf = CliLeaf({
         envVars: JSON.stringify(newEnvs)
       }
     };
+    await deviceAgent.waitForConnection();
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
@@ -140,9 +140,7 @@ export const rmEnvCliLeaf = CliLeaf({
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(projectId)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(projectId);
     await deviceAgent.stop();
   }
 });

package/src/subcommands/app/models.ts

@@ -54,6 +54,7 @@ export const addModelCliLeaf = CliLeaf({
         appConfig: JSON.stringify(newAppCfg)
       }
     };
+    await deviceAgent.waitForConnection();
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
@@ -66,9 +67,7 @@ export const addModelCliLeaf = CliLeaf({
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(projectId)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(projectId);
     await deviceAgent.stop();
   }
 });

package/src/subcommands/app/shadow.ts

@@ -14,13 +14,12 @@ export const getShadowCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.waitForConnection();
     deviceAgent.shadowHandler.getProjectShadowUpdates();
 
     // 5 seconds should cover the response wait time
     await sleep(5000);
-    while (deviceAgent.isCmdInProgress(project)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(project);
     await deviceAgent.stop();
   }
 });
@@ -37,13 +36,12 @@ export const updateShadowCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.waitForConnection();
     await deviceAgent.shadowHandler.updateProjectShadow(project);
 
     // 5 seconds should cover the response wait time
     await sleep(5000);
-    while (deviceAgent.isCmdInProgress(project)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForCmd(project);
     await deviceAgent.stop();
   }
 });

package/src/subcommands/app/version.ts

@@ -10,6 +10,7 @@ import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-
 import { AgentConfigFile } from '../../infrastructure/agent-config';
 import sleep from '../../util/sleep';
 import { logger } from '../../util/logger';
+import { device } from 'alwaysai/lib/components';
 
 export const listAppsCliLeaf = CliLeaf({
   name: 'list',
@@ -81,10 +82,9 @@ export const installAppCliLeaf = CliLeaf({
         envVars
       }
     };
-    await deviceAgent.handleMessage(topic, message);
-    while (deviceAgent.isCmdInProgress(project)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForConnection();
+    await deviceAgent.sendCliCmd(topic, message);
+    await deviceAgent.waitForCmd(project);
     await deviceAgent.stop();
   }
 });
@@ -112,10 +112,9 @@ export const uninstallAppCliLeaf = CliLeaf({
         projectId: project
       }
     };
-    await deviceAgent.handleMessage(topic, message);
-    while (deviceAgent.isCmdInProgress(project)) {
-      await sleep(1000);
-    }
+    await deviceAgent.waitForConnection();
+    await deviceAgent.sendCliCmd(topic, message);
+    await deviceAgent.waitForCmd(project);
     await deviceAgent.stop();
   }
 });

package/src/subcommands/device/clean.ts

@@ -11,7 +11,7 @@ import { AgentConfigFile } from '../../infrastructure/agent-config';
 import {
   checkRabbitMQContainerRunning,
   stopRabbitMQContainer
-} from '../../local-connection/rabbitmq-connection';
+} from '../../local-connection/rabbitmq-container';
 import {
   APP_ROOT,
   CREDENTIALS_FILE_PATH,
@@ -20,28 +20,24 @@ import {
 } from '../../util/directories';
 import { safeRimraf } from '../../util/file';
 import { logger } from '../../util/logger';
+import { existsSync } from 'fs';
 
 export const cleanCliLeaf = CliLeaf({
   name: 'clean',
   description: 'Remove all provisioning files',
   async action(_, opts) {
     logger.info('Removing provisioning files.');
-    try {
-      if (await checkRabbitMQContainerRunning()) {
-        await stopRabbitMQContainer();
+    if (await checkRabbitMQContainerRunning()) {
+      if ((await stopRabbitMQContainer()) === false) {
+        logger.error(
+          `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
+        );
       }
-    } catch (e) {
-      logger.error(
-        `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
-      );
-      logger.debug(
-        `Error in checking / stopping RabbitMQ container!\n${stringifyError(e)}`
-      );
     }
 
     await safeRimraf(getDeviceAgentConfigPath());
 
-    logger.debug('Checking for alwaysAI applications still running');
+    logger.debug('Checking for alwaysAI applications still installed');
     const apps = await AgentConfigFile().getApps();
     const uninstallAppPromises: Promise<void>[] = [];
     for (const app of apps) {
@@ -60,13 +56,18 @@ export const cleanCliLeaf = CliLeaf({
     DeviceConfigFile().remove();
 
     await safeRimraf(CREDENTIALS_FILE_PATH);
-    const files = await readdir(APP_ROOT);
-    logger.debug(`${APP_ROOT} folder contents ${JSON.stringify(files.length)}`);
-    // This won't handle hidden files, but will remove if truly empty, which is safer
-    if (files.length === 0) {
-      logger.debug('Applications directory is empty, removing.');
-      await safeRimraf(APP_ROOT);
+
+    if (existsSync(APP_ROOT)) {
+      const files = await readdir(APP_ROOT);
+      logger.debug(
+        `${APP_ROOT} folder contents ${JSON.stringify(files.length)}`
+      );
+      // This won't handle hidden files, but will remove if truly empty, which is safer
+      if (files.length === 0) {
+        logger.debug('Applications directory is empty, removing.');
+        await safeRimraf(APP_ROOT);
+      }
+      logger.info('Device configuration cleaned');
     }
-    logger.info('Device configuration cleaned');
   }
 });

package/src/subcommands/device/index.ts

@@ -5,6 +5,7 @@ import { initCliLeaf } from './init';
 import { restartCliLeaf } from './restart';
 import { refreshCliLeaf } from './refresh';
 import { migrateCliLeaf } from './migrate';
+import { stopLocalConnectionCliLeaf } from './local-connection';
 
 export const deviceCliBranch = CliBranch({
   name: 'device',
@@ -15,6 +16,7 @@ export const deviceCliBranch = CliBranch({
     refreshCliLeaf,
     cleanCliLeaf,
     restartCliLeaf,
-    migrateCliLeaf
+    migrateCliLeaf,
+    stopLocalConnectionCliLeaf
   ]
 });

package/src/subcommands/device/local-connection.ts

@@ -0,0 +1,16 @@
+import { CliLeaf } from '@alwaysai/alwayscli';
+import { stopRabbitMQContainer } from '../../local-connection/rabbitmq-container';
+import { logger } from '../../util/logger';
+import { getDeviceAgentDockerComposePath } from '../../util/directories';
+
+export const stopLocalConnectionCliLeaf = CliLeaf({
+  name: 'stop-local-connection',
+  description: 'Stop the Device Agent local connection container',
+  async action(_, opts) {
+    if ((await stopRabbitMQContainer()) === false) {
+      logger.error(
+        `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
+      );
+    }
+  }
+});