@alwaysai/device-agent 0.0.7 → 0.0.9

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

@@ -1,32 +1,61 @@
 "use strict";
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeviceAgentCloudInterface = exports.DeviceAgentCloudConnection = void 0;
 const awsIot = require('aws-iot-device-sdk');
 const urls_1 = require("../infrastructure/urls");
 const directories_1 = require("../util/directories");
+const sleep_1 = require("../util/sleep");
 const status_1 = require("../application-control/status");
 const install_1 = require("../application-control/install");
-const device_control_1 = require("../device-control/device-control");
 const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
 const get_device_id_1 = require("../util/get-device-id");
+const util_1 = require("alwaysai/lib/util");
+const device_control_1 = require("../device-control/device-control");
 const agent_config_1 = require("../infrastructure/agent-config");
+const utils_1 = require("../application-control/utils");
+const models_1 = require("../application-control/models");
+const config_1 = require("../application-control/config");
 class DeviceAgentCloudConnection {
     constructor() {
         this.clientId = (0, get_device_id_1.getDeviceId)();
         this.host = (0, urls_1.getIoTCoreEndpointUrl)();
-        this.publishable = false;
-        this.publishInterval = 10000;
-        this.installationStatusInterval = 5000;
+        this.liveUpdatesAlive = {
+            [device_agent_schemas_1.keyMirrors.agentMessageType.device_stats]: false,
+            [device_agent_schemas_1.keyMirrors.agentMessageType.app_state]: false,
+            [device_agent_schemas_1.keyMirrors.agentMessageType.app_logs]: false,
+        };
+        this.liveUpdatesSleepIntervals = {
+            [device_agent_schemas_1.keyMirrors.agentMessageType.device_stats]: 5000,
+            [device_agent_schemas_1.keyMirrors.agentMessageType.app_state]: 5000,
+            [device_agent_schemas_1.keyMirrors.agentMessageType.app_logs]: 5000,
+            [device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status]: 5000,
+        };
+        this.appLogStreams = new Set();
+        this.deviceType = 'aai-device';
+        this.shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
+        this.shadowTopics = {
+            projects: {
+                updateDelta: `${this.shadowPrefix}projects/update/delta`,
+                getAccepted: `${this.shadowPrefix}projects/get/accepted`,
+            },
+        };
+        this.toCloudTopic = `topic/to_cloud/${this.deviceType}/${this.clientId}`;
+        this.toClientTopic = `topic/to_client/${this.deviceType}/${this.clientId}`;
+        this.toDeviceTopic = `topic/to_device/${this.deviceType}/${this.clientId}`;
+        // must be arrow function due to this context when function is passed as param
+        this.getAppInstallStatusMessage = async () => {
+            const appInstallStatus = this.getAppInstallStatus();
+            const appInstallStatusMessage = {
+                messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status,
+                appInstallStatus,
+            };
+            return appInstallStatusMessage;
+        };
+        this.handleDeviceCommand = async (packet) => {
+            // TODO
+        };
+        // Public Methods
         this.device = awsIot.device;
-        this.agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
-        this.cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
         this.device = awsIot.device({
             keyPath: (0, directories_1.getPrivateKeyFilePath)(),
             certPath: (0, directories_1.getCertificateFilePath)(),
@@ -34,118 +63,117 @@ class DeviceAgentCloudConnection {
             clientId: this.clientId,
             host: this.host,
         });
-        this.device.subscribe(`${this.agentTopicPrefix}command`);
-        this.device.subscribe(`${this.agentTopicPrefix}response`);
+        this.device.subscribe(this.toDeviceTopic);
+        this.device.subscribe(this.shadowTopics.projects.getAccepted);
+        this.device.subscribe(this.shadowTopics.projects.updateDelta);
     }
-    setInstallationStatus(installationStatus) {
-        this.installationStatus = installationStatus;
+    // device shadow utils
+    getShadowPrefix() {
+        return this.shadowPrefix;
     }
-    getInstallationStatus() {
-        return this.installationStatus;
-    }
-    getPublishable() {
-        return this.publishable;
-    }
-    setPublishable(enabled) {
-        this.publishable = enabled;
-    }
-    restartPublishableTimeout() {
-        clearTimeout(this.publishableTimeout);
-        this.publishableTimeout = setTimeout(() => {
-            this.setPublishable(false);
-        }, 600000); // 10 min
+    async handleNamedShadowUpdate({ payload }) {
+        const delta = JSON.parse(payload);
+        const deltaKeys = Object.keys(delta);
+        for (const projectId of deltaKeys) {
+            const projectShadow = delta[projectId];
+            if (projectShadow.appConfig) {
+                const appConfig = projectShadow.appConfig;
+                const appDir = (0, utils_1.getAppDir)(projectId);
+                await (0, config_1.updateAppConfig)(projectId, appConfig);
+                if (appConfig.models) {
+                    this.publishCloudRequest({
+                        messageType: device_agent_schemas_1.keyMirrors.agentMessageType.signed_urls_request,
+                        modelsOnlyUrlsRequest: {
+                            projectId,
+                            models: appConfig.models,
+                        },
+                    });
+                }
+                if (appConfig.scripts && !appConfig.models) {
+                    const appState = await (0, status_1.getAppStatus)({ projectId });
+                    await (0, utils_1.buildApp)({ appDir });
+                    if (appState.services.length &&
+                        appState.services[0].state !== device_agent_schemas_1.keyMirrors.appState.stopped) {
+                        (0, status_1.restartApp)({ projectId });
+                    }
+                    await this.publishReportedState(projectId);
+                }
+            }
+        }
     }
-    getPublishInterval() {
-        return this.publishInterval;
+    async startAppLogStream(projectId) {
+        this.appLogStreams.add(projectId);
+        const readable = await (0, status_1.getAppLogs)({
+            projectId,
+            args: ['--tail', '100', '--no-log-prefix'],
+        });
+        readable.on('data', (chunk) => {
+            if (!this.appLogStreams.has(projectId)) {
+                // why doesn't typescript know about this function?
+                // @ts-ignore
+                readable.destroy();
+                util_1.logger.info(`App log stream terminated for project ${projectId}`);
+                return;
+            }
+            const logStr = chunk.toString();
+            const message = {
+                messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_logs,
+                appLogs: {
+                    projectId,
+                    logChunk: logStr,
+                },
+            };
+            const packet = this.buildMessagePacket(this.getClientId(), this.toClientTopic, message);
+            this.publishMessage(this.toClientTopic, JSON.stringify(packet));
+        });
+        readable.on('error', (error) => {
+            util_1.logger.error(`App log stream terminated for project ${projectId}: ${error}`);
+        });
+        readable.on('finished', () => {
+            util_1.logger.info(`App logs finished piping for project ${projectId}`);
+        });
     }
-    getInstallationStatusInterval() {
-        return this.installationStatusInterval;
+    // must contain app release hash
+    initAppInstallStatus(installationStatus) {
+        this.appInstallStatus = installationStatus;
     }
-    getClientId() {
-        return this.clientId;
+    updateAppInstallStatus(installationStatus) {
+        this.appInstallStatus.status = installationStatus.status;
+        this.appInstallStatus.message = installationStatus.message;
     }
-    publishMessage(topic, message) {
-        this.device.publish(topic, message);
+    getAppInstallStatus() {
+        return this.appInstallStatus;
     }
-}
-exports.DeviceAgentCloudConnection = DeviceAgentCloudConnection;
-function runDeviceAgentCloudInterface() {
-    const deviceAgent = new DeviceAgentCloudConnection();
-    async function buildMessagePacket(topic, payload) {
+    // Message Builders
+    buildMessagePacket(deviceId, topic, payload) {
         const packet = {
             timestamp: new Date().toUTCString(),
-            deviceId: deviceAgent.getClientId(),
+            deviceId,
             topic,
             payload,
         };
         return packet;
     }
-    async function getAppLogsMessage() {
-        var e_1, _a;
-        const appLogsList = [];
-        const apps = await (0, agent_config_1.AgentConfigFile)().getReadyApps();
-        for (const app of apps) {
-            const projectId = app.projectId;
-            const readable = await (0, status_1.getAppLogs)({ projectId });
-            const logs = [];
-            readable.setEncoding('utf8');
-            try {
-                for (var readable_1 = (e_1 = void 0, __asyncValues(readable)), readable_1_1; readable_1_1 = await readable_1.next(), !readable_1_1.done;) {
-                    const chunk = readable_1_1.value;
-                    logs.push(chunk);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (readable_1_1 && !readable_1_1.done && (_a = readable_1.return)) await _a.call(readable_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            const appLogs = {
-                projectId,
-                logs,
-            };
-            appLogsList.push(appLogs);
-        }
-        const applicationStatePackage = {
-            applicationLogs: appLogsList,
-        };
-        return applicationStatePackage;
-    }
-    // * This was causing massive CPU overhead
-    // 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() {
+    async getAppStateMessage() {
         const appStateMessage = [];
-        const apps = await (0, agent_config_1.AgentConfigFile)().getApps();
+        const apps = await (0, agent_config_1.AgentConfigFile)().getReadyApps();
         for (const app of apps) {
             const projectId = app.projectId;
             const status = await (0, status_1.getAppStatus)({ projectId });
             appStateMessage.push(status);
         }
-        const applicationStatePackage = {
-            applicationState: appStateMessage,
+        const appStatePackage = {
+            messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_state,
+            appState: appStateMessage,
         };
-        return applicationStatePackage;
+        return 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 getDeviceStatsMessage() {
         const cpuUsage = await (0, device_control_1.getCpuUtil)();
         const diskUtil = await (0, device_control_1.getDiskUtil)();
         const memUtil = await (0, device_control_1.getMemUtil)();
         const deviceStatsMessage = {
+            messageType: device_agent_schemas_1.keyMirrors.agentMessageType.device_stats,
             deviceStats: {
                 cpuUsage,
                 diskUtil,
@@ -154,122 +182,256 @@ function runDeviceAgentCloudInterface() {
         };
         return deviceStatsMessage;
     }
-    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 }));
+    async startPublishingLiveUpdates(topic, messageType, getMessageData) {
+        while (true) {
+            try {
+                const message = await getMessageData();
+                const packet = this.buildMessagePacket(this.getClientId(), topic, message);
+                this.publishMessage(topic, JSON.stringify(packet));
+            }
+            catch (e) {
+                util_1.logger.error(`Error publishing live updates for ${messageType}: ${e.message}`);
+                break;
+            }
+            if (!this.continuePublishing(messageType)) {
+                util_1.logger.info(`Turned off live updates for ${messageType}`);
+                break;
+            }
+            await (0, sleep_1.default)(this.getLiveUpdatesInterval(messageType));
         }
-    }, deviceAgent.getPublishInterval());
-    const publishDeviceRequest = async ({ projectId, releaseHash }) => {
-        const topic = `${deviceAgent.cloudTopicPrefix}request`;
-        const deviceRequestPackage = {
-            timestamp: new Date().toUTCString(),
-            deviceId: deviceAgent.getClientId(),
-            projectId,
-            releaseHash,
-            topic,
-        };
-        deviceAgent.publishMessage(topic, JSON.stringify({ device_request: deviceRequestPackage }));
-    };
-    const publishInstallationStatus = async (interval) => {
-        const topic = `${deviceAgent.cloudTopicPrefix}installation-status`;
-        const installationStatus = deviceAgent.getInstallationStatus();
-        const installationStatusPacket = await buildMessagePacket(topic, {
-            installationStatus,
+    }
+    continuePublishing(flag) {
+        switch (flag) {
+            case device_agent_schemas_1.keyMirrors.agentMessageType.device_stats:
+            case device_agent_schemas_1.keyMirrors.agentMessageType.app_state:
+                return this.liveUpdatesAlive[flag];
+            case device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status:
+                return this.appInstallStatus.status === device_agent_schemas_1.keyMirrors.appInstallStatus.in_progress;
+            default:
+                util_1.logger.error(`Unrecognized publishable flag ${flag}`);
+                return false;
+        }
+    }
+    getLiveUpdatesInterval(flag) {
+        const exists = this.liveUpdatesSleepIntervals[flag];
+        if (exists) {
+            return exists;
+        }
+        util_1.logger.error(`Unrecognized live updates flag ${flag}`);
+        return -1;
+    }
+    setLiveUpdates(toggles) {
+        if (toggles.deviceStats) {
+            this.liveUpdatesAlive.device_stats = toggles.deviceStats;
+        }
+        if (toggles.appState) {
+            this.liveUpdatesAlive.app_state = toggles.appState;
+        }
+    }
+    handleAppStateControl(payload) {
+        const { baseCommand, projectId } = payload;
+        switch (baseCommand) {
+            case device_agent_schemas_1.keyMirrors.appStateControl.start:
+                (0, status_1.startApp)({ projectId });
+                break;
+            case device_agent_schemas_1.keyMirrors.appStateControl.stop:
+                (0, status_1.stopApp)({ projectId });
+                break;
+            case device_agent_schemas_1.keyMirrors.appStateControl.restart:
+                (0, status_1.restartApp)({ projectId });
+                break;
+        }
+    }
+    handleAppVersionControl(payload) {
+        const { projectId, appReleaseHash } = payload;
+        const signedUrlsRequest = { projectId, appReleaseHash };
+        this.publishCloudRequest({
+            messageType: device_agent_schemas_1.keyMirrors.agentMessageType.signed_urls_request,
+            signedUrlsRequest,
         });
-        deviceAgent.device.publish(topic, JSON.stringify({ installationStatusPacket }));
-        if (installationStatus.status !== device_agent_schemas_1.InstallationStatusEnum.IN_PROGRESS) {
-            clearInterval(interval);
+    }
+    handleAgentCommand(message) {
+        switch (message.messageType) {
+            case device_agent_schemas_1.keyMirrors.clientMessageType.live_state_updates:
+                this.liveUpdatesBroker(message.liveUpdatesToggles);
+                break;
+            default:
+                util_1.logger.error(`Invalid agent action message type from message '${message}'`);
         }
-    };
-    const handleMessageTopic = async ({ topic, payload }) => {
-        const action = payload['action'];
-        const actionPayload = payload[action];
-        const type = topic.split('/').slice(-1)[0];
-        if (!type) {
-            return false;
+    }
+    restartLiveUpdatesTimeout() {
+        clearTimeout(this.liveUpdatesTimeout);
+        this.liveUpdatesTimeout = setTimeout(() => {
+            this.setLiveUpdates({
+                deviceStats: false,
+                appState: false,
+            });
+            this.appLogStreams.clear();
+            // TODO: Make constant, not hard coded
+        }, 600000); // 10 min
+    }
+    async liveUpdatesBroker({ deviceStats, appState, appLogs, }) {
+        this.restartLiveUpdatesTimeout();
+        if (deviceStats !== undefined) {
+            this.liveUpdatesAlive.device_stats = deviceStats;
+            if (deviceStats) {
+                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.device_stats, this.getDeviceStatsMessage);
+            }
         }
-        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: device_agent_schemas_1.InstallationStatusEnum.IN_PROGRESS,
-                        applicationReleaseHash: actionPayload.releaseHash,
-                    });
-                    const installationStatusPing = setInterval(() => publishInstallationStatus(installationStatusPing), deviceAgent.getInstallationStatusInterval());
-                    // Install the app with the given url
-                    await (async () => {
-                        try {
-                            await (0, install_1.installApp)(actionPayload);
-                            deviceAgent.setInstallationStatus({
-                                status: device_agent_schemas_1.InstallationStatusEnum.SUCCESS,
-                                applicationReleaseHash: actionPayload.releaseHash,
-                            });
-                        }
-                        catch (e) {
-                            const reason = e.message;
-                            deviceAgent.setInstallationStatus({
-                                status: device_agent_schemas_1.InstallationStatusEnum.FAILURE,
-                                reason,
-                                applicationReleaseHash: actionPayload.releaseHash,
-                            });
-                        }
-                    })();
-                    break;
-                }
-                publishDeviceRequest(actionPayload);
+        if (appState !== undefined) {
+            this.liveUpdatesAlive.app_state = appState;
+            if (appState) {
+                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.app_state, this.getAppStateMessage);
+            }
+        }
+        if (appLogs !== undefined) {
+            if (appLogs.toggle) {
+                this.startAppLogStream(appLogs.projectId);
+            }
+            else {
+                this.appLogStreams.delete(appLogs.projectId);
+            }
+        }
+    }
+    async publishReportedState(projectId) {
+        const newAppCfg = await (0, utils_1.getAppConfig)(projectId);
+        const packet = {
+            state: {
+                reported: {
+                    [projectId]: { appConfig: newAppCfg },
+                },
+            },
+        };
+        this.publishMessage(`${this.shadowPrefix}projects/update`, JSON.stringify(packet));
+    }
+    async publishCloudRequest(payload) {
+        const topic = this.toCloudTopic;
+        const deviceRequestPacket = this.buildMessagePacket(this.getClientId(), topic, payload);
+        this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
+    }
+    getClientId() {
+        return this.clientId;
+    }
+    publishMessage(topic, message) {
+        // TODO: topic validation
+        this.device.publish(topic, message);
+    }
+    async handleClientMessage({ topic, message, }) {
+        const payload = message.payload;
+        switch (payload.messageType) {
+            case device_agent_schemas_1.keyMirrors.clientMessageType.app_state_control: {
+                this.handleAppStateControl(payload.appStateControl);
                 break;
-            case 'start':
-                (0, status_1.startApp)({ projectId: actionPayload.projectId });
+            }
+            case device_agent_schemas_1.keyMirrors.clientMessageType.app_version_control: {
+                this.handleAppVersionControl(payload.appVersionControl);
                 break;
-            case 'stop':
-                (0, status_1.stopApp)({ projectId: actionPayload.projectId });
+            }
+            case device_agent_schemas_1.keyMirrors.clientMessageType.live_state_updates: {
+                this.handleAgentCommand(payload);
                 break;
-            case 'restart':
-                (0, status_1.restartApp)({ projectId: actionPayload.projectId });
+            }
+            case device_agent_schemas_1.keyMirrors.clientMessageType.app_install_cloud_response: {
+                const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } = payload.appInstallCloudResponse;
+                this.initAppInstallStatus({
+                    status: device_agent_schemas_1.keyMirrors.appInstallStatus.in_progress,
+                    appReleaseHash,
+                });
+                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status, this.getAppInstallStatusMessage);
+                // Install the app and models
+                try {
+                    const signedUrlsPayload = {
+                        appInstallPayload,
+                        modelsInstallPayload,
+                    };
+                    await (0, install_1.installApp)({
+                        projectId,
+                        appReleaseHash,
+                        signedUrlsPayload,
+                    });
+                    this.updateAppInstallStatus({
+                        status: device_agent_schemas_1.keyMirrors.appInstallStatus.success,
+                    });
+                    // update app config shadow for project
+                    await this.publishReportedState(projectId);
+                }
+                catch (e) {
+                    console.error(e);
+                    const message = e.message;
+                    // uninstall the failed app to put system back in good state
+                    await (0, install_1.uninstallApp)({ projectId });
+                    this.updateAppInstallStatus({
+                        status: device_agent_schemas_1.keyMirrors.appInstallStatus.failure,
+                        message,
+                    });
+                    // delete shadow for project
+                    this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, '');
+                }
                 break;
-            /**
-             * Allow/disallow publishing on this device. By default, (publishable = false)
-             */
-            case 'publishable':
-                /**
-                  {
-                    "action": "publishable",
-                    "publishable": true | false
-                  }
-                 */
-                deviceAgent.setPublishable(actionPayload);
-                deviceAgent.restartPublishableTimeout();
+            }
+            case device_agent_schemas_1.keyMirrors.clientMessageType.models_install_cloud_response: {
+                const { projectId, newModels } = payload.modelsInstallCloudResponse;
+                try {
+                    await (0, models_1.updateModelsWithPresignedUrls)(projectId, newModels);
+                    await this.publishReportedState(projectId);
+                }
+                catch (e) {
+                    console.error(e);
+                }
                 break;
+            }
             default:
-                break;
+                util_1.logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
+        }
+    }
+    async handleShadowTopic({ topic, payload }) {
+        const shadowName = topic.split('/')[5];
+        const message = JSON.parse(payload);
+        if (topic === this.shadowTopics.projects.updateDelta) {
+            this.handleNamedShadowUpdate({ payload });
         }
-    };
+        else if (topic === this.shadowTopics.projects.getAccepted) {
+            if (message.delta) {
+                this.handleNamedShadowUpdate({
+                    payload: JSON.stringify(message.delta),
+                });
+            }
+            else {
+                console.log(`No delta updates in shadow ${shadowName}`);
+            }
+        }
+    }
+}
+exports.DeviceAgentCloudConnection = DeviceAgentCloudConnection;
+function runDeviceAgentCloudInterface() {
+    const deviceAgent = new DeviceAgentCloudConnection();
     deviceAgent.device.on('connect', function () {
         deviceAgent.publishMessage('connection', deviceAgent.getClientId());
         console.log('Device Agent has connected to the cloud');
+        // Get shadow updates
+        deviceAgent.publishMessage(`${deviceAgent.getShadowPrefix()}projects/get`, '');
     });
     deviceAgent.device.on('disconnect', function () {
         console.log('Device Agent has been disconnected from the cloud');
     });
     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) });
+            const jsonPacket = JSON.parse(payload);
+            if (jsonPacket.hasOwnProperty('state')) {
+                deviceAgent.handleShadowTopic({
+                    topic,
+                    payload: JSON.stringify(jsonPacket.state),
+                });
+            }
+            else {
+                const valid = (0, device_agent_schemas_1.validateClientMessage)(jsonPacket);
+                if (!valid) {
+                    console.error(JSON.stringify(device_agent_schemas_1.validateClientMessage.errors));
+                }
+                else {
+                    deviceAgent.handleClientMessage({ topic, message: jsonPacket });
+                }
+            }
         }
         catch (error) {
             console.error(error);