@alwaysai/device-agent 1.4.0 → 2.0.0

package/src/infrastructure/tokens-and-device-cfg.ts

@@ -1,13 +1,14 @@
-import { logger } from '../util/logger';
-import { microServiceHttpClient } from '../util/http-client';
-import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
 import {
   DeviceTokens,
-  writeOrValidateDeviceCfgFile,
-  writeTokens
+  writeOrValidateDeviceCfgFile
 } from 'alwaysai/lib/core/device';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
 import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/paths';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+import { microServiceHttpClient } from '../util/http-client';
+import { logger } from '../util/logger';
+import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
 
 // NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
 export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
@@ -21,14 +22,15 @@ export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
   );
 
   const tokens: DeviceTokens = {
-    deviceId: deviceUuid,
+    deviceUuid,
     accessToken,
     refreshToken,
     idToken
   };
-  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
-  await writeTokens({ spawner: tokenSpawner, tokens });
-  await writeOrValidateDeviceCfgFile({ spawner: tokenSpawner, deviceUuid });
+  const tokenSpawner = JsSpawner({
+    path: join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath())
+  });
+  await writeOrValidateDeviceCfgFile({ spawner: tokenSpawner, ...tokens });
 
   logger.info('Updated tokens and certificate');
 }

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

@@ -1,13 +1,12 @@
-import { logger } from '../util/logger';
-import sleep from '../util/sleep';
-import compose from 'docker-compose';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 import * as YAML from 'yaml';
-
+import { compose } from '../docker/docker-compose';
 import {
-  DEVICE_AGENT_CFG_PATH,
-  DEVICE_AGENT_DOCKER_COMPOSE_PATH
+  getDeviceAgentConfigPath,
+  getDeviceAgentDockerComposePath
 } from '../util/directories';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
 import { LOCAL_CONNECTION_PORT } from './constants';
 
 export const rabbitMQServiceName = 'alwaysAIRabbitMQ';
@@ -16,33 +15,33 @@ export const rabbitMQContainerName = 'alwaysAIRabbitMQContainer';
 export async function checkRabbitMQContainerRunning() {
   logger.debug('Checking alwaysAI Local Connection Container status');
   const spawner = JsSpawner();
-  if (!(await spawner.exists(DEVICE_AGENT_DOCKER_COMPOSE_PATH))) {
+  if (!(await spawner.exists(getDeviceAgentDockerComposePath()))) {
     logger.warn(
       'alwaysAI Location Connection configuration file is not present'
     );
     return false;
   }
-  const containerData = await compose.ps({ cwd: DEVICE_AGENT_CFG_PATH });
-  if (!(containerData === undefined)) {
+  const containerData = await compose.ps({ cwd: getDeviceAgentConfigPath() });
+  if (containerData !== undefined) {
     const rabbitmqService = containerData.data.services[0];
     if (
-      rabbitmqService.name === rabbitMQContainerName &&
-      rabbitmqService.state === 'Up'
+      rabbitmqService?.name === rabbitMQContainerName &&
+      rabbitmqService.state.includes('Up')
     ) {
-      logger.debug('alwaysAI Local Connection is running');
+      logger.debug('alwaysAI Local Connection Container is up');
       return true;
     }
-    logger.debug('alwaysAI Local Connection is not running');
+    logger.debug('alwaysAI Local Connection Container is not up');
     return false;
   }
-  logger.warn('alwaysAI Local Connection container was undefined');
+  logger.warn('alwaysAI Local Connection Container is undefined');
   return false;
 }
 
 export async function writeRabbitMQDockerComposeFile() {
   const spawner = JsSpawner();
-  if (!(await spawner.exists(DEVICE_AGENT_CFG_PATH))) {
-    await JsSpawner().mkdirp(DEVICE_AGENT_CFG_PATH);
+  if (!(await spawner.exists(getDeviceAgentConfigPath()))) {
+    await JsSpawner().mkdirp(getDeviceAgentConfigPath());
   }
 
   logger.debug(
@@ -68,7 +67,7 @@ export async function writeRabbitMQDockerComposeFile() {
 
   const RabbitMQDockerComposeYaml = YAML.stringify(rabbitmqDockerComposeCmd);
   await spawner.writeFile(
-    DEVICE_AGENT_DOCKER_COMPOSE_PATH,
+    getDeviceAgentDockerComposePath(),
     RabbitMQDockerComposeYaml
   );
 }
@@ -79,12 +78,14 @@ export async function setupRabbitMQContainer() {
     await writeRabbitMQDockerComposeFile();
   } catch (e) {
     logger.error(
-      `An error occurred setting up docker-compose.yaml for Device Agent pass through:\n{e.message}`
+      `An error occurred setting up docker-compose.yaml for Device Agent pass through!\n${stringifyError(
+        e
+      )}`
     );
   }
   try {
     const upOut = await compose.upAll({
-      cwd: DEVICE_AGENT_CFG_PATH
+      cwd: getDeviceAgentConfigPath()
     });
     logger.debug(
       `Docker compose up for alwaysAI Local Connection:\n${JSON.stringify(
@@ -97,14 +98,16 @@ export async function setupRabbitMQContainer() {
     }
   } catch (e) {
     logger.error(
-      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e.messaage}`
+      `Unable to start alwaysAI Device Agent Local Connection Container!\n${stringifyError(
+        e
+      )}`
     );
   }
 }
 
 export async function stopRabbitMQContainer() {
   try {
-    const downOut = await compose.down({ cwd: DEVICE_AGENT_CFG_PATH });
+    const downOut = await compose.down({ cwd: getDeviceAgentConfigPath() });
     logger.debug(`Stopping alwaysAI Local Connection container`);
     logger.debug(
       `Docker compose down for alwaysAI Local Connection:\n${JSON.stringify(
@@ -113,7 +116,9 @@ export async function stopRabbitMQContainer() {
     );
   } catch (e) {
     logger.error(
-      `Unable to stop alwaysAI Device Agent Local Connection Container:\n${e.message}`
+      `Unable to stop alwaysAI Device Agent Local Connection Container!\n${stringifyError(
+        e
+      )}`
     );
   }
 }

package/src/secure-tunneling/secure-tunneling.test.ts

@@ -1,4 +1,10 @@
+import {
+  SecureTunnelPortInfo,
+  SecureTunnelShadowUpdate
+} from '@alwaysai/device-agent-schemas';
 import { AAI_DIR } from 'alwaysai/lib/paths';
+import { downloadToFile } from '../util/file';
+import { ChildProcess } from 'child_process';
 import { join } from 'path';
 import { aaiArtifactsBucketUrl } from '../urls';
 import {
@@ -7,18 +13,12 @@ import {
   SECURE_TUNNEL_BIN_NAME,
   SECURE_TUNNEL_BIN_PATH
 } from '../util/directories';
-import { downloadFile } from '../util/download-file';
 import { getArch, getDistribution, getOsVersion } from '../util/system-info';
 import {
   SecureTunnelHandlerSingleton,
-  SecureTunnelPortInfo,
-  SecureTunnelShadowDesRep,
   SecureTunnelShadowUpdateDelta
 } from './secure-tunneling';
-// import { JsSpawner } from 'alwaysai/lib/util/spawner';
-import { ChildProcess } from 'child_process';
 import { killDetachedProcess, runDetachedProcess } from './spawner-detached';
-
 //-----------------------------------------------------------------------------
 // mocks
 //-----------------------------------------------------------------------------
@@ -49,9 +49,8 @@ jest.mock('../util/system-info', () => ({
   getDistribution: jest.fn()
 }));
 
-jest.mock('../util/download-file', () => ({
-  downloadFile: jest.fn()
-}));
+jest.mock('../util/file');
+const mockDownloadToFile = jest.mocked(downloadToFile);
 
 jest.mock('./spawner-detached', () => ({
   runDetachedProcess: jest.fn(),
@@ -173,9 +172,9 @@ describe('SecureTunnelHandlerSingleton', () => {
 
   function transformDeltaToUpdateReported(
     deltaMsg: SecureTunnelShadowUpdateDelta
-  ): SecureTunnelShadowDesRep {
+  ): SecureTunnelShadowUpdate {
     const { version, state } = deltaMsg;
-    const reportedStateReported: SecureTunnelShadowDesRep = JSON.parse(
+    const reportedStateReported: SecureTunnelShadowUpdate = JSON.parse(
       JSON.stringify(state)
     );
     return reportedStateReported;
@@ -671,16 +670,16 @@ describe('SecureTunnelHandlerSingleton', () => {
   //---------------------------------------------------------------------------
   // test secureTunnelNotifyHandler function
   //---------------------------------------------------------------------------
-  it('should start Secure Tunnel, given localproxy already downloaded and default shadow is not enabled, that is default SSH connection', async () => {
+  it('should start Secure Tunnel, given local proxy already downloaded and default shadow is not enabled, that is default SSH connection', async () => {
     // Arrange
     // --------------------------------------------------------------------
-    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
+    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
     const message: SecureTunnelNotifyMsg = {
       clientAccessToken: 'DefaultSSHConnection_001',
       region: 'us-west-2',
       services: ['SSH']
     };
-    const expectedLocalproxyArgs = [
+    const expectedLocalProxyArgs = [
       '--destination-app',
       '22',
       '--region',
@@ -705,16 +704,16 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(getDistribution).not.toHaveBeenCalled();
     expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
     expect(mockJsSpawner.run).not.toHaveBeenCalled();
-    expect(downloadFile).not.toHaveBeenCalled();
+    expect(mockDownloadToFile).not.toHaveBeenCalled();
     expect(runDetachedProcess).toHaveBeenCalledTimes(1);
     expect(runDetachedProcess).toHaveBeenCalledWith(
       SECURE_TUNNEL_BIN_PATH,
-      expectedLocalproxyArgs
+      expectedLocalProxyArgs
     );
     expect(killDetachedProcess).not.toHaveBeenCalled();
   });
 
-  const testCasesForDIfferentLocalproxyEnv: [string, string, string][] = [
+  const testCasesForDIfferentLocalProxyEnv: [string, string, string][] = [
     // linuxDistro, osVersion, arch
     ['debian', '12', 'aarch64'],
     ['debian', '12', 'arm64'],
@@ -734,12 +733,12 @@ describe('SecureTunnelHandlerSingleton', () => {
     ['ubuntu', '23.10', 'amd64'],
     ['ubuntu', '23.10', 'arm64']
   ];
-  test.each(testCasesForDIfferentLocalproxyEnv)(
-    'should start Secure Tunnel, given localproxy downloaded needed and default shadow is not enabled, that is default SSH connection',
+  test.each(testCasesForDIfferentLocalProxyEnv)(
+    'should start Secure Tunnel, given local proxy downloaded needed and default shadow is not enabled, that is default SSH connection',
     async (linuxDistro: string, osVersion: string, arch: string) => {
       // Arrange
       // --------------------------------------------------------------------
-      mockJsSpawner.exists.mockResolvedValueOnce(false); // mock that localproxy does not exist on file system
+      mockJsSpawner.exists.mockResolvedValueOnce(false); // mock that local proxy does not exist on file system
       jest.mocked(getArch).mockResolvedValueOnce(arch);
       jest.mocked(getOsVersion).mockResolvedValueOnce(osVersion);
       jest.mocked(getDistribution).mockResolvedValueOnce(linuxDistro);
@@ -749,7 +748,7 @@ describe('SecureTunnelHandlerSingleton', () => {
         region: 'us-west-2',
         services: ['SSH']
       };
-      const expectedLocalproxyArgs = [
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -782,16 +781,15 @@ describe('SecureTunnelHandlerSingleton', () => {
         exe: 'chmod',
         args: ['+x', SECURE_TUNNEL_BIN_PATH]
       });
-      expect(downloadFile).toHaveBeenCalledTimes(1);
-      expect(downloadFile).toHaveBeenCalledWith({
+      expect(mockDownloadToFile).toHaveBeenCalledTimes(1);
+      expect(mockDownloadToFile).toHaveBeenCalledWith({
         url: expectedUrl,
-        path: SECURE_TUNNEL_BIN_PATH,
-        errorMessage: `Secure Tunnel bin for ${linuxDistro} ${osVersion} ${arch} not found}`
+        path: SECURE_TUNNEL_BIN_PATH
       });
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
         SECURE_TUNNEL_BIN_PATH,
-        expectedLocalproxyArgs
+        expectedLocalProxyArgs
       );
       expect(killDetachedProcess).not.toHaveBeenCalled();
     }
@@ -891,8 +889,8 @@ describe('SecureTunnelHandlerSingleton', () => {
     async (message) => {
       // Arrange
       // --------------------------------------------------------------------
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -916,7 +914,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(mockJsSpawner.run).not.toHaveBeenCalled();
       expect(runDetachedProcess).not.toHaveBeenCalled();
       expect(killDetachedProcess).not.toHaveBeenCalled();
@@ -1003,8 +1001,8 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(actualReportedShadow).toEqual(updateReported);
       jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
       jest.resetModules();
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -1028,7 +1026,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(runDetachedProcess).not.toHaveBeenCalled();
       expect(killDetachedProcess).not.toHaveBeenCalled();
     }
@@ -1128,8 +1126,8 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(actualReportedShadow).toEqual(updateReported);
       jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
       jest.resetModules();
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         expectedPortMapping,
         '--region',
@@ -1153,12 +1151,12 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(mockJsSpawner.run).not.toHaveBeenCalled();
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
         SECURE_TUNNEL_BIN_PATH,
-        expectedLocalproxyArgs
+        expectedLocalProxyArgs
       );
       expect(killDetachedProcess).toHaveBeenCalledTimes(0);
     }
@@ -1192,8 +1190,8 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(beforeReportedShadow).toEqual(updateReported);
     jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
     jest.resetModules();
-    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-    const expectedLocalproxyArgs = [
+    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+    const expectedLocalProxyArgs = [
       '--destination-app',
       expectedPortMapping,
       '--region',
@@ -1228,7 +1226,7 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(getOsVersion).not.toHaveBeenCalled();
     expect(getDistribution).not.toHaveBeenCalled();
     expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-    expect(downloadFile).not.toHaveBeenCalled();
+    expect(mockDownloadToFile).not.toHaveBeenCalled();
     expect(mockJsSpawner.run).not.toHaveBeenCalled();
     expect(runDetachedProcess).toHaveBeenCalledTimes(0);
     expect(killDetachedProcess).toHaveBeenCalledTimes(2);