@alwaysai/device-agent 1.3.0 → 1.3.1-2

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

@@ -3,29 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeviceAgentCloudInterface = exports.DeviceAgentCloudConnection = void 0;
 // eslint-disable-next-line
 const awsIot = require('aws-iot-device-sdk');
-const urls_1 = require("../infrastructure/urls");
+const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
 const fs_1 = require("fs");
+const application_control_1 = require("../application-control");
+const backup_1 = require("../application-control/backup");
+const device_control_1 = require("../device-control/device-control");
+const environment_1 = require("../environment");
+const agent_config_1 = require("../infrastructure/agent-config");
+const urls_1 = require("../infrastructure/urls");
+const secure_tunneling_1 = require("../secure-tunneling/secure-tunneling");
+const cloud_mode_ready_1 = require("../util/cloud-mode-ready");
 const directories_1 = require("../util/directories");
-const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
 const get_device_id_1 = require("../util/get-device-id");
 const logger_1 = require("../util/logger");
-const cloud_mode_ready_1 = require("../util/cloud-mode-ready");
-const agent_config_1 = require("../infrastructure/agent-config");
-const application_control_1 = require("../application-control");
-const shadow_handler_1 = require("./shadow-handler");
-const index_1 = require("../secure-tunneling/index");
-const publisher_1 = require("./publisher");
-const live_updates_handler_1 = require("./live-updates-handler");
+const sleep_1 = require("../util/sleep");
 const bootstrap_provision_1 = require("./bootstrap-provision");
-const cmd_status_1 = require("./cmd-status");
+const live_updates_handler_1 = require("./live-updates-handler");
 const passthrough_handler_1 = require("./passthrough-handler");
-const environment_1 = require("../environment");
-const messages_1 = require("./messages");
-const sleep_1 = require("../util/sleep");
-const backup_1 = require("../application-control/backup");
+const publisher_1 = require("./publisher");
+const shadow_handler_1 = require("./shadow-handler");
 const transaction_manager_1 = require("./transaction-manager");
-const message_builder_1 = require("./message-builder");
-const device_control_1 = require("../device-control/device-control");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const exec_promise = (0, util_1.promisify)(child_process_1.exec);
 class DeviceAgentCloudConnection {
     /*=================================================================
                               Public interface
@@ -34,8 +34,10 @@ class DeviceAgentCloudConnection {
         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();
         // FIXME: Add support for multiple simultaneous project updates
         this.appCfgUpdateQueue = [];
         this.handleAppStateControl = async (payload) => {
@@ -63,7 +65,7 @@ class DeviceAgentCloudConnection {
                             appReleaseHash
                         }
                     };
-                    const message = await (0, message_builder_1.buildSignedUrlsRequestMessage)(signedUrlsRequestPayload, txId);
+                    const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, signedUrlsRequestPayload, txId);
                     await this.publishCloudRequest(message);
                     return false;
                 }
@@ -83,7 +85,10 @@ class DeviceAgentCloudConnection {
                 appInstallPayload,
                 modelsInstallPayload
             };
-            await this.atomicApplicationUpdate(application_control_1.installApp, [{ projectId, appReleaseHash, signedUrlsPayload }], projectId);
+            await this.atomicApplicationUpdate(async () => {
+                await this.shadowHandler.clearProjectShadow(projectId);
+                await (0, application_control_1.installApp)({ projectId, appReleaseHash, signedUrlsPayload });
+            }, projectId);
             return true;
         };
         this.handleModelsInstallCloudResponsePayload = async (payload) => {
@@ -94,20 +99,18 @@ class DeviceAgentCloudConnection {
             const { appCfgUpdate, envVarUpdate } = update;
             const projectId = payload.modelsInstallResponse.projectId;
             if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(application_control_1.updateModelsWithPresignedUrls, [
-                    {
-                        projectId,
-                        modelInstallPayloads: payload.modelsInstallResponse.newModels,
-                        newAppCfg: appCfgUpdate.newAppCfg
-                    }
-                ], projectId);
+                await this.atomicApplicationUpdate(async () => await (0, application_control_1.updateModelsWithPresignedUrls)({
+                    projectId,
+                    modelInstallPayloads: payload.modelsInstallResponse.newModels,
+                    newAppCfg: appCfgUpdate.newAppCfg
+                }), projectId);
             }
             if (envVarUpdate) {
-                await this.atomicApplicationUpdate(application_control_1.setEnv, [{ projectId, envVars: envVarUpdate.envVars }], projectId);
+                await this.atomicApplicationUpdate(async () => await (0, application_control_1.setEnv)({ projectId, envVars: envVarUpdate.envVars }), projectId);
             }
             return true;
         };
-        this.handleAppConfigUpdate = async (update, txId) => {
+        this.handleProjectShadowConfigUpdate = async (update, txId) => {
             const { projectId, appCfgUpdate, envVarUpdate } = update;
             if (appCfgUpdate &&
                 appCfgUpdate.updatedModels &&
@@ -121,21 +124,19 @@ class DeviceAgentCloudConnection {
                         models: updatedModels
                     }
                 };
-                const message = await (0, message_builder_1.buildSignedUrlsRequestMessage)(modelsOnlyUrlsRequestPayload, txId);
+                const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, modelsOnlyUrlsRequestPayload, txId);
                 this.publisher.publishToCloud(message);
                 this.appCfgUpdateQueue.push(update);
                 return false;
             }
             if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(application_control_1.updateAppCfg, [
-                    {
-                        projectId,
-                        newAppCfg: appCfgUpdate.newAppCfg
-                    }
-                ], projectId);
+                await this.atomicApplicationUpdate(async () => await (0, application_control_1.updateAppCfg)({
+                    projectId,
+                    newAppCfg: appCfgUpdate.newAppCfg
+                }), projectId);
             }
             if (envVarUpdate) {
-                await this.atomicApplicationUpdate(application_control_1.setEnv, [{ projectId, envVars: envVarUpdate.envVars }], projectId);
+                await this.atomicApplicationUpdate(async () => await (0, application_control_1.setEnv)({ projectId, envVars: envVarUpdate.envVars }), projectId);
             }
             return true;
         };
@@ -145,21 +146,20 @@ class DeviceAgentCloudConnection {
             caPath: directories_1.AWS_ROOT_CERTIFICATE_FILE_PATH,
             clientId: this.clientId,
             host: this.host,
-            port: 8883,
+            port: this.port,
             keepalive: 1 // time before re-connect attempt on dropped connection, default is 400 seconds
         });
         this.publisher = new publisher_1.Publisher(this.device, this.clientId);
         this.shadowHandler = new shadow_handler_1.ShadowHandler(this.clientId, this.publisher);
-        this.cmdStatusMgr = new cmd_status_1.CmdStatusManager();
         this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler(this.publisher, this.clientId);
-        this.txnMgr = new transaction_manager_1.TransactionManager();
+        this.txnMgr = new transaction_manager_1.TransactionManager(this.publisher, this.liveUpdatesHandler);
         this.subscribe(this.toDeviceTopic);
         this.subscribe(this.secureTunnelNotifyTopic);
-        this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
-        this.subscribe(this.shadowHandler.shadowTopics.projects.getRejected);
-        this.subscribe(this.shadowHandler.shadowTopics.projects.updateDelta);
-        this.subscribe(this.shadowHandler.shadowTopics.projects.updateAccepted);
-        this.subscribe(this.shadowHandler.shadowTopics.projects.updateRejected);
+        for (const topic of this.shadowHandler.projectShadowTopics) {
+            this.subscribe(topic);
+        }
+        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.updateDelta);
+        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted);
     }
     async handleDeviceAction(payload) {
         const { system_restart } = device_agent_schemas_1.keyMirrors.deviceAction;
@@ -183,7 +183,7 @@ class DeviceAgentCloudConnection {
     async atomicApplicationUninstall(projectId) {
         try {
             await (0, application_control_1.uninstallApp)({ projectId });
-            this.shadowHandler.clearAppConfig(projectId);
+            await this.shadowHandler.clearProjectShadow(projectId);
         }
         catch (e) {
             logger_1.logger.error(`Failed to uninstall ${projectId}: ${e.message}`);
@@ -191,7 +191,7 @@ class DeviceAgentCloudConnection {
         }
     }
     // eslint-disable-next-line
-    async atomicApplicationUpdate(func, args, projectId) {
+    async atomicApplicationUpdate(func, projectId) {
         // First try to create a backup, so that there is one available if something goes wrong in the next try:catch.
         if (await (0, agent_config_1.AgentConfigFile)().isAppPresent({ projectId })) {
             try {
@@ -202,8 +202,7 @@ class DeviceAgentCloudConnection {
             }
         }
         try {
-            const out = await func(...args);
-            this.shadowHandler.clearAppConfig(projectId);
+            const out = await func();
             await this.shadowHandler.updateProjectShadow(projectId);
             return out;
         }
@@ -217,10 +216,10 @@ class DeviceAgentCloudConnection {
             catch (errorRollbackApp) {
                 // and if that fails, uninstall the app as a last resort.
                 try {
-                    await (0, application_control_1.uninstallApp)({ projectId });
+                    await this.atomicApplicationUninstall(projectId);
                 }
-                finally {
-                    this.shadowHandler.clearAppConfig(projectId);
+                catch (_a) {
+                    // atomicApplicationUninstall handles failing, so there's nothing to handle here.
                 }
                 logger_1.logger.error(`Application update failed, rolled back to previous version: ${errorAppUpdate}`);
                 throw new Error(`Application update and rollback failed, uninstalled the application: ${errorAppUpdate}`);
@@ -228,40 +227,29 @@ class DeviceAgentCloudConnection {
             throw new Error(`Application update failed, rolled the application back: ${errorAppUpdate}`);
         }
     }
-    // eslint-disable-next-line
-    async atomicCmd(props) {
-        const { func, args, projectId, txId } = props;
-        try {
-            await this.cmdStatusMgr.start(projectId);
-            await this.liveUpdatesHandler.enableTransactionStatus({
-                txId
-            });
-            const completed = await func(...args);
-            if (completed) {
-                await this.cmdStatusMgr.stop(projectId);
-                await this.liveUpdatesHandler.disableTransactionStatus({
-                    txId
-                });
-                const successStatusResponsePayload = await (0, messages_1.getStatusResponsePayload)(device_agent_schemas_1.keyMirrors.statusResponse.success, '');
-                // Send final status message
-                const message = await (0, message_builder_1.buildStatusResponseMessage)(successStatusResponsePayload, txId);
-                this.publisher.publishToClient(message);
+    async handleProjectShadowMessage(topic, message) {
+        const shadowUpdates = await this.shadowHandler.handleProjectShadow({
+            topic,
+            payload: message,
+            clientToken: message.clientToken
+        });
+        if (shadowUpdates.length) {
+            for (const shadowUpdate of shadowUpdates) {
+                const projectId = shadowUpdate.projectId;
+                const txId = shadowUpdate.txId;
+                try {
+                    await this.txnMgr.runTransactionStep({
+                        func: () => this.handleProjectShadowConfigUpdate(shadowUpdate, txId),
+                        projectId,
+                        txId,
+                        start: true,
+                        stepName: topic
+                    });
+                }
+                catch (e) {
+                    logger_1.logger.error(`Error handling shadow message: ${e.message}`);
+                }
             }
-            return completed;
-        }
-        catch (e) {
-            logger_1.logger.error(`Failed to execute cmd for ${projectId}:\n${e.message}\n${e.stack}`);
-            const message = e.message;
-            // uninstall the failed app to put system back in good state
-            await this.cmdStatusMgr.stop(projectId);
-            await this.liveUpdatesHandler.disableTransactionStatus({
-                txId
-            });
-            const failureStatusResponsePayload = await (0, messages_1.getStatusResponsePayload)(device_agent_schemas_1.keyMirrors.statusResponse.failure, message);
-            // Send final status message
-            const failureStatusResponseMessage = await (0, message_builder_1.buildStatusResponseMessage)(failureStatusResponsePayload, txId);
-            this.publisher.publishToClient(failureStatusResponseMessage);
-            return true;
         }
     }
     getClientId() {
@@ -270,11 +258,8 @@ class DeviceAgentCloudConnection {
     getToDeviceTopic() {
         return this.toDeviceTopic;
     }
-    getShadowTopics() {
-        return this.shadowHandler.shadowTopics;
-    }
     isCmdInProgress(projectId) {
-        return this.cmdStatusMgr.isCmdInProgress(projectId);
+        return this.txnMgr.isOngoingTransactionForProjectID(projectId);
     }
     async updateProjectShadow(projectId) {
         await this.shadowHandler.updateProjectShadow(projectId);
@@ -287,76 +272,66 @@ class DeviceAgentCloudConnection {
             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 device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.app_state_control: {
+            case app_state_control: {
                 // txId sent from cloud, just need to continue it
                 const payload = message.payload;
                 const projectId = payload.projectId;
                 try {
-                    this.txnMgr.addTransaction(txId, projectId);
-                    const completed = await this.atomicCmd({
-                        func: this.handleAppStateControl,
-                        args: [message.payload],
+                    await this.txnMgr.runTransactionStep({
+                        func: () => this.handleAppStateControl(message.payload),
                         projectId,
-                        txId
+                        txId,
+                        start: true,
+                        stepName: payload.baseCommand
                     });
-                    if (completed) {
-                        this.txnMgr.completeTransaction(txId);
-                    }
                 }
                 catch (e) {
                     logger_1.logger.error(`Error processing application state control request: ${e}!`);
                 }
                 break;
             }
-            case device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.app_version_control: {
+            case app_version_control: {
                 // txId sent from cloud, just need to continue it
                 const payload = message.payload;
                 const projectId = payload.projectId;
-                const appReleaseHash = payload.baseCommand === device_agent_schemas_1.keyMirrors.appVersionControl.install
-                    ? payload.appReleaseHash
-                    : undefined;
                 try {
-                    this.txnMgr.addTransaction(txId, projectId);
-                    const completed = await this.atomicCmd({
-                        func: this.handleAppVersionControl,
-                        args: [payload, txId],
+                    await this.txnMgr.runTransactionStep({
+                        func: () => this.handleAppVersionControl(payload, txId),
                         projectId,
-                        txId
+                        txId,
+                        start: true,
+                        stepName: payload.baseCommand
                     });
-                    if (completed) {
-                        this.txnMgr.completeTransaction(txId);
-                    }
                 }
                 catch (e) {
                     logger_1.logger.error(`Error processing application install request: ${e}!`);
                 }
                 break;
             }
-            case device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.live_state_updates: {
+            case live_state_updates: {
                 const payload = message.payload;
                 // TODO: Send response?
-                await this.liveUpdatesHandler.handleToggles(payload, txId);
+                void this.liveUpdatesHandler.handleToggles(payload, txId);
                 break;
             }
-            case device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.app_install_response: {
+            case app_install_response: {
                 const payload = message.payload;
-                const { projectId, appReleaseHash } = payload.appInstallResponse;
+                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)})!`);
                 }
-                const completed = await this.atomicCmd({
-                    func: this.handleAppInstallCloudResponsePayload,
-                    args: [payload],
+                await this.txnMgr.runTransactionStep({
+                    func: () => this.handleAppInstallCloudResponsePayload(payload),
                     projectId,
-                    txId
+                    txId,
+                    start: false,
+                    stepName: message.messageType
                 });
-                if (completed) {
-                    this.txnMgr.completeTransaction(txId);
-                }
                 break;
             }
-            case device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.models_install_response: {
+            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;
@@ -364,28 +339,50 @@ class DeviceAgentCloudConnection {
                 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)})!`);
                 }
-                const completed = await this.atomicCmd({
-                    func: this.handleModelsInstallCloudResponsePayload,
-                    args: [payload],
+                await this.txnMgr.runTransactionStep({
+                    func: () => this.handleModelsInstallCloudResponsePayload(payload),
                     projectId,
-                    txId
+                    txId,
+                    start: false,
+                    stepName: message.messageType
                 });
-                if (completed) {
+                break;
+            }
+            case status_response: {
+                const { failure } = device_agent_schemas_1.keyMirrors.statusResponse;
+                if (message.payload.status === failure) {
                     this.txnMgr.completeTransaction(txId);
+                    const failureStatusResponsePayload = {
+                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
+                        message: message.payload.message
+                    };
+                    // Send final status message
+                    const failureStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, failureStatusResponsePayload, txId);
+                    this.publisher.publishToClient(failureStatusResponseMessage);
                 }
                 break;
             }
-            case device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType.device_action: {
+            case device_action: {
                 try {
-                    const successStatusResponsePayload = await (0, messages_1.getStatusResponsePayload)(device_agent_schemas_1.keyMirrors.statusResponse.success, '');
-                    const successStatusResponseMessage = await (0, message_builder_1.buildStatusResponseMessage)(successStatusResponsePayload, txId);
-                    this.publisher.publishToClient(successStatusResponseMessage);
+                    const statusResponsePayload = {
+                        status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress
+                    };
+                    const statusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, statusResponsePayload, txId);
+                    this.publisher.publishToClient(statusResponseMessage);
                     await this.handleDeviceAction(message.payload);
+                    const successStatusResponsePayload = {
+                        status: device_agent_schemas_1.keyMirrors.statusResponse.success
+                    };
+                    const successStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, successStatusResponsePayload, txId);
+                    this.publisher.publishToClient(successStatusResponseMessage);
                 }
                 catch (e) {
                     logger_1.logger.error(`There was a problem performing device action '${message.payload.action}': ${e.message}`);
-                    const failureStatusResponsePayload = await (0, messages_1.getStatusResponsePayload)(device_agent_schemas_1.keyMirrors.statusResponse.failure, e.message);
-                    const failureStatusResponseMessage = await (0, message_builder_1.buildStatusResponseMessage)(failureStatusResponsePayload, txId);
+                    const failureStatusResponsePayload = {
+                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
+                        message: e.message
+                    };
+                    const failureStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, failureStatusResponsePayload, txId);
                     this.publisher.publishToClient(failureStatusResponseMessage);
                 }
                 break;
@@ -396,53 +393,32 @@ class DeviceAgentCloudConnection {
     }
     async handleMessage(topic, message) {
         logger_1.logger.debug(`Received message: ${JSON.stringify({ topic, message }, null, 2)}`);
-        switch (topic) {
-            case this.shadowHandler.shadowTopics.projects.getAccepted:
-            case this.shadowHandler.shadowTopics.projects.updateDelta: {
-                const shadowUpdates = await this.shadowHandler.handleShadowTopic({
-                    topic,
-                    payload: message.state,
-                    clientToken: message.clientToken
-                });
-                if (shadowUpdates.length) {
-                    for (const shadowUpdate of shadowUpdates) {
-                        const projectId = shadowUpdate.projectId;
-                        const txId = shadowUpdate.txId;
-                        try {
-                            this.txnMgr.addTransaction(txId, projectId);
-                            const completed = await this.atomicCmd({
-                                func: this.handleAppConfigUpdate,
-                                args: [shadowUpdate, txId],
-                                projectId,
-                                txId
-                            });
-                            if (completed) {
-                                this.txnMgr.completeTransaction(txId);
-                            }
-                        }
-                        catch (e) {
-                            logger_1.logger.error(`Error handling shadow message: ${e.message}`);
-                        }
-                    }
-                }
-                break;
-            }
-            case this.shadowHandler.shadowTopics.projects.getRejected:
-            case this.shadowHandler.shadowTopics.projects.updateAccepted:
-            case this.shadowHandler.shadowTopics.projects.updateRejected:
-                // Not handling these for now
-                break;
-            case this.toDeviceTopic:
-                await this.handleDeviceAgentMessage({
-                    topic,
-                    message
-                });
-                break;
-            case this.secureTunnelNotifyTopic:
-                await (0, index_1.secureTunnelNotifyHandler)(message);
-                break;
-            default:
-                logger_1.logger.error(`Unexpected topic, ignoring! ${topic}`);
+        // 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) {
+            logger_1.logger.info(`Received secure tunnel update: ${message}`);
+            const reported = await this.secureTunnelHandler.syncShadowToDeviceState(message);
+            this.publisher.publish(this.shadowHandler.shadowTopics.secureTunnel.update, JSON.stringify({ state: { reported } }));
+        }
+        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}`);
         }
     }
     async setupHandlers() {
@@ -474,8 +450,57 @@ class DeviceAgentCloudConnection {
         });
         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 stop() {
         // FIXME: 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