@alwaysai/device-agent 0.0.13 → 0.0.14

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

@@ -0,0 +1,361 @@
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
+import { readAppCfgFile } from '../application-control';
+import { Publisher } from './publisher';
+import { ShadowHandler } from './shadow-handler';
+
+jest.mock('../application-control');
+jest.mock('./publisher');
+const mockClient = jest.fn();
+const clientId = 'test-client';
+const projectId1 = 'test-project';
+const projectId2 = 'test-project-2';
+
+describe('Test Shadow Handler', () => {
+  let publisher: Publisher;
+  let shadowHandler: ShadowHandler;
+
+  beforeEach(() => {
+    publisher = new Publisher(mockClient, clientId);
+    shadowHandler = new ShadowHandler(clientId, publisher);
+  });
+
+  test.skip('reject buffer payload', async () => {
+    //FIXME: Invalid input is silently ignored, need input validation
+    expect(() => {
+      shadowHandler.handleShadowTopic({
+        topic: shadowHandler.shadowTopics.projects.updateDelta,
+        payload: Buffer.from('test-payload')
+      });
+    }).toThrow(Error);
+  });
+
+  test('ignore message from self', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v3': 4
+      }
+    };
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      },
+      clientToken: clientId
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test('handle shadow get response with updated models', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v3': 4
+      }
+    };
+
+    const payload = {
+      delta: {
+        [projectId1]: {
+          appConfig: JSON.stringify(appCfg1)
+        }
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.getAccepted,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/yolo_v3': 4
+      }
+    });
+  });
+
+  test('handle shadow delta without app config', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const payload = {
+      [projectId1]: {}
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test('handle shadow delta with updated models', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    });
+  });
+
+  test('handle shadow delta with updated models for two apps', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValueOnce(ogAppCfg1);
+    const ogAppCfg2: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v4': 5
+      }
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValueOnce(ogAppCfg2);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    };
+    const appCfg2: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/yolo_v4': 5,
+        'alwaysai/human_pose': 7
+      }
+    };
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      },
+      [projectId2]: {
+        appConfig: JSON.stringify(appCfg2)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(2);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1,
+      updatedModels: {
+        'alwaysai/mobilenet_ssd': 3,
+        'alwaysai/yolo_v4': 5
+      }
+    });
+    expect(appCfgUpdates[1]).toEqual({
+      projectId: projectId2,
+      newAppCfg: appCfg2,
+      updatedModels: {
+        'alwaysai/human_pose': 7
+      }
+    });
+  });
+
+  test('handle shadow delta with updated analytics', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {}
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+
+    const appCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {},
+      analytics: {
+        enable_cloud_publish: true
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(1);
+    expect(appCfgUpdates[0]).toEqual({
+      projectId: projectId1,
+      newAppCfg: appCfg1
+    });
+  });
+
+  test('handle shadow delta with invalid app config', async () => {
+    const ogAppCfg1: AppConfig = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': 2
+      }
+    };
+
+    jest.mocked(readAppCfgFile).mockResolvedValue(ogAppCfg1);
+    const appCfg1 = {
+      scripts: {
+        start: 'python app.py'
+      },
+      models: {
+        'alwaysai/mobilenet_ssd': '3',
+        'alwaysai/yolo_v4': '5'
+      }
+    };
+
+    const payload = {
+      [projectId1]: {
+        appConfig: JSON.stringify(appCfg1)
+      }
+    };
+
+    const appCfgUpdates = await shadowHandler.handleShadowTopic({
+      topic: shadowHandler.shadowTopics.projects.updateDelta,
+      payload
+    });
+    expect(appCfgUpdates.length).toBe(0);
+  });
+
+  test.skip('publish app state', async () => {
+    // FIXME: For some reason publisher is not being called...
+    const testAppCfg: AppConfig = {
+      scripts: {
+        start: ''
+      },
+      models: {}
+    };
+    jest.mocked(readAppCfgFile).mockResolvedValue(testAppCfg);
+
+    shadowHandler.publishAppState(projectId1);
+    expect(jest.mocked(readAppCfgFile)).toBeCalledWith({ projectId1 });
+    const packet = {
+      state: {
+        reported: {
+          [projectId1]: { appConfig: JSON.stringify(testAppCfg) }
+        }
+      },
+      clientToken: clientId
+    };
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.update,
+      JSON.stringify(packet)
+    );
+  });
+
+  test('get shadow updates', async () => {
+    shadowHandler.getShadowUpdates();
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.get,
+      JSON.stringify({
+        clientToken: clientId
+      })
+    );
+  });
+
+  test('delete project shadow', async () => {
+    shadowHandler.deleteProjectShadow(projectId1);
+    const packet = {
+      state: {
+        reported: {
+          [projectId1]: null
+        }
+      },
+      clientToken: clientId
+    };
+    expect(jest.mocked(publisher.publish)).toBeCalledWith(
+      shadowHandler.shadowTopics.projects.update,
+      JSON.stringify(packet)
+    );
+  });
+});

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

@@ -7,7 +7,7 @@ import { logger } from '../util/logger';
 import { Publisher } from './publisher';
 import { AppConfigModels, getAppCfgModelsDiff } from './shadow';
 
-interface ShadowTopics {
+export interface ShadowTopics {
   projects: {
     update: string;
     get: string;
@@ -59,8 +59,9 @@ export class ShadowHandler {
       if (projectShadow.appConfig) {
         const newAppCfg = JSON.parse(projectShadow.appConfig);
         if (!validateAppConfig(newAppCfg)) {
+          // FIXME: Raise an exception to be handled at higher layer
           logger.error(
-            `Received invalid app config for ${projectId}!/n${JSON.stringify(
+            `Received invalid app config for ${projectId}!\n${JSON.stringify(
               validateAppConfig.errors,
               null,
               2
@@ -78,6 +79,10 @@ export class ShadowHandler {
         } else {
           appConfigUpdates.push({ projectId, newAppCfg });
         }
+      } else {
+        logger.warn(
+          `Ignoring shadow update for ${projectId} due to no app config`
+        );
       }
     }
     return appConfigUpdates;
@@ -96,6 +101,16 @@ export class ShadowHandler {
     const shadowName = topic.split('/')[5];
     switch (topic) {
       case this.shadowTopics.projects.updateDelta:
+        if (payload.clientToken === this.clientId) {
+          logger.debug(
+            `Ignoring message sent from self: ${JSON.stringify(
+              { topic, payload },
+              null,
+              2
+            )}`
+          );
+          break;
+        }
         return await this.handleNamedShadowUpdate({ delta: payload });
       case this.shadowTopics.projects.getAccepted:
         if (payload['delta']) {
@@ -143,12 +158,18 @@ export class ShadowHandler {
     );
   }
 
-  public deleteProjectShadow() {
+  public deleteProjectShadow(projectId: string) {
+    const packet = {
+      state: {
+        reported: {
+          [projectId]: null
+        }
+      },
+      clientToken: this.clientId
+    };
     this.publisher.publish(
-      `${this.shadowTopics.projects.delete}`,
-      JSON.stringify({
-        clientToken: this.clientId
-      })
+      this.shadowTopics.projects.update,
+      JSON.stringify(packet)
     );
   }
 }

package/src/environment.ts

@@ -10,6 +10,9 @@ export const ALWAYSAI_DEVICE_AGENT_MODE =
   process.env.ALWAYSAI_DEVICE_AGENT_MODE;
 export const ALWAYSAI_LOG_LEVEL = process.env.AAI_LOG_LEVEL;
 export const ALWAYSAI_LOG_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
+export const ALWAYSAI_ANALYTICS_PASSTHROUGH = parseBoolean(
+  process.env.ALWAYSAI_ANALYTICS_PASSTHROUGH
+);
 
 function parseOsPlatform(str: string | undefined): NodeJS.Platform {
   switch (str) {

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

@@ -1,13 +1,6 @@
 import * as tempy from 'tempy';
 import { AgentConfigFile } from './agent-config';
 
-const mockAgentModeGetter = jest.fn().mockReturnValue(undefined);
-jest.mock('../environment', () => ({
-  get ALWAYSAI_DEVICE_AGENT_MODE() {
-    return mockAgentModeGetter();
-  }
-}));
-
 const configFile = AgentConfigFile(tempy.directory());
 
 describe('Test Agent Config', () => {

package/src/infrastructure/agent-config.ts

@@ -1,4 +1,7 @@
-import { ConfigFileSchema } from '@alwaysai/config-nodejs';
+import {
+  ConfigFileSchema,
+  ConfigFileSchemaReturnType
+} from '@alwaysai/config-nodejs';
 import Ajv, { JSONSchemaType } from 'ajv';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -55,7 +58,26 @@ const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
 
 const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
+export interface AgentJsonFileReturnType
+  extends ConfigFileSchemaReturnType<AgentConfig> {
+  name: string;
+  getApps: () => Promise<InstalledAppConfig[]>;
+  getReadyApps;
+  getApp;
+  isAppPresent;
+  isAppReady;
+  removeApp;
+  setAppInstalling;
+  setAppInstalled;
+  setAppUninstalled;
+  getAppVersion;
+  setAppBackup;
+  getAppBackup;
+}
+
+export function AgentConfigFile(
+  dir = ALWAYSAI_CONFIG_DIR
+): AgentJsonFileReturnType {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []

package/src/infrastructure/system-id.ts

@@ -1,6 +1,6 @@
+import { SystemId } from 'alwaysai/lib/constants';
 import { DeviceConfigFile } from 'alwaysai/lib/core/device';
 import { ALWAYSAI_SYSTEM_ID } from 'alwaysai/lib/environment';
-import { SystemId } from 'alwaysai/lib/infrastructure';
 
 export function getSystemId() {
   if (ALWAYSAI_SYSTEM_ID) {

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

@@ -1,23 +1,18 @@
-import {
-  DeviceTokens,
-  writeOrValidateDeviceCfgFile
-} from 'alwaysai/lib/components/device';
-import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
 import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/constants';
-import { checkPaidPlan } from 'alwaysai/lib/core/project';
-import { JsSpawner, writeTokens } from 'alwaysai/lib/util';
 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
+} from 'alwaysai/lib/core/device';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 // NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
 export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
   const { deviceUuid } = props;
-  await checkUserIsLoggedInComponent({ yes: true });
-  if (!(await checkPaidPlan())) {
-    throw new Error(
-      `This action only supported for Enterprise alwaysAI accounts!`
-    );
-  }
+  await requireLoggedInAndPaidPlan();
   const { accessToken, refreshToken, idToken } = await microServiceHttpClient(
     'token-service',
     'create-device-tokens',

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

@@ -0,0 +1,53 @@
+import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
+
+export async function checkRabbitMQContainerRunning() {
+  const spawner = JsSpawner();
+  return await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+}
+
+export async function setupRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainerRunning = await checkRabbitMQContainerRunning();
+  logger.debug('Checking for running RabbitMQ container');
+  if (!rabbitMqContainerRunning) {
+    logger.debug('Setting up RabbitMQ container');
+    await spawner.run({
+      exe: 'docker',
+      args: [
+        'run',
+        '--rm',
+        '-p',
+        '5672:5672',
+        '-d',
+        '--hostname',
+        'my-rabbit',
+        'rabbitmq'
+      ]
+    });
+    await sleep(8000);
+    while (!(await checkRabbitMQContainerRunning())) {
+      await sleep(5000);
+    }
+  }
+}
+
+export async function stopRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainer = await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+  if (!rabbitMqContainer) {
+    logger.debug('No RabbitMQ container running');
+  } else {
+    await spawner.run({
+      exe: 'docker',
+      args: ['stop', `${rabbitMqContainer}`]
+    });
+  }
+}