@alwaysai/device-agent 2.0.0 → 2.0.2-0

package/lib/cloud-connection/device-agent-cloud-connection.js

@@ -1,180 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeviceAgentCloudInterface = exports.DeviceAgentCloudConnection = void 0;
-// eslint-disable-next-line
-const awsIot = require('aws-iot-device-sdk');
 const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
-const infrastructure_1 = require("alwaysai/lib/infrastructure");
-const util_1 = require("alwaysai/lib/util");
-const child_process_1 = require("child_process");
 const fs_1 = require("fs");
-const util_2 = require("util");
-const application_control_1 = require("../application-control");
-const backup_1 = require("../application-control/backup");
-const models_1 = require("../application-control/models");
-const device_control_1 = require("../device-control/device-control");
 const environment_1 = require("../environment");
-const agent_config_1 = require("../infrastructure/agent-config");
 const device_certificate_1 = require("../infrastructure/device-certificate");
 const legacy_migration_1 = require("../infrastructure/legacy-migration/legacy-migration");
 const required_config_checks_1 = require("../infrastructure/required-config-checks");
 const urls_1 = require("../infrastructure/urls");
 const secure_tunneling_1 = require("../secure-tunneling/secure-tunneling");
-const aai_error_1 = require("../util/aai-error");
+const secure_tunnel_message_handler_1 = require("../secure-tunneling/secure-tunnel-message-handler");
 const check_for_updates_1 = require("../util/check-for-updates");
-const directories_1 = require("../util/directories");
 const get_device_id_1 = require("../util/get-device-id");
 const logger_1 = require("../util/logger");
 const sleep_1 = require("../util/sleep");
 const bootstrap_provision_1 = require("./bootstrap-provision");
 const live_updates_handler_1 = require("./live-updates-handler");
-const messages_1 = require("./messages");
 const passthrough_handler_1 = require("./passthrough-handler");
 const publisher_1 = require("./publisher");
 const shadow_handler_1 = require("./shadow-handler");
+const job_handler_1 = require("../jobs/job-handler");
 const transaction_manager_1 = require("./transaction-manager");
-const exec_promise = (0, util_2.promisify)(child_process_1.exec);
+const connection_manager_1 = require("./connection-manager");
+const device_agent_message_handler_1 = require("./device-agent-message-handler");
 class DeviceAgentCloudConnection {
     constructor() {
-        this.device = awsIot.device;
         this.clientId = (0, get_device_id_1.getDeviceUuid)();
         this.host = (0, urls_1.getIoTCoreEndpointUrl)();
         this.port = 8883;
         this.toDeviceTopic = (0, device_agent_schemas_1.getToDeviceTopic)(this.clientId);
-        this.secureTunnelNotifyTopic = `$aws/things/${this.clientId}/tunnels/notify`;
         this.secureTunnelHandler = secure_tunneling_1.SecureTunnelHandlerSingleton.getInstance();
-        this.handleAppStateControl = async (payload) => {
-            const { baseCommand, projectId } = payload;
-            switch (baseCommand) {
-                case device_agent_schemas_1.keyMirrors.appStateControl.start:
-                    await (0, application_control_1.startApp)({ projectId });
-                    break;
-                case device_agent_schemas_1.keyMirrors.appStateControl.stop:
-                    await (0, application_control_1.stopApp)({ projectId });
-                    break;
-                case device_agent_schemas_1.keyMirrors.appStateControl.restart:
-                    await (0, application_control_1.restartApp)({ projectId });
-                    break;
-            }
-            return true;
-        };
-        this.handleAppVersionControl = async (payload, txId) => {
-            switch (payload.baseCommand) {
-                case device_agent_schemas_1.keyMirrors.appVersionControl.install: {
-                    const { projectId, appReleaseHash } = payload;
-                    const signedUrlsRequestPayload = {
-                        signedUrlsRequest: {
-                            projectId,
-                            appReleaseHash
-                        }
-                    };
-                    const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, signedUrlsRequestPayload, txId);
-                    await this.publishCloudRequest(message);
-                    return false;
-                }
-                case device_agent_schemas_1.keyMirrors.appVersionControl.uninstall: {
-                    const { projectId } = payload;
-                    await this.atomicApplicationUninstall(projectId);
-                    return true;
-                }
-                default:
-                    logger_1.logger.warn(`Ignore App Version Control packet: ${JSON.stringify(payload, null, 2)}`);
-                    return true;
-            }
-        };
-        this.handleAppInstallCloudResponsePayload = async (payload) => {
-            const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } = payload.appInstallResponse;
-            const signedUrlsPayload = {
-                appInstallPayload,
-                modelsInstallPayload
-            };
-            await this.atomicApplicationUpdate(async () => {
-                this.shadowHandler.clearProjectShadow(projectId);
-                await (0, application_control_1.installApp)({ projectId, appReleaseHash, signedUrlsPayload });
-            }, projectId);
-            return true;
-        };
-        this.handleModelsInstallCloudResponsePayload = async (payload, txId) => {
-            const projectId = payload.modelsInstallResponse.projectId;
-            const update = this.txnMgr.getAppCfgUpdateFromTxID(txId);
-            if (update === undefined) {
-                throw new Error('Unknown error while updating models via application config! No config present for model update.');
-            }
-            const { appCfgUpdate, envVarUpdate } = update;
-            if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(async () => await (0, application_control_1.updateModelsWithPresignedUrls)({
-                    projectId,
-                    modelInstallPayloads: payload.modelsInstallResponse.newModels,
-                    newAppCfg: appCfgUpdate.newAppCfg
-                }), projectId);
-            }
-            if (envVarUpdate) {
-                await this.atomicApplicationUpdate(async () => await this.shadowHandler.updateProjectEnvVars({
-                    projectId,
-                    envVars: envVarUpdate.envVars
-                }), projectId, true);
-            }
-            return true;
-        };
-        this.handleProjectShadowConfigUpdate = async (update, txId) => {
-            const { projectId, appCfgUpdate, envVarUpdate } = update;
-            if ((appCfgUpdate === null || appCfgUpdate === void 0 ? void 0 : appCfgUpdate.updatedModels) &&
-                Object.keys(appCfgUpdate.updatedModels).length) {
-                // When there are model updates request signed URLs and wait to apply config changes
-                const { updatedModels } = appCfgUpdate;
-                logger_1.logger.debug(`Requesting presigned urls from cloud for model versions: ${JSON.stringify(updatedModels)}`);
-                const modelsOnlyUrlsRequestPayload = {
-                    modelsOnlyUrlsRequest: {
-                        projectId,
-                        models: updatedModels
-                    }
-                };
-                const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, modelsOnlyUrlsRequestPayload, txId);
-                this.publisher.publishToCloud(message);
-                this.txnMgr.setAppCfgUpdateToTx(txId, update);
-                return false;
-            }
-            if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(async () => {
-                    await (0, models_1.pruneModels)({
-                        projectId,
-                        appCfg: appCfgUpdate.newAppCfg
-                    });
-                    await (0, application_control_1.updateAppCfg)({
-                        projectId,
-                        newAppCfg: appCfgUpdate.newAppCfg
-                    });
-                }, projectId);
-            }
-            if (envVarUpdate) {
-                await this.atomicApplicationUpdate(async () => await this.shadowHandler.updateProjectEnvVars({
-                    projectId,
-                    envVars: envVarUpdate.envVars
-                }), projectId, true);
-            }
-            return true;
-        };
-        this.device = awsIot.device({
-            keyPath: infrastructure_1.DEVICE_PRIVATE_KEY_FILE_PATH,
-            certPath: infrastructure_1.DEVICE_CERTIFICATE_FILE_PATH,
-            caPath: directories_1.AWS_ROOT_CERTIFICATE_FILE_PATH,
+        this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler();
+        // Initialize & setup the connection
+        this.connectionManager = new connection_manager_1.ConnectionManager(this.clientId, this.host, this.port);
+        this.publisher = new publisher_1.Publisher(this.connectionManager, this.clientId);
+        this.shadowHandler = new shadow_handler_1.ShadowHandler(this.clientId, this.publisher);
+        this.connectionManager.connect(() => {
+            void this.shadowHandler.initShadows();
+            this.publisher.publish(JOB_HANDLER_TOPICS.START_NEXT, JSON.stringify({}));
+        });
+        this.transactionManager = new transaction_manager_1.TransactionManager(this.liveUpdatesHandler);
+        // Construct a HandlerContext used by all the message handlers
+        const handlerContext = {
             clientId: this.clientId,
-            host: this.host,
-            port: this.port,
-            keepalive: 10 // time before re-connect attempt on dropped connection, default is 400 seconds
+            txnMgr: this.transactionManager,
+            publisher: this.publisher,
+            shadowHandler: this.shadowHandler,
+            liveUpdatesHandler: this.liveUpdatesHandler,
+            secureTunnelHandler: this.secureTunnelHandler
+        };
+        // Instantiate & register message handlers for Project Shadow topics
+        const projectShadowMessageHandler = new shadow_handler_1.ProjectShadowMessageHandler(handlerContext);
+        this.shadowHandler.projectShadowTopics.forEach((topic) => {
+            this.connectionManager.registerHandler(topic, projectShadowMessageHandler);
         });
-        this.publisher = new publisher_1.Publisher(this.device, this.clientId);
-        this.shadowHandler = new shadow_handler_1.ShadowHandler(this.clientId, this.publisher);
-        this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler();
-        this.txnMgr = new transaction_manager_1.TransactionManager(this.publisher, this.liveUpdatesHandler);
-        this.subscribe(this.toDeviceTopic);
-        this.subscribe(this.secureTunnelNotifyTopic);
-        for (const topic of this.shadowHandler.projectShadowTopics) {
-            this.subscribe(topic);
-        }
-        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.updateDelta);
-        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted);
-        this.setupHandlers();
+        // Instantiate & register message handlers for to-device and secureTunnel topics
+        this.connectionManager.registerHandler(this.toDeviceTopic, new device_agent_message_handler_1.DeviceAgentMessageHandler(handlerContext, (txId, errorMsg) => {
+            const msg = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.publisher.getClientId(), {
+                status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
+                message: errorMsg
+            }, txId);
+            this.publisher.publishToClient(msg);
+        }, (txId) => {
+            const msg = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.publisher.getClientId(), { status: device_agent_schemas_1.keyMirrors.statusResponse.success }, txId);
+            this.publisher.publishToClient(msg);
+        }));
+        const secureTunnelMessageHandler = new secure_tunnel_message_handler_1.SecureTunnelMessageHandler(handlerContext);
+        this.connectionManager.registerHandler(secureTunnelMessageHandler.getNotifyTopic(), secureTunnelMessageHandler);
+        this.connectionManager.registerHandler(this.shadowHandler.shadowTopics.secureTunnel.updateDelta, secureTunnelMessageHandler);
+        this.connectionManager.registerHandler(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted, secureTunnelMessageHandler);
+        const jobHandler = new job_handler_1.JobHandler(handlerContext);
+        const JOB_HANDLER_TOPICS = jobHandler.getJobTopic();
+        this.connectionManager.registerHandler(JOB_HANDLER_TOPICS.NOTIFY_NEXT, jobHandler);
+        this.connectionManager.registerHandler(JOB_HANDLER_TOPICS.START_NEXT_ACCEPTED, jobHandler);
     }
     /*=================================================================
                               Public interface
@@ -183,383 +81,17 @@ class DeviceAgentCloudConnection {
         return this.clientId;
     }
     isCmdInProgress(projectId) {
-        return this.txnMgr.isOngoingTransactionForProjectID(projectId);
-    }
-    async handleMessage(topic, message) {
-        logger_1.logger.debug(`Received message: ${JSON.stringify({ topic, message }, null, 2)}`);
-        // ProjectShadow messages
-        if (this.shadowHandler.projectShadowTopics.includes(topic)) {
-            await this.handleProjectShadowMessage(topic, message);
-        }
-        else if (topic === this.toDeviceTopic) {
-            await this.handleDeviceAgentMessage({
-                topic,
-                message
-            });
-            // SecureTunnelNotify messages
-        }
-        else if (topic === this.secureTunnelNotifyTopic) {
-            await this.secureTunnelHandler.secureTunnelNotifyHandler(message);
-            // SecureTunnel messages
-        }
-        else if (topic === this.shadowHandler.shadowTopics.secureTunnel.updateDelta) {
-            await this.handleSecureTunnelMessage(message);
-        }
-        else if (topic === this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted) {
-            logger_1.logger.info(`Received secure tunnel deleteAccepted: ${message}`);
-            await this.secureTunnelHandler.destroy();
-        }
-        else {
-            logger_1.logger.error(`Unexpected topic, ignoring! ${topic}`);
-        }
+        return this.transactionManager.isOngoingTransactionForProjectID(projectId);
     }
     async stop() {
         // This method is currently only used by the CLI, and shadow messages can be
         // lost since we aren't waiting for responses so sleep for a short time to
         // receive them
         await (0, sleep_1.default)(1000);
-        this.device.end();
-    }
-    /*=================================================================
-                              Private interface
-    =================================================================*/
-    setupHandlers() {
-        this.device.on('connect', (connack) => {
-            logger_1.logger.info('Device Agent has connected to the cloud');
-            // FIXME: EI-709 Skip this request for now to prevent kicking off another
-            // shadow update process if IoT Core disconnect occurs during app config update
-            //this.shadowHandler.getShadowUpdates();
-            void this.shadowHandler.updateSystemInfoShadow();
-        });
-        this.device.on('disconnect', () => {
-            logger_1.logger.warn('Device Agent has been disconnected from the cloud');
-        });
-        this.device.on('reconnect', () => {
-            logger_1.logger.info(`Device Agent attempting to re-connect ${new Date().toLocaleString()}`);
-        });
-        this.device.on('error', function (e) {
-            logger_1.logger.error(`Error connecting to cloud!\n${(0, util_1.stringifyError)(e)}`);
-        });
-        this.device.on('message', async (topic, payload) => {
-            try {
-                const jsonPacket = JSON.parse(payload);
-                await this.handleMessage(topic, jsonPacket);
-            }
-            catch (e) {
-                logger_1.logger.error(`Error parsing message!\n${(0, util_1.stringifyError)(e)}`);
-            }
-        });
-        this.device.on('offline', () => {
-            logger_1.logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
-            void this.logConnectionInfo();
-        });
-    }
-    async logConnectionInfo() {
-        try {
-            /**
-             * We're using the 'netcat' or 'nc' command to test the connection to the IoT Core endpoint.
-             * This command doesn't always exit (see below), so
-             * we use timeout to break out of the prompt
-             * and catch the resulting error/parse the resulting stderr
-             *
-             * Sample command for current host and port:
-             * nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
-             *
-             * Sample output when port is not blocked and host is reachable:
-             * $ nc  -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443
-             * Connection to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443 port [tcp/https] succeeded!
-             *
-             *
-             * Sample output when port is blocked (will repeatedly try until ctrl-C out):
-             * $ nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * ^C
-             *
-             *
-             * Sample command/output when the port isn't enable on that host:
-             * $ nc -zv -w 1 localhost 8883
-             * nc: connect to localhost port 8883 (tcp) failed: Connection refused
-             */
-            await exec_promise(`nc -zv -w 1 ${this.host} ${this.port}`, {
-                timeout: 2000
-            });
-        }
-        catch (err) {
-            const output = JSON.stringify(err['stderr']);
-            if (output.indexOf('not known') !== -1) {
-                logger_1.logger.warn('Iot Core endpoint appears to be unreachable, internet connection may be unstable or the host may be down.');
-            }
-            else if (output.indexOf('timed out') !== -1) {
-                logger_1.logger.warn(`Internet connection appears fine, however the endpoint was not reachable on the current connection port: ${this.port}\nPlease check if a firewall is in place.`);
-            }
-            else if (output.indexOf('refused') !== -1) {
-                logger_1.logger.warn(`The connection was refused, likely ${this.host} is not running a service on ${this.port}.`);
-            }
-            else {
-                logger_1.logger.warn(`Output from checking connection to ${this.host} on ${this.port}: ${output}`);
-            }
-        }
-    }
-    async handleDeviceAgentMessage({ topic, message }) {
-        const valid = (0, device_agent_schemas_1.validateToDeviceAgentMessage)(message);
-        if (!valid) {
-            logger_1.logger.error(`Error validating message: ${JSON.stringify({ topic, message, errors: device_agent_schemas_1.validateToDeviceAgentMessage.errors }, null, 2)}`);
-            // TODO: Send generic error response
-            return;
-        }
-        const txId = message.txId;
-        const { app_state_control, app_version_control, live_state_updates, app_install_response, models_install_response, status_response, device_action } = device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType;
-        switch (message.messageType) {
-            case app_state_control: {
-                // txId sent from cloud, just need to continue it
-                const payload = message.payload;
-                const projectId = payload.projectId;
-                try {
-                    await this.txnMgr.runTransactionStep({
-                        func: () => this.handleAppStateControl(message.payload),
-                        projectId,
-                        txId,
-                        start: true,
-                        liveUpdatesPublishFn: async () => this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, { status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress }, txId), logger_1.logger.silly),
-                        stepName: payload.baseCommand
-                    });
-                }
-                catch (e) {
-                    logger_1.logger.error(`Error processing application state control request for ${projectId}!\n${(0, util_1.stringifyError)(e)}`);
-                }
-                break;
-            }
-            case app_version_control: {
-                // txId sent from cloud, just need to continue it
-                const payload = message.payload;
-                const projectId = payload.projectId;
-                try {
-                    await this.txnMgr.runTransactionStep({
-                        func: () => this.handleAppVersionControl(payload, txId),
-                        projectId,
-                        txId,
-                        start: true,
-                        liveUpdatesPublishFn: async () => this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, { status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress }, txId), logger_1.logger.silly),
-                        stepName: payload.baseCommand
-                    });
-                }
-                catch (e) {
-                    logger_1.logger.error(`Error processing application install request for ${projectId}!\n${(0, util_1.stringifyError)(e)}`);
-                }
-                break;
-            }
-            case live_state_updates: {
-                const { deviceStats, appState, appLogs } = message.payload;
-                if (deviceStats !== undefined) {
-                    if (deviceStats) {
-                        await this.liveUpdatesHandler.enable(device_agent_schemas_1.keyMirrors.toClientMessageType.device_stats, async () => this.publisher.publishToClient((0, device_agent_schemas_1.buildDeviceStatsMessage)(this.clientId, await (0, messages_1.getDeviceStatsPayload)(), txId), logger_1.logger.silly));
-                    }
-                    else {
-                        this.liveUpdatesHandler.disable(device_agent_schemas_1.keyMirrors.toClientMessageType.device_stats);
-                    }
-                }
-                if (appState !== undefined) {
-                    if (appState) {
-                        await this.liveUpdatesHandler.enable(device_agent_schemas_1.keyMirrors.toClientMessageType.app_state, async () => this.publisher.publishToClient((0, device_agent_schemas_1.buildAppStateMessage)(this.clientId, await (0, messages_1.getAppStatePayload)(), txId), logger_1.logger.silly));
-                    }
-                    else {
-                        this.liveUpdatesHandler.disable(device_agent_schemas_1.keyMirrors.toClientMessageType.app_state);
-                    }
-                }
-                if (appLogs !== undefined) {
-                    if (appLogs.toggle) {
-                        await this.liveUpdatesHandler.startStream(appLogs.projectId, async () => await (0, application_control_1.getAppLogs)({
-                            projectId: appLogs.projectId,
-                            args: ['--tail', '100', '--no-log-prefix']
-                        }), async (logChunk) => this.publisher.publishToClient((0, device_agent_schemas_1.buildAppLogsMessage)(this.clientId, {
-                            projectId: appLogs.projectId,
-                            logChunk
-                        }, txId), logger_1.logger.silly));
-                    }
-                    else {
-                        this.liveUpdatesHandler.stopStream(appLogs.projectId);
-                    }
-                }
-                break;
-            }
-            case app_install_response: {
-                const payload = message.payload;
-                const { projectId } = payload.appInstallResponse;
-                if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
-                    throw new Error(`App install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(projectId)})!`);
-                }
-                await this.txnMgr.runTransactionStep({
-                    func: () => this.handleAppInstallCloudResponsePayload(payload),
-                    projectId,
-                    txId,
-                    start: false,
-                    stepName: message.messageType
-                });
-                break;
-            }
-            case models_install_response: {
-                // This message doesn't have appReleaseHash in it's payload, but
-                // atomicCmd should be able to read it from the installed app
-                const payload = message.payload;
-                const { projectId } = payload.modelsInstallResponse;
-                if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
-                    throw new Error(`Model install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(projectId)})!`);
-                }
-                await this.txnMgr.runTransactionStep({
-                    func: () => this.handleModelsInstallCloudResponsePayload(payload, txId),
-                    projectId,
-                    txId,
-                    start: false,
-                    stepName: message.messageType
-                });
-                break;
-            }
-            case status_response: {
-                const { failure } = device_agent_schemas_1.keyMirrors.statusResponse;
-                if (message.payload.status === failure) {
-                    this.txnMgr.completeTransaction(txId, (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
-                        message: message.payload.message
-                    }, txId));
-                }
-                break;
-            }
-            case device_action: {
-                try {
-                    this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress
-                    }, txId));
-                    await this.handleDeviceAction(message.payload);
-                    this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.success
-                    }, txId));
-                }
-                catch (e) {
-                    logger_1.logger.error(`There was a problem performing device action '${message.payload.action}'!\n${(0, util_1.stringifyError)(e)}`);
-                    this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
-                        message: e.message
-                    }, txId));
-                }
-                break;
-            }
-            default:
-                logger_1.logger.error(`Invalid client message: '${JSON.stringify({ topic, message, txId }, null, 2)}'`);
-        }
-    }
-    async handleDeviceAction(payload) {
-        const { system_restart } = device_agent_schemas_1.keyMirrors.deviceAction;
-        switch (payload.action) {
-            case system_restart: {
-                await (0, device_control_1.reboot)();
-                break;
-            }
-            default: {
-                logger_1.logger.info(`Unrecognized device action requested: '${payload.action}'.`);
-            }
-        }
-    }
-    async publishCloudRequest(message) {
-        this.publisher.publishToCloud(message);
-    }
-    subscribe(topic) {
-        logger_1.logger.info(`Subscribing to ${topic}`);
-        this.device.subscribe(topic);
+        this.connectionManager.disconnect();
     }
-    async atomicApplicationUninstall(projectId) {
-        try {
-            await (0, application_control_1.uninstallApp)({ projectId });
-            this.shadowHandler.clearProjectShadow(projectId);
-        }
-        catch (e) {
-            logger_1.logger.error(`Failed to uninstall ${projectId}!\n${(0, util_1.stringifyError)(e)}`);
-            throw e;
-        }
-    }
-    // eslint-disable-next-line
-    async atomicApplicationUpdate(func, projectId, skipUpdateShadow) {
-        if (await (0, agent_config_1.AgentConfigFile)().isAppPresent({ projectId })) {
-            // Reject the application update if app is present but not ready
-            if (!(await (0, agent_config_1.AgentConfigFile)().isAppReady({ projectId }))) {
-                throw new Error('Application already has installation in progress!');
-            }
-            // Try to create a backup, so that there is one available if something goes wrong in the next try:catch.
-            try {
-                await (0, backup_1.createAppBackup)({ projectId });
-            }
-            catch (e) {
-                logger_1.logger.error(`Could not create a backup for the project: ${projectId}!\n${(0, util_1.stringifyError)(e)}`);
-            }
-        }
-        try {
-            const out = await func();
-            if (!skipUpdateShadow)
-                await this.shadowHandler.updateProjectShadow(projectId);
-            return out;
-        }
-        catch (errorAppUpdate) {
-            logger_1.logger.error(`Failed to update ${projectId}!\n${(0, util_1.stringifyError)(errorAppUpdate)}`);
-            // If something goes wrong, first try to rollback
-            try {
-                await (0, backup_1.rollbackApp)({ projectId });
-            }
-            catch (errorRollbackApp) {
-                logger_1.logger.error(`Application rollback failed for ${projectId}!\n${(0, util_1.stringifyError)(errorRollbackApp)}`);
-                // and if that fails, uninstall the app as a last resort.
-                try {
-                    await this.atomicApplicationUninstall(projectId);
-                }
-                catch (_a) {
-                    // atomicApplicationUninstall logs failure, so there's nothing to do here.
-                }
-                throw new aai_error_1.default('Application update and rollback failed, uninstalled the application!', { cause: errorAppUpdate });
-            }
-            throw new Error('Application update failed, rolled the application back!', { cause: errorAppUpdate });
-        }
-    }
-    async handleProjectShadowMessage(topic, message) {
-        const shadowUpdates = await this.shadowHandler.handleProjectShadow({
-            topic,
-            payload: message,
-            clientToken: message.clientToken
-        });
-        if (shadowUpdates.length) {
-            const shadowUpdatePromises = [];
-            for (const shadowUpdate of shadowUpdates) {
-                const projectId = shadowUpdate.projectId;
-                const txId = shadowUpdate.txId;
-                shadowUpdatePromises.push(this.txnMgr
-                    .runTransactionStep({
-                    func: () => this.handleProjectShadowConfigUpdate(shadowUpdate, txId),
-                    projectId,
-                    txId,
-                    start: true,
-                    liveUpdatesPublishFn: async () => this.publisher.publishToClient((0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, { status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress }, txId), logger_1.logger.silly),
-                    stepName: topic
-                })
-                    .catch((e) => {
-                    logger_1.logger.error(`There was an issue updating project shadow config for ${projectId}!\n${(0, util_1.stringifyError)(e)}`);
-                }));
-            }
-            await Promise.all(shadowUpdatePromises);
-        }
-    }
-    async handleSecureTunnelMessage(payload) {
-        logger_1.logger.info(`Received secure tunnel update: ${JSON.stringify(payload)}`);
-        const state = (0, device_agent_schemas_1.getUpdateDeltaStateFromMessage)(payload);
-        if (!state) {
-            logger_1.logger.debug(`No state found in message: ${JSON.stringify(payload)}`);
-            return;
-        }
-        const valid = (0, device_agent_schemas_1.validateSecureTunnelShadowUpdate)(state);
-        if (!valid) {
-            logger_1.logger.error(`Error validating message: ${JSON.stringify({ payload, errors: device_agent_schemas_1.validateSecureTunnelShadowUpdate.errors }, null, 2)}`);
-            return;
-        }
-        const secureTunnelUpdate = await this.secureTunnelHandler.syncShadowToDeviceState(payload);
-        await this.shadowHandler.updateSecureTunnelShadow(secureTunnelUpdate);
+    async handleMessage(topic, message) {
+        this.connectionManager.dispatch(topic, message);
     }
 }
 exports.DeviceAgentCloudConnection = DeviceAgentCloudConnection;