@alwaysai/device-agent 1.4.0 → 1.5.0

package/src/cloud-connection/passthrough-handler.ts

@@ -1,11 +1,13 @@
-// eslint-disable-next-line
-const amqp = require('amqplib');
+import * as amqp from 'amqplib';
 import {
   LOCAL_CONNECTION_HOST,
   LOCAL_CONNECTION_PORT,
   LOCAL_CONNECTION_ROUTING_KEY
 } from '../local-connection/constants';
-import { setupRabbitMQContainer } from '../local-connection/rabbitmq-connection';
+import {
+  stopRabbitMQContainer,
+  setupRabbitMQContainer
+} from '../local-connection/rabbitmq-connection';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
@@ -16,21 +18,84 @@ const MAX_LOCAL_CONNECTION_ATTEMPTS = 10;
 
 export class PassthroughHandler {
   public publisher: Publisher;
-  public connection;
-  public channel;
+  public connection: amqp.Connection | undefined;
+  public channel: amqp.Channel;
   public packetQueue;
 
   constructor(publisher: Publisher) {
     this.publisher = publisher;
   }
 
-  public async setup() {
-    await setupRabbitMQContainer();
+  runChannel = async () => {
+    logger.debug('Beginning to consume packets');
+    await this.channel.consume(
+      this.packetQueue,
+      (msg) => {
+        // NOTE: this needs to be an arrow function and then the whole contents of processPublish are below
+        if (msg?.content !== undefined) {
+          const packet = JSON.parse(msg.content.toString());
+          messageQueue.push({ packet, msg });
+          while (messageQueue.length > 0) {
+            const entry = messageQueue.shift();
+            const { packet, msg } = entry;
+            try {
+              const parsedPacket = JSON.parse(packet);
+              if (parsedPacket?.['action']) {
+                switch (parsedPacket['action']) {
+                  case 'analytics':
+                    ackQueue.push(msg);
+                    // FIXME: put real topic here
+                    this.publisher.publishToCloudWithAck(
+                      packet,
+                      (errOrResp) => {
+                        while (ackQueue.length > 0) {
+                          const msg = ackQueue.shift();
+                          if (errOrResp === true) {
+                            this.channel.ack(msg); // acknowledge, allow queue to discard
+                          } else if (errOrResp === false) {
+                            this.channel.reject(msg, true); // reject and requeue
+                          }
+                        }
+                      }
+                    );
+                    break;
+                  case 'heartbeat':
+                    this.channel.ack(msg);
+                    logger.silly(
+                      `Heartbeat package received & acknowledged: ${packet}`
+                    );
+                    break;
+                  default:
+                    this.channel.ack(msg);
+                    logger.debug(
+                      `Unknown 'action' package received & acknowledged: ${packet}`
+                    );
+                    break;
+                }
+              } else {
+                this.channel.ack(msg);
+                logger.debug(
+                  `Received & acknowledged a RabbitMQ Package of unknown structure: ${parsedPacket}`
+                );
+              }
+            } catch (e) {
+              logger.error(`There was a problem parsing RabbitMQ packet ${e}`);
+              this.channel.ack(msg);
+              logger.debug(`Problematic packet was acknowledged`);
+            }
+          }
+        }
+      },
+      {
+        noAck: false // When true, RabbitMQ deletes message as soon as it is consumed
+      }
+    );
+  };
+
+  async establishLocalConnection(): Promise<void> {
     let connectAttempts = 0;
     let connected = false;
-    logger.debug(
-      `Setting up alwaysAI Local Connection on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
-    );
+    logger.debug(`Establishing local connection...`);
     while (
       connectAttempts <= MAX_LOCAL_CONNECTION_ATTEMPTS &&
       this.connection === undefined
@@ -40,6 +105,13 @@ export class PassthroughHandler {
           `amqp://${LOCAL_CONNECTION_HOST}:${LOCAL_CONNECTION_PORT}`
         );
         this.channel = await this.connection.createChannel();
+        this.connection.on('error', async () => {
+          logger.error(`Local connection failed. Attempting to reconnect...`);
+          await stopRabbitMQContainer();
+          this.connection = undefined;
+          await this.setup();
+        });
+
         connected = true;
       } catch (e) {
         const timeTillNextAttemptMs = 1000 + 1000 * connectAttempts;
@@ -53,84 +125,34 @@ export class PassthroughHandler {
       }
     }
     if (connected === true) {
-      this.channel.prefetch(1); // This ensures we only get one packet at a time! This appears to have prevented throttling
+      await this.channel.prefetch(1); // This ensures we only get one packet at a time! This appears to have prevented throttling
       this.packetQueue = `${LOCAL_CONNECTION_ROUTING_KEY}`;
       await this.channel.assertQueue(this.packetQueue, {
         durable: true
       });
+      logger.info(`Local connection established.`);
     } else {
       throw new Error(
         'Unable to establish connection to alwaysAI Local Connection, please try restarting Device Agent.'
       );
     }
   }
-}
 
-function processPublish(passthroughHandler: PassthroughHandler) {
-  while (messageQueue.length > 0) {
-    const entry = messageQueue.shift();
-    const { packet, msg } = entry;
+  public async setup() {
+    logger.debug(
+      `Setting up alwaysAI Local Connection on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
+    );
+    await setupRabbitMQContainer();
     try {
-      const parsedPacket = JSON.parse(packet);
-      if (parsedPacket && parsedPacket['action']) {
-        switch (parsedPacket['action']) {
-          case 'analytics':
-            ackQueue.push(msg);
-            // FIXME: put real topic here
-            passthroughHandler.publisher.publishToCloudWithAck(
-              packet,
-              (errOrResp) => {
-                while (ackQueue.length > 0) {
-                  const msg = ackQueue.shift();
-                  if (errOrResp === true) {
-                    passthroughHandler.channel.ack(msg); // acknowledge, allow queue to discard
-                  } else if (errOrResp === false) {
-                    passthroughHandler.channel.reject(msg, true); // reject and requeue
-                  }
-                }
-              }
-            );
-            break;
-          case 'heartbeat':
-            passthroughHandler.channel.ack(msg);
-            logger.debug(
-              `Heartbeat package received & acknowledged: ${packet}`
-            );
-            break;
-          default:
-            passthroughHandler.channel.ack(msg);
-            logger.debug(
-              `Unknown 'action' package received & acknowledged: ${packet}`
-            );
-            break;
-        }
-      } else {
-        passthroughHandler.channel.ack(msg);
-        logger.debug(
-          `Received & acknowledged a RabbitMQ Package of unknown structure: ${parsedPacket}`
-        );
-      }
-    } catch (e) {
-      logger.error(`There was a problem parsing RabbitMQ packet ${e}`);
-      passthroughHandler.channel.ack(msg);
-      logger.debug(`Problematic packet was acknowledged`);
+      await this.establishLocalConnection();
+      await this.runChannel();
+    } catch (error) {
+      logger.error(
+        `There was a problem maintaining RabbitMQ connection: ${error}`
+      );
+      throw new Error(
+        `There was a problem maintaining RabbitMQ connection: ${error}`
+      );
     }
   }
 }
-
-export async function runChannel(passthroughHandler: PassthroughHandler) {
-  logger.debug('Beginning to consume packets');
-  passthroughHandler.channel.consume(
-    passthroughHandler.packetQueue,
-    function (msg) {
-      if (msg.content !== undefined) {
-        const packet = JSON.parse(msg.content.toString());
-        messageQueue.push({ packet, msg });
-        processPublish(passthroughHandler);
-      }
-    },
-    {
-      noAck: false // When true, RabbitMQ deletes message as soon as it is consumed
-    }
-  );
-}

package/src/cloud-connection/shadow-handler.ts

@@ -21,8 +21,9 @@ import {
   getShadowTopic,
   ShadowProjectsUpdateAll,
   getDesiredFromMessage,
-  ShadowTopics,
-  ProjectShadowUpdate
+  ProjectShadowUpdate,
+  buildUpdateSecureTunnelShadowMessage,
+  SecureTunnelShadowDescriptionReported
 } from '@alwaysai/device-agent-schemas';
 
 export type AppConfigUpdate = {
@@ -107,9 +108,7 @@ export class ShadowHandler {
     txId: string;
     projectId: string;
   }): Promise<AppConfigUpdate | null> {
-    let appCfgUpdate: any;
     let newAppCfg: any;
-
     // Handle errors and validation
     try {
       newAppCfg = JSON.parse(appConfig);
@@ -139,10 +138,9 @@ export class ShadowHandler {
       projectId
     });
 
+    const appCfgUpdate: AppConfigUpdate = { newAppCfg };
     if (updatedModels && Object.keys(updatedModels).length) {
-      appCfgUpdate = { newAppCfg, updatedModels };
-    } else {
-      appCfgUpdate = { newAppCfg };
+      appCfgUpdate.updatedModels = updatedModels;
     }
     return appCfgUpdate;
   }
@@ -362,6 +360,20 @@ export class ShadowHandler {
     );
   }
 
+  public async updateSecureTunnelShadow(
+    secureTunnelShadowUpdate: SecureTunnelShadowDescriptionReported
+  ) {
+    this.publisher.publish(
+      getShadowTopic(this.clientId, 'secure-tunnel', 'update'),
+      JSON.stringify(
+        buildUpdateSecureTunnelShadowMessage(
+          secureTunnelShadowUpdate,
+          this.clientId
+        )
+      )
+    );
+  }
+
   public getProjectShadowUpdates() {
     this.publisher.publish(
       getShadowTopic(this.clientId, 'projects', 'get'),

package/src/cloud-connection/transaction-manager.test.ts

@@ -7,6 +7,7 @@ import { TransactionManager } from './transaction-manager';
 import { v4 as uuidv4 } from 'uuid';
 import { Publisher } from './publisher';
 import { LiveUpdatesHandler } from './live-updates-handler';
+import { AppConfigUpdate, ShadowUpdate } from './shadow-handler';
 
 const mockClient = {
   publish: jest.fn()
@@ -245,4 +246,127 @@ describe('Test Transaction Manager', () => {
 
     expect(txnMgr.getProjectFromTransaction(txId)).toBeUndefined();
   });
+
+  test('add an appCfgUpdate from txDetails', async () => {
+    const txId = generateTxId();
+    const projectId = generateRandomProjectId();
+    const cfgUpdate: ShadowUpdate = { txId: txId, projectId: projectId };
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: true
+    });
+
+    expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(undefined);
+
+    txnMgr.setAppCfgUpdateToTx(txId, cfgUpdate);
+
+    expect(txnMgr.getProjectFromTransaction(txId)).toEqual(projectId);
+    expect(txnMgr.getTransactionFromProject(projectId)).toEqual(txId);
+    expect(txnMgr.isOngoingTransaction(txId)).toBe(true);
+    expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(true);
+    expect(txnMgr.isAnyOngoingTransaction()).toBe(true);
+    expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(cfgUpdate);
+  });
+
+  test('update a tx while holding appCfgUpdate', async () => {
+    const txId = generateTxId();
+    const projectId = generateRandomProjectId();
+    const cfgUpdate: ShadowUpdate = { txId: txId, projectId: projectId };
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: true
+    });
+
+    txnMgr.setAppCfgUpdateToTx(txId, cfgUpdate);
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: false,
+      stepName: 'step2'
+    });
+
+    expect(txnMgr.getProjectFromTransaction(txId)).toEqual(projectId);
+    expect(txnMgr.getTransactionFromProject(projectId)).toEqual(txId);
+    expect(txnMgr.isOngoingTransaction(txId)).toBe(true);
+    expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(true);
+    expect(txnMgr.isAnyOngoingTransaction()).toBe(true);
+    expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(cfgUpdate);
+  });
+
+  test('update an appCfgUpdate to the same tx ', async () => {
+    const txId = generateTxId();
+    const projectId = generateRandomProjectId();
+    const cfgUpdate: ShadowUpdate = { txId: txId, projectId: projectId };
+
+    const ogAppCfg1: AppConfigUpdate = {
+      newAppCfg: {
+        scripts: {
+          start: 'python app.py'
+        },
+        models: {}
+      }
+    };
+
+    const cfgUpdate2: ShadowUpdate = {
+      txId: txId,
+      projectId: projectId,
+      appCfgUpdate: ogAppCfg1
+    };
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: true
+    });
+
+    txnMgr.setAppCfgUpdateToTx(txId, cfgUpdate);
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: false,
+      stepName: 'step2'
+    });
+    txnMgr.setAppCfgUpdateToTx(txId, cfgUpdate2);
+
+    expect(txnMgr.getProjectFromTransaction(txId)).toEqual(projectId);
+    expect(txnMgr.getTransactionFromProject(projectId)).toEqual(txId);
+    expect(txnMgr.isOngoingTransaction(txId)).toBe(true);
+    expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(true);
+    expect(txnMgr.isAnyOngoingTransaction()).toBe(true);
+    expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(cfgUpdate2);
+  });
+
+  test('remove a tx, ensure appCfgUpdate is removed', async () => {
+    const txId = generateTxId();
+    const projectId = generateRandomProjectId();
+    const cfgUpdate: ShadowUpdate = { txId: txId, projectId: projectId };
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: true
+    });
+
+    txnMgr.setAppCfgUpdateToTx(txId, cfgUpdate);
+    txnMgr.completeTransaction(txId);
+
+    expect(txnMgr.getProjectFromTransaction(txId)).toEqual(undefined);
+    expect(txnMgr.getTransactionFromProject(projectId)).toEqual(undefined);
+    expect(txnMgr.isOngoingTransaction(txId)).toBe(false);
+    expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(false);
+    expect(txnMgr.isAnyOngoingTransaction()).toBe(false);
+    expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(undefined);
+  });
 });

package/src/cloud-connection/transaction-manager.ts

@@ -8,6 +8,7 @@ import { Publisher } from './publisher';
 import { logger } from '../util/logger';
 import { keyMirror } from 'alwaysai/lib/util';
 import { CodedError } from '@carnesen/coded-error';
+import { ShadowUpdate } from './shadow-handler';
 
 interface TransactionDetails {
   txId: string;
@@ -16,6 +17,7 @@ interface TransactionDetails {
   start: string;
   update?: string;
   stop?: string;
+  appCfgUpdate?: ShadowUpdate;
 }
 
 export class TransactionManager {
@@ -169,6 +171,19 @@ export class TransactionManager {
     return txnDetails?.projectId;
   }
 
+  public getAppCfgUpdateFromTxID(txId: string): ShadowUpdate | undefined {
+    return this.detailsByTx[txId]?.appCfgUpdate;
+  }
+
+  public setAppCfgUpdateToTx(txId: string, appCfgUpdate: ShadowUpdate) {
+    if (this.isOngoingTransaction(txId)) {
+      this.detailsByTx[txId].appCfgUpdate = appCfgUpdate;
+    } else
+      throw new Error(
+        `Could not set appCfgUpdate, the transaction ${txId} does not exist.`
+      );
+  }
+
   public completeTransaction(txId: string): void {
     const txDetails = this.detailsByTx[txId];
     if (txDetails === undefined) {

package/src/device-control/device-control.ts

@@ -4,7 +4,9 @@ import * as osu from 'node-os-utils';
 import * as si from 'systeminformation';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { JsSpawner } from 'alwaysai/lib/util';
 import { DeviceStatsPayload } from '@alwaysai/device-agent-schemas';
+import { getDeviceAgentVersion } from '../util/check-for-updates';
 
 const exec_promise = promisify(exec);
 
@@ -112,27 +114,100 @@ export async function getNetworkInfo() {
   };
 }
 
+export async function getDockerVersion() {
+  try {
+    const spawner = JsSpawner();
+    const result = JSON.parse(
+      await spawner.run({
+        exe: 'docker',
+        args: ['info', '--format', 'json']
+      })
+    );
+    return result.ClientInfo.Version;
+  } catch (e) {
+    logger.warn(`Cannot get Docker version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getDockerComposeVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'docker',
+      args: ['compose', 'version']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get Docker Compose version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getNpmVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'npm',
+      args: ['--version']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get npm version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getNodeVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'node',
+      args: ['-v']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get Node version: ${e}`);
+    return 'Not found';
+  }
+}
+
 export async function getPackageVersions() {
-  // eslint-disable-next-line
-  const agentJson = require('../../package.json');
+  const agentVersion = await getDeviceAgentVersion();
   // eslint-disable-next-line
   const deviceAgentSchemasJson = require('../../node_modules/@alwaysai/device-agent-schemas/package.json');
+
+  // Concurrent asynchronous function call
+  const [dockerVersion, dockerComposeVersion, nodeVersion, npmVersion] =
+    await Promise.all([
+      getDockerVersion(),
+      getDockerComposeVersion(),
+      getNodeVersion(),
+      getNpmVersion()
+    ]);
+
   return {
-    agent: agentJson.version,
-    deviceAgentSchemas: deviceAgentSchemasJson.version
+    agent: agentVersion,
+    deviceAgentSchemas: deviceAgentSchemasJson.version,
+    docker: dockerVersion,
+    dockerCompose: dockerComposeVersion,
+    node: nodeVersion,
+    npm: npmVersion
   };
 }
 
 export async function getLastBootTime() {
   try {
-    const test = await exec_promise(
-      "last -x reboot | grep reboot | head -n 1 | awk '{ print $5, $6, $7, $8 }'"
-    );
-    if (test.stderr) {
-      logger.error(`Stderr when getting last boot time: ${test.stderr}`);
+    const out = await exec_promise('journalctl --list-boots');
+    if (!out || out.stderr) {
+      logger.error(`Stderr when getting last boot time: ${out.stderr}`);
       return undefined;
     }
-    return new Date(test.stdout).toString();
+
+    const bootTimes = out.stdout.split('\n');
+    const latestBootStdout = (bootTimes.pop() || bootTimes.pop())?.trim(); // possible last \n causes '' at end of array
+    if (!latestBootStdout) return undefined;
+
+    const tokens = latestBootStdout.trim().split(' ');
+
+    return new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`);
   } catch (e) {
     logger.error(`Issue getting last boot time: ${e.message}`);
     return undefined;
@@ -148,7 +223,7 @@ export async function getSystemInformation(): Promise<SystemInformationShadowUpd
       device: await getDeviceInfo(),
       network: await getNetworkInfo(),
       versions: await getPackageVersions(),
-      lastBootTime: await getLastBootTime()
+      lastBootTime: (await getLastBootTime())?.toString()
     };
     return systemInfo;
   } catch (e) {

package/src/docker/docker-compose.ts

@@ -0,0 +1,60 @@
+import * as DockerComposeV1 from 'docker-compose';
+import { v2 as DockerComposeV2 } from 'docker-compose';
+import { execSync } from 'child_process';
+import { logger } from '../util/logger';
+import { JsSpawner } from 'alwaysai/lib/util';
+
+let dockerCmd = 'docker';
+
+export function importDockerCompose():
+  | typeof DockerComposeV1
+  | typeof DockerComposeV2 {
+  try {
+    execSync('docker compose version').toString();
+    logger.debug('Using Docker Compose V2.');
+    return DockerComposeV2;
+  } catch (e) {
+    try {
+      execSync('docker-compose -v').toString();
+      logger.warn('Using docker-compose V1. Please consider updating to V2.');
+    } catch (e) {
+      logger.warn(`Could not determine compose: ${e}`);
+    }
+  }
+  dockerCmd = 'docker-compose';
+  return DockerComposeV1;
+}
+
+export const compose = importDockerCompose();
+
+export async function runDockerComposeCmd(props: {
+  args: string[];
+  dir: string;
+}) {
+  const { args, dir } = props;
+  const spawner = JsSpawner();
+  if (dockerCmd === 'docker') {
+    args.unshift('compose');
+  }
+  const output = await spawner.run({
+    exe: dockerCmd,
+    args,
+    cwd: dir
+  });
+  return output;
+}
+
+export async function runStreamingDockerComposeCmd(props: {
+  args: string[];
+  dir: string;
+}) {
+  const { args, dir } = props;
+  if (dockerCmd === 'docker') {
+    args.unshift('compose');
+  }
+  return await JsSpawner().runStreaming({
+    exe: dockerCmd,
+    args,
+    cwd: dir
+  });
+}

package/src/index.ts

@@ -10,13 +10,9 @@ import { root } from './root';
 import { runDeviceAgentCloudInterface } from './cloud-connection/device-agent-cloud-connection';
 import { AgentConfigFile } from './infrastructure/agent-config';
 import { ALWAYSAI_DEVICE_AGENT_MODE } from './environment';
-import { logger } from './util/logger';
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { version } = require('../package.json');
+import { checkForUpdatesAndPrompt } from './util/check-for-updates';
 
 if (module === require.main) {
-  logger.info(`Starting alwaysAI Device Agent v${version}`);
   if (!AgentConfigFile().exists()) {
     AgentConfigFile().initialize();
   }
@@ -24,6 +20,6 @@ if (module === require.main) {
   if (ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
     void runDeviceAgentCloudInterface();
   } else {
-    void runCliAndExit(root, {});
+    void runCliAndExit(root, { postRun: checkForUpdatesAndPrompt });
   }
 }

package/src/infrastructure/agent-config.test.ts

@@ -95,6 +95,9 @@ describe('Test Agent Config', () => {
       expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       await configFile.setAppInstalled({ projectId, version });
       expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      expect(await configFile.isAppReady({ projectId })).toEqual(true);
+      await configFile.setAppUninstalling({ projectId });
+      expect(await configFile.isAppReady({ projectId })).toEqual(false);
       await configFile.setAppUninstalled({ projectId });
       const apps = await configFile.getApps();
       expect(apps).toEqual([]);