@alwaysai/device-agent 0.0.4 → 0.0.5

package/src/cloud-connection/device-agent-cloud-connection.ts

@@ -1,21 +1,46 @@
 const awsIot = require('aws-iot-device-sdk');
-import { getIoTCoreEndpointUrl } from '../util/urls';
+import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
 import {
   getPrivateKeyFilePath,
   getCertificateFilePath,
   getRootCertificateFilePath,
 } from '../util/directories';
-import { getAppStatus } from '../application-control/status';
-import { getInstalledApps } from '../application-control/install';
-import { AppStatus } from '../application-control/types';
+import {
+  startApp,
+  stopApp,
+  restartApp,
+  getAppStatus,
+  getAppLogs,
+} from '../application-control/status';
+import { installApp } from '../application-control/install';
 import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
+import {
+  DeviceAgentMessage,
+  DeviceStatsMessage,
+  AppState,
+  AppStateMessage,
+  ActionMessage,
+  AppLogs,
+  AppLogsMessage,
+  InstallationStatusMessage,
+  InstallationStatus,
+  InstallationStatusEnum,
+} from '@alwaysai/device-agent-schemas';
 import { getDeviceId } from '../util/get-device-id';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 
 export class DeviceAgentCloudConnection {
-  public device = awsIot.device;
   private clientId = getDeviceId();
   private host = getIoTCoreEndpointUrl();
-  private publishInterval = 1000;
+  private publishable = false;
+  private readonly publishInterval = 1000;
+  private readonly installationStatusInterval = 3000;
+  private installationStatus: InstallationStatus;
+  private publishableTimeout: ReturnType<typeof setTimeout>;
+
+  public device = awsIot.device;
+  public agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
+  public cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
 
   constructor() {
     this.device = awsIot.device({
@@ -26,21 +51,46 @@ export class DeviceAgentCloudConnection {
       host: this.host,
     });
 
-    // TODO: subscribe to topics here
-    this.device.subscribe('command');
-    this.publishInterval = this.publishInterval;
+    this.device.subscribe(`${this.agentTopicPrefix}command`);
+    this.device.subscribe(`${this.agentTopicPrefix}response`);
+  }
+
+  public setInstallationStatus(installationStatus: InstallationStatus) {
+    this.installationStatus = installationStatus;
+  }
+
+  public getInstallationStatus(): InstallationStatus {
+    return this.installationStatus;
+  }
+
+  public getPublishable(): boolean {
+    return this.publishable;
+  }
+
+  public setPublishable(enabled: boolean) {
+    this.publishable = enabled;
+  }
+
+  public restartPublishableTimeout() {
+    clearTimeout(this.publishableTimeout);
+    this.publishableTimeout = setTimeout(() => {
+      this.setPublishable(false);
+    }, 600000); // 10 min
   }
 
   public getPublishInterval() {
     return this.publishInterval;
   }
 
-  public getClientId() {
+  public getInstallationStatusInterval() {
+    return this.installationStatusInterval;
+  }
+
+  public getClientId(): string {
     return this.clientId;
   }
 
   public publishMessage(topic: string, message: string) {
-    console.log('publishing message ', message);
     this.device.publish(topic, message);
   }
 }
@@ -48,11 +98,60 @@ export class DeviceAgentCloudConnection {
 export function runDeviceAgentCloudInterface() {
   const deviceAgent = new DeviceAgentCloudConnection();
 
-  async function getAppStateMessage() {
-    const appStateMessage: AppStatus[] = [];
-    const installedApps = await getInstalledApps();
-    for (const app of installedApps) {
-      const projectId = app['projectId'];
+  async function buildMessagePacket(
+    topic: string,
+    payload:
+      | DeviceStatsMessage
+      | ActionMessage
+      | AppStateMessage
+      | AppLogsMessage
+      | InstallationStatusMessage,
+  ): Promise<DeviceAgentMessage> {
+    const packet = {
+      timestamp: new Date().toUTCString(),
+      deviceId: deviceAgent.getClientId(),
+      topic,
+      payload,
+    };
+    return packet;
+  }
+
+  async function getAppLogsMessage(): Promise<AppLogsMessage> {
+    const appLogsList: AppLogs[] = [];
+    const apps = await AgentConfigFile().getReadyApps();
+    for (const app of apps) {
+      const projectId = app.projectId;
+      const readable = await getAppLogs({ projectId });
+      const logs: any[] = [];
+      readable.setEncoding('utf8');
+      for await (const chunk of readable) {
+        logs.push(chunk);
+      }
+      const appLogs = {
+        projectId,
+        logs,
+      };
+      appLogsList.push(appLogs);
+    }
+    const applicationStatePackage = {
+      applicationLogs: appLogsList,
+    };
+    return applicationStatePackage;
+  }
+
+  const publishAppLogs = setInterval(async function () {
+    const appLogsMessage = await getAppLogsMessage();
+    const topic = `device/${deviceAgent.getClientId()}/topic/application-management`;
+    const appLogsPacket = await buildMessagePacket(topic, appLogsMessage);
+
+    deviceAgent.publishMessage(topic, JSON.stringify({ appLogsPacket }));
+  }, deviceAgent.getPublishInterval());
+
+  async function getAppStateMessage(): Promise<AppStateMessage> {
+    const appStateMessage: AppState[] = [];
+    const apps = await AgentConfigFile().getApps();
+    for (const app of apps) {
+      const projectId = app.projectId;
       const status = await getAppStatus({ projectId });
       appStateMessage.push(status);
     }
@@ -62,19 +161,16 @@ export function runDeviceAgentCloudInterface() {
     return applicationStatePackage;
   }
 
-  const publishAppState = setInterval(async function() {
-    const topic = `device/${deviceAgent.getClientId()}/topic/application-management`;
-    const appStateMessage = await getAppStateMessage();
-    const appStatePackage = {
-      timestamp: new Date().toUTCString(),
-      deviceId: deviceAgent.getClientId(),
-      topic,
-      payload: appStateMessage,
-    };
-    deviceAgent.publishMessage(topic, JSON.stringify({ appStatePackage }));
+  const publishAppState = setInterval(async function () {
+    if (deviceAgent.getPublishable()) {
+      const topic = `${deviceAgent.cloudTopicPrefix}application-management`;
+      const appStateMessage = await getAppStateMessage();
+      const appStatePacket = await buildMessagePacket(topic, appStateMessage);
+      deviceAgent.publishMessage(topic, JSON.stringify({ appStatePacket }));
+    }
   }, deviceAgent.getPublishInterval());
 
-  async function getDeviceStatsMessage() {
+  async function getDeviceStatsMessage(): Promise<DeviceStatsMessage> {
     const cpuUsage = await getCpuUtil();
     const diskUtil = await getDiskUtil();
     const memUtil = await getMemUtil();
@@ -83,35 +179,142 @@ export function runDeviceAgentCloudInterface() {
       deviceStats: {
         cpuUsage,
         diskUtil,
-        freeMemoryPercentage: memUtil,
+        usedMemoryPercentage: memUtil,
       },
     };
     return deviceStatsMessage;
   }
 
-  const publishDeviceStats = setInterval(async function() {
-    const topic = `device/${deviceAgent.getClientId()}/topic/device-management`;
-    const deviceStatsMessage = await getDeviceStatsMessage();
-    const deviceStatsPackage = {
+  const publishDeviceStats = setInterval(async function () {
+    if (deviceAgent.getPublishable()) {
+      const topic = `${deviceAgent.cloudTopicPrefix}device-management`;
+      const deviceStatsMessage = await getDeviceStatsMessage();
+      const deviceStatsPacket = await buildMessagePacket(topic, deviceStatsMessage);
+      deviceAgent.publishMessage(topic, JSON.stringify({ deviceStatsPacket }));
+    }
+  }, deviceAgent.getPublishInterval());
+
+  const publishDeviceRequest = async ({ projectId }) => {
+    const topic = `${deviceAgent.cloudTopicPrefix}request`;
+    const deviceRequestPackage = {
       timestamp: new Date().toUTCString(),
       deviceId: deviceAgent.getClientId(),
+      projectId,
+      releaseHash: '',
       topic,
-      payload: deviceStatsMessage,
     };
-    deviceAgent.publishMessage(topic, JSON.stringify({ deviceStatsPackage }));
-  }, deviceAgent.getPublishInterval());
+    deviceAgent.publishMessage(
+      topic,
+      JSON.stringify({ device_request: deviceRequestPackage }),
+    );
+  };
 
-  deviceAgent.device.on('connect', function() {
+  const publishInstallationStatus = async (interval: NodeJS.Timeout) => {
+    const topic = `${deviceAgent.cloudTopicPrefix}installation-status`;
+    const installationStatus = deviceAgent.getInstallationStatus();
+    const installationStatusPacket = await buildMessagePacket(topic, {
+      installationStatus,
+    });
+    deviceAgent.device.publish(topic, JSON.stringify({ installationStatusPacket }));
+    if (installationStatus.status !== InstallationStatusEnum.IN_PROGRESS) {
+      clearInterval(interval);
+    }
+  };
+
+  const handleMessageTopic = async ({ topic, payload }) => {
+    const action = payload['action'];
+    const actionPayload: any = payload[action];
+    const type = topic.split('/').slice(-1)[0];
+
+    if (!type) {
+      return false;
+    }
+
+    switch (action) {
+      /**
+       * Install app package based on the given project ID
+       */
+      case 'install':
+        /**
+          {
+            "action": "install",
+            "install": {
+              "releaseHash": "7fb2a812f9e7aa193208dac353521965da50d755085162066c125592f1ed760b",
+              "projectId": "786e4686-a681-4cff-9e17-1e7d385c0fdb"
+            }
+          }
+         */
+        if (type === 'response') {
+          deviceAgent.setInstallationStatus({
+            status: InstallationStatusEnum.IN_PROGRESS,
+          });
+
+          const installationStatusPing = setInterval(
+            () => publishInstallationStatus(installationStatusPing),
+            deviceAgent.getInstallationStatusInterval(),
+          );
+
+          // Install the app with the given url
+          await (async () => {
+            try {
+              await installApp(actionPayload);
+              deviceAgent.setInstallationStatus({
+                status: InstallationStatusEnum.SUCCESS,
+              });
+            } catch (e) {
+              const reason: string = e.message;
+              deviceAgent.setInstallationStatus({
+                status: InstallationStatusEnum.FAILURE,
+                reason,
+              });
+            }
+          })();
+          break;
+        }
+        publishDeviceRequest(actionPayload);
+        break;
+      case 'start':
+        startApp({ projectId: actionPayload.projectId });
+        break;
+      case 'stop':
+        stopApp({ projectId: actionPayload.projectId });
+        break;
+      case 'restart':
+        restartApp({ projectId: actionPayload.projectId });
+        break;
+      /**
+       * Allow/disallow publishing on this device. By default, (publishable = false)
+       */
+      case 'publishable':
+        /**
+          {
+            "action": "publishable",
+            "publishable": true | false
+          }
+         */
+        deviceAgent.setPublishable(actionPayload);
+        deviceAgent.restartPublishableTimeout();
+        break;
+      default:
+        break;
+    }
+  };
+
+  deviceAgent.device.on('connect', function () {
     deviceAgent.publishMessage('connection', deviceAgent.getClientId());
     console.log('Device Agent has connected to the cloud');
   });
 
-  deviceAgent.device.on('disconnect', function() {
+  deviceAgent.device.on('disconnect', function () {
     console.log('Device Agent has been disconnected from the cloud');
   });
 
-  deviceAgent.device.on('message', function(topic, payload) {
-    // TODO: parse/determine action based on topic/payload here
-    console.log('message', topic, payload.toString());
+  deviceAgent.device.on('message', function (topic, payload) {
+    // ToDo: insert valdiation here for incoming messages.  Maybe we will use a JSON schema for the message structure.
+    try {
+      handleMessageTopic({ topic, payload: JSON.parse(payload) });
+    } catch (error) {
+      console.error(error);
+    }
   });
 }

package/src/docker/docker-cmd.ts

@@ -1,4 +1,4 @@
-import { JsSpawner } from '../util/spawner/js-spawner';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 export async function runDockerLogin(props: { token: string }) {
   const { token } = props;

package/src/docker/docker-compose-cmd.ts

@@ -1,4 +1,4 @@
-import { JsSpawner } from '../util/spawner/js-spawner';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 export async function runDockerComposeCmd(props: { args: string[]; dir: string }) {
   const { args, dir } = props;

package/src/environment.ts

@@ -2,6 +2,8 @@ import { platform } from 'os';
 
 export const ALWAYSAI_OS_PLATFORM = parseOsPlatform(process.env.ALWAYSAI_OS_PLATFORM);
 export const ALWAYSAI_SHOW_HIDDEN = parseBoolean(process.env.ALWAYSAI_SHOW_HIDDEN);
+export const ALWAYSAI_DEVICE_AGENT_MODE = process.env.ALWAYSAI_DEVICE_AGENT_MODE;
+export const ALWAYSAI_LOG_LEVEL = process.env.AAI_LOG_LEVEL;
 
 function parseOsPlatform(str: string | undefined): NodeJS.Platform {
   switch (str) {

package/src/index.ts

@@ -1,21 +1,24 @@
 #!/usr/bin/env node
 
-// This file is the entry point for when this package is run as a CLI. Though
-// this file is not executable, the above "shebang" line is necessary as an
-// indicator to npm that this file is a Node.js script, not a shell script e.g.
+/*
+Though this file is not executable, the above "shebang" line is necessary as an
+indicator to npm that this file is a Node.js script, not a shell script e.g.
+*/
 
 import { runCliAndExit } from '@alwaysai/alwayscli';
 import { root } from './root';
-import { runWebInterface } from './web/web-interface';
 import { runDeviceAgentCloudInterface } from './cloud-connection/device-agent-cloud-connection';
+import { AgentConfigFile } from './infrastructure/agent-config';
+import { ALWAYSAI_DEVICE_AGENT_MODE } from './environment';
 
 if (module === require.main) {
   console.log('Starting alwaysAI Device Agent');
+  if (!AgentConfigFile().exists()) {
+    AgentConfigFile().initialize();
+  }
 
-  if (process.env.ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
+  if (ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
     runDeviceAgentCloudInterface();
-  } else if (process.env.ALWAYSAI_DEVICE_AGENT_MODE === 'web') {
-    runWebInterface();
   } else {
     runCliAndExit(root, {});
   }

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

@@ -0,0 +1,143 @@
+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', () => {
+  beforeEach(() => {
+    configFile.remove();
+    configFile.initialize();
+  });
+  describe('Test applications', () => {
+    test('Commands with no apps', async () => {
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([]);
+      const app = await configFile.getApp({ projectId: 'wrong-id' });
+      expect(app).toBeNull();
+      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      expect(present).toBeFalsy();
+      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Indicate app installation in progress', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: false,
+        },
+      ]);
+      const readyApps = await configFile.getReadyApps();
+      expect(readyApps).toEqual([]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: false,
+      });
+      const present = await configFile.isAppPresent({ projectId });
+      expect(present).toBeTruthy();
+      const ready = await configFile.isAppReady({ projectId });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Indicate app installation complete', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+        },
+      ]);
+      const readyApps = await configFile.getReadyApps();
+      expect(readyApps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+        },
+      ]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: true,
+      });
+      const appVersion = await configFile.getAppVersion({ projectId });
+      expect(appVersion).toEqual(version);
+      const present = await configFile.isAppPresent({ projectId });
+      expect(present).toBeTruthy();
+      const ready = await configFile.isAppReady({ projectId });
+      expect(ready).toBeTruthy();
+    });
+
+    test('Indicate app uninstalled', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      await configFile.setAppUninstalled({ projectId });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([]);
+      const app = await configFile.getApp({ projectId: 'wrong-id' });
+      expect(app).toBeNull();
+      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      expect(present).toBeFalsy();
+      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Set and get backup', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      const backup1 = await configFile.getAppBackup({ projectId });
+      expect(backup1).toBeNull();
+      await configFile.setAppBackup({ projectId });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+          backup: {
+            version,
+          },
+        },
+      ]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: true,
+        backup: {
+          version,
+        },
+      });
+      const backup2 = await configFile.getAppBackup({ projectId });
+      expect(backup2).toEqual({ version });
+    });
+  });
+});