@alwaysai/device-agent 2.0.0 → 2.0.2-0

package/src/jobs/job-handler.ts

@@ -0,0 +1,146 @@
+import { MessageHandler } from '../cloud-connection/message-dispatcher';
+import { logger } from '../util/logger';
+import {
+  BaseHandler,
+  HandlerContext
+} from '../cloud-connection/base-message-handler';
+import { DeviceAgentMessageHandler } from '../cloud-connection/device-agent-message-handler';
+
+class JobState {
+  private static instance: JobState;
+  public jobInProgress = false;
+
+  // Singleton pattern
+  private constructor() { } // eslint-disable-line
+
+  static getInstance(): JobState {
+    if (!JobState.instance) {
+      JobState.instance = new JobState();
+    }
+    return JobState.instance;
+  }
+}
+
+export class JobHandler extends BaseHandler implements MessageHandler {
+  private readonly msgHandler: DeviceAgentMessageHandler;
+
+  constructor(handlerContext: HandlerContext) {
+    super(handlerContext);
+    this.msgHandler = new DeviceAgentMessageHandler(
+      handlerContext,
+      this.handleJobError,
+      this.handleJobSuccess
+    );
+  }
+  private readonly state = JobState.getInstance();
+  private jobId = '';
+
+  public async handle(message: any, topic: string): Promise<void> {
+    const TOPICS = this.getJobTopic();
+
+    try {
+      switch (topic) {
+        case TOPICS.NOTIFY_NEXT:
+          await this.notifyNext(message);
+          break;
+        case TOPICS.START_NEXT_ACCEPTED:
+          this.startNextAccepted(message);
+          break;
+        default:
+          logger.info(`No handler for topic: ${topic}`);
+      }
+    } catch (error) {
+      logger.error(`Error handling job for topic: ${topic}`, error);
+    }
+  }
+
+  getJobTopic() {
+    const TOPICS = {
+      NOTIFY_NEXT: `$aws/things/${this.clientId}/jobs/notify-next`,
+      START_NEXT: `$aws/things/${this.clientId}/jobs/start-next`,
+      START_NEXT_ACCEPTED: `$aws/things/${this.clientId}/jobs/start-next/accepted`,
+      UPDATE: `$aws/things/${this.clientId}/jobs/${this.jobId}/update`
+    };
+    return TOPICS;
+  }
+
+  private async notifyNext(message: any): Promise<void> {
+    // Triggers when a job is completed and we need to notify the next job
+    logger.info('Invoking NOTIFY_NEXT handler');
+    const TOPICS = this.getJobTopic();
+    this.publisher.publish(TOPICS.START_NEXT, JSON.stringify({}));
+  }
+
+  private startNextAccepted(message: any): void {
+    if (this.state.jobInProgress) {
+      logger.info('Job already in progress');
+      return;
+    }
+
+    this.state.jobInProgress = true;
+
+    try {
+      if (message.execution) {
+        this.processJobExecution(message.execution);
+      } else {
+        this.state.jobInProgress = false;
+      }
+    } catch (error: unknown) {
+      this.handleError(error);
+    }
+    this.state.jobInProgress = false;
+  }
+
+  private processJobExecution(execution: any): void {
+    logger.info('Job in progress...');
+    const { jobDocument, jobId } = execution;
+    this.jobId = jobId;
+    this.msgHandler.handle(jobDocument);
+  }
+
+  private handleError(error: unknown): void {
+    if (error instanceof Error) {
+      logger.error(`Error starting next job`, error);
+      this.handleJobError('', error.message);
+    } else {
+      let errorMessage: string;
+      if (typeof error === 'string') {
+        errorMessage = error;
+      } else if (typeof error === 'object' && error !== null) {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch (jsonError) {
+          errorMessage = 'Unknown error (failed to stringify)';
+        }
+      } else {
+        errorMessage = 'Unknown error';
+      }
+      logger.error(`Unexpected error: ${errorMessage}`);
+      this.handleJobError('', errorMessage);
+    }
+  }
+
+  private updateJobStatus(status: string, message?: string): void {
+    const { UPDATE } = this.getJobTopic();
+    const payload = {
+      status,
+      statusDetails: {
+        message
+      }
+    };
+
+    this.publisher.publish(UPDATE, JSON.stringify(payload));
+    logger.info(`Marked job ${this.jobId} as ${status}`);
+    // Reset the job state
+    this.state.jobInProgress = false;
+  }
+
+  private readonly handleJobSuccess = (txId: string): void => {
+    this.updateJobStatus('SUCCEEDED');
+  };
+
+  private readonly handleJobError = (_txId: string, msg: string): void => {
+    logger.error(`Unexpected error type: ${msg}`);
+    this.updateJobStatus('FAILED', `Unexpected error: ${msg}`);
+  };
+}

package/src/secure-tunneling/secure-tunnel-message-handler.ts

@@ -0,0 +1,56 @@
+import {
+  getUpdateDeltaStateFromMessage,
+  validateSecureTunnelShadowUpdate
+} from '@alwaysai/device-agent-schemas';
+import { MessageHandler } from '../cloud-connection/message-dispatcher';
+import { logger } from '../util/logger';
+import { BaseHandler } from '../cloud-connection/base-message-handler';
+
+export class SecureTunnelMessageHandler
+  extends BaseHandler
+  implements MessageHandler<any>
+{
+  public getNotifyTopic(): string {
+    return `$aws/things/${this.clientId}/tunnels/notify`;
+  }
+
+  public async handle(message: any, topic: string): Promise<void> {
+    const secureTunnelNotifyTopic = this.getNotifyTopic();
+    if (topic === secureTunnelNotifyTopic) {
+      await this.secureTunnelHandler.secureTunnelNotifyHandler(message);
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.updateDelta
+    ) {
+      logger.info(`Received secure tunnel update: ${JSON.stringify(message)}`);
+      await this.handleSecureTunnelMessage(message);
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted
+    ) {
+      logger.info(`Received secure tunnel deleteAccepted: ${message}`);
+      await this.secureTunnelHandler.destroy();
+    }
+  }
+
+  public async handleSecureTunnelMessage(payload: any): Promise<void> {
+    logger.info(`Received secure tunnel update: ${JSON.stringify(payload)}`);
+    const state = getUpdateDeltaStateFromMessage(payload);
+    if (!state) {
+      logger.debug(`No state found in message: ${JSON.stringify(payload)}`);
+      return;
+    }
+    const valid = validateSecureTunnelShadowUpdate(state);
+    if (!valid) {
+      logger.error(
+        `Error validating message: ${JSON.stringify(
+          { payload, errors: validateSecureTunnelShadowUpdate.errors },
+          null,
+          2
+        )}`
+      );
+      return;
+    }
+    const secureTunnelUpdate =
+      await this.secureTunnelHandler.syncShadowToDeviceState(payload);
+    await this.shadowHandler.updateSecureTunnelShadow(secureTunnelUpdate);
+  }
+}

package/src/subcommands/app/version.ts

@@ -37,10 +37,26 @@ export const installAppCliLeaf = CliLeaf({
       description: 'Release Hash',
       required: false,
       hidden: true
+    }),
+    appCfg: CliStringInput({
+      description: 'Application Configuration',
+      required: false,
+      hidden: true
+    }),
+    envVars: CliStringInput({
+      description: 'Environment Variables configuration',
+      hidden: true,
+      required: false
     })
   },
   async action(_, opts) {
-    const { project, releaseHash, 'release-hash': releaseHashNew } = opts;
+    const {
+      project,
+      releaseHash,
+      'release-hash': releaseHashNew,
+      appCfg,
+      envVars
+    } = opts;
     if (releaseHash) {
       logger.warn(
         `--releaseHash is deprecated and will be removed in a future release. Please switch to --release-hash`
@@ -60,7 +76,9 @@ export const installAppCliLeaf = CliLeaf({
       payload: {
         baseCommand: keyMirrors.appVersionControl.install,
         projectId: project,
-        appReleaseHash: releaseHashResolved
+        appReleaseHash: releaseHashResolved,
+        appCfg,
+        envVars
       }
     };
     await deviceAgent.handleMessage(topic, message);