@alwaysai/device-agent 1.4.0 → 2.0.0

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

@@ -1,14 +1,23 @@
-// eslint-disable-next-line
-const amqp = require('amqplib');
+import {
+  DeviceAgentStatusShadowUpdate,
+  PassthroughStatusValue
+} from '@alwaysai/device-agent-schemas/lib/shadow-schema';
+import { stringifyError } from 'alwaysai/lib/util';
+import * as amqp from 'amqplib';
+import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
 import {
   LOCAL_CONNECTION_HOST,
   LOCAL_CONNECTION_PORT,
   LOCAL_CONNECTION_ROUTING_KEY
 } from '../local-connection/constants';
-import { setupRabbitMQContainer } from '../local-connection/rabbitmq-connection';
+import {
+  setupRabbitMQContainer,
+  stopRabbitMQContainer
+} from '../local-connection/rabbitmq-connection';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
+import { ShadowHandler } from './shadow-handler';
 
 const messageQueue: any[] = [];
 const ackQueue: any[] = [];
@@ -16,21 +25,90 @@ const MAX_LOCAL_CONNECTION_ATTEMPTS = 10;
 
 export class PassthroughHandler {
   public publisher: Publisher;
-  public connection;
-  public channel;
+  public shadowHandler: ShadowHandler;
+  public connection: amqp.Connection | undefined;
+  public channel: amqp.Channel;
   public packetQueue;
 
-  constructor(publisher: Publisher) {
+  constructor(publisher: Publisher, shadowHandler: ShadowHandler) {
     this.publisher = publisher;
+    this.shadowHandler = shadowHandler;
   }
 
-  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!\n${stringifyError(
+                  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 +118,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 +138,58 @@ 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;
-    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}`
-        );
+  private async publishPassthroughStatusUpdate(
+    status: PassthroughStatusValue,
+    message?: string
+  ) {
+    const deviceAgentPassthroughStatus: DeviceAgentStatusShadowUpdate = {
+      passthrough: {
+        status: status,
+        message: message ?? ''
       }
-    } catch (e) {
-      logger.error(`There was a problem parsing RabbitMQ packet ${e}`);
-      passthroughHandler.channel.ack(msg);
-      logger.debug(`Problematic packet was acknowledged`);
-    }
+    };
+    await this.shadowHandler.updateDeviceAgentStatusShadow(
+      deviceAgentPassthroughStatus
+    );
   }
-}
 
-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);
+  async setup() {
+    if (ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
+      logger.debug(
+        `Setting up alwaysAI Local Connection on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
+      );
+      await this.publishPassthroughStatusUpdate('starting');
+      await setupRabbitMQContainer();
+      try {
+        await this.establishLocalConnection();
+        await this.runChannel();
+        await this.publishPassthroughStatusUpdate(
+          'running',
+          `Passthrough running on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
+        );
+      } catch (e) {
+        logger.error(
+          `There was a problem maintaining RabbitMQ connection!\n${stringifyError(
+            e
+          )}`
+        );
+        await this.publishPassthroughStatusUpdate('error', stringifyError(e));
       }
-    },
-    {
-      noAck: false // When true, RabbitMQ deletes message as soon as it is consumed
+    } else {
+      await this.publishPassthroughStatusUpdate('disabled');
     }
-  );
+  }
 }

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

@@ -68,13 +68,11 @@ describe('Test Shadow Handler', () => {
 
   test('handle project shadow empty delta', async () => {
     const payload = {
-      desired: {
-        [projectId1]: {}
-      }
+      [projectId1]: {}
     };
 
     const updates = await shadowHandler.handleProjectShadow({
-      topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+      topic: getShadowTopic(clientId, 'projects', 'update/delta'),
       payload,
       clientToken: ''
     });
@@ -104,16 +102,14 @@ describe('Test Shadow Handler', () => {
 
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              appConfig: JSON.stringify(appCfg1)
-            }
+          [projectId1]: {
+            appConfig: JSON.stringify(appCfg1)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -153,16 +149,14 @@ describe('Test Shadow Handler', () => {
 
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              appConfig: JSON.stringify(appCfg1)
-            }
+          [projectId1]: {
+            appConfig: JSON.stringify(appCfg1)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -220,19 +214,17 @@ describe('Test Shadow Handler', () => {
       };
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              appConfig: JSON.stringify(appCfg1)
-            },
-            [projectId2]: {
-              appConfig: JSON.stringify(appCfg2)
-            }
+          [projectId1]: {
+            appConfig: JSON.stringify(appCfg1)
+          },
+          [projectId2]: {
+            appConfig: JSON.stringify(appCfg2)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -281,16 +273,14 @@ describe('Test Shadow Handler', () => {
 
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              appConfig: JSON.stringify(appCfg1)
-            }
+          [projectId1]: {
+            appConfig: JSON.stringify(appCfg1)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -365,10 +355,8 @@ describe('Test Shadow Handler', () => {
 
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              appConfig: appCfg1 // This is missing JSON.stringify() making this an unparsable object.
-            }
+          [projectId1]: {
+            appConfig: appCfg1 // This is missing JSON.stringify() making this an unparsable object.
           }
         }
       };
@@ -378,7 +366,7 @@ describe('Test Shadow Handler', () => {
         .mockReturnValue({} as unknown as Logger);
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -393,13 +381,15 @@ describe('Test Shadow Handler', () => {
   describe('handle project shadow env vars', () => {
     test('handle a response from the getAccepted from the cloud', async () => {
       const envVars1 = {
-        VAR0: 'value0'
+        service: {
+          VAR0: 'value0'
+        }
       };
       const payload = {
         state: {
           reported: {
             [projectId1]: {
-              envVars: { service: envVars1 }
+              envVars: JSON.stringify(envVars1)
             }
           }
         }
@@ -414,22 +404,20 @@ describe('Test Shadow Handler', () => {
     });
     test('handle project shadow env vars update delta', async () => {
       const envVars1 = {
-        VAR1: 'value1'
+        service: {
+          VAR1: 'value1'
+        }
       };
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              envVars: {
-                service: envVars1
-              }
-            }
+          [projectId1]: {
+            envVars: JSON.stringify(envVars1)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -438,36 +426,36 @@ describe('Test Shadow Handler', () => {
         projectId: projectId1,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: { service: envVars1 }
+          envVars: envVars1
         }
       });
     });
 
     test('handle project shadow env vars update delta for two projects', async () => {
       const service1 = {
-        VAR1: 'value1'
+        service: {
+          VAR1: 'value1'
+        }
       };
       const service2 = {
-        VAR2: 'value2'
+        service: {
+          VAR2: 'value2'
+        }
       };
 
       const payload = {
         state: {
-          desired: {
-            [projectId1]: {
-              envVars: {
-                service: service1
-              }
-            },
-            [projectId2]: {
-              envVars: { service: service2 }
-            }
+          [projectId1]: {
+            envVars: JSON.stringify(service1)
+          },
+          [projectId2]: {
+            envVars: JSON.stringify(service2)
           }
         }
       };
 
       const updates = await shadowHandler.handleProjectShadow({
-        topic: getShadowTopic(clientId, 'projects', 'update/accepted'),
+        topic: getShadowTopic(clientId, 'projects', 'update/delta'),
         payload,
         clientToken: ''
       });
@@ -476,14 +464,14 @@ describe('Test Shadow Handler', () => {
         projectId: projectId1,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: { service: service1 }
+          envVars: service1
         }
       });
       expect(updates[1]).toEqual({
         projectId: projectId2,
         txId: expect.any(String),
         envVarUpdate: {
-          envVars: { service: service2 }
+          envVars: service2
         }
       });
     });