From 60e888e16ece2ad59384db3de6840cd999c8af84 Mon Sep 17 00:00:00 2001 From: Victor Woeltjen Date: Thu, 16 Apr 2015 16:27:25 -0700 Subject: [PATCH] [Telemetry] Begin adding telemetry handler Begin adding a general purpose handler for telemetry which extends on the behavior associated with the telemetrySubscriber by supporting access to historical data as well. WTD-806. --- platform/telemetry/src/TelemetryHandle.js | 81 +++++++++++++++++++ platform/telemetry/src/TelemetryHandler.js | 33 ++++++++ platform/telemetry/src/TelemetryRequester.js | 34 -------- .../telemetry/src/TelemetrySubscription.js | 16 +++- 4 files changed, 128 insertions(+), 36 deletions(-) create mode 100644 platform/telemetry/src/TelemetryHandle.js create mode 100644 platform/telemetry/src/TelemetryHandler.js delete mode 100644 platform/telemetry/src/TelemetryRequester.js diff --git a/platform/telemetry/src/TelemetryHandle.js b/platform/telemetry/src/TelemetryHandle.js new file mode 100644 index 0000000000..eef57caba6 --- /dev/null +++ b/platform/telemetry/src/TelemetryHandle.js @@ -0,0 +1,81 @@ +/*global define*/ + +define( + [], + function () { + "use strict"; + + function TelemetryHandle($q, subscription) { + var seriesMap = {}, + self = Object.create(subscription); + + function requestSeries(telemetryObject, request, callback) { + var id = telemetryObject.getId(), + telemetry = telemetryObject.getCapability('telemetry'); + + function receiveSeries(series) { + // Store it for subsequent lookup + seriesMap[id] = series; + // Notify callback of new series data, if there is one + if (callback) { + callback(telemetryObject, series); + } + // Pass it along for promise-chaining + return series; + } + + // Issue the request via the object's telemetry capability + return telemetry.requestData(request).then(receiveSeries); + } + + + /** + * Get the most recently obtained telemetry data series associated + * with this domain object. + * @param {DomainObject} the domain object which has telemetry + * data associated with it + * @return {TelemetrySeries} the most recent telemetry series + * (or undefined if there is not one) + */ + self.getSeries = function (domainObject) { + var id = domainObject.getId(); + return seriesMap[id]; + }; + + + /** + * Change the request duration. + * @param {object|number} request the duration of historical + * data to look at; or, the request to issue + * @param {Function} [callback] a callback that will be + * invoked as new data becomes available, with the + * domain object for which new data is available. + */ + self.request = function (request, callback) { + // Issue (and handle) the new request from this object + function issueRequest(telemetryObject) { + return requestSeries(telemetryObject, request, callback); + } + + // Map the request to all telemetry objects + function issueRequests(telemetryObjects) { + return $q.all(telemetryObjects.map(issueRequest)); + } + + // If the request is a simple number, treat it as a duration + request = (typeof request === 'number') ? + { duration: request } : request; + + // Look up telemetry-providing objects from the subscription, + // then issue new requests. + return subscription.promiseTelemetryObjects() + .then(issueRequests); + }; + + return self; + } + + return TelemetryHandle; + + } +); \ No newline at end of file diff --git a/platform/telemetry/src/TelemetryHandler.js b/platform/telemetry/src/TelemetryHandler.js new file mode 100644 index 0000000000..2b3aa954eb --- /dev/null +++ b/platform/telemetry/src/TelemetryHandler.js @@ -0,0 +1,33 @@ +/*global define*/ + +define( + ['./TelemetryHandle'], + function (TelemetryHandle) { + "use strict"; + + + /** + * A TelemetryRequester provides an easy interface to request + * telemetry associated with a set of domain objects. + * + * @constructor + * @param $q Angular's $q + */ + function TelemetryHandler($q, telemetrySubscriber) { + return { + handle: function (domainObject, callback, lossless) { + var subscription = telemetrySubscriber.subscribe( + domainObject, + callback, + lossless + ); + + return new TelemetryHandle($q, subscription); + } + }; + } + + return TelemetryHandler; + + } +); \ No newline at end of file diff --git a/platform/telemetry/src/TelemetryRequester.js b/platform/telemetry/src/TelemetryRequester.js deleted file mode 100644 index f400083b28..0000000000 --- a/platform/telemetry/src/TelemetryRequester.js +++ /dev/null @@ -1,34 +0,0 @@ -/*global define*/ - -define( - ['./TelemetryDelegator'], - function (TelemetryDelegator) { - "use strict"; - - - /** - * A TelemetryRequester provides an easy interface to request - * telemetry associated with a set of domain objects. - * - * @constructor - * @param $q Angular's $q - */ - function TelemetryRequester($q) { - var delegator = new TelemetryDelegator($q); - - // Look up domain objects which have telemetry capabilities. - // This will either be the object in view, or object that - // this object delegates its telemetry capability to. - function promiseRelevantObjects(domainObject) { - return delegator.promiseTelemetryObjects(domainObject); - } - - return { - - }; - } - - return TelemetryRequester; - - } -); \ No newline at end of file diff --git a/platform/telemetry/src/TelemetrySubscription.js b/platform/telemetry/src/TelemetrySubscription.js index adbe08ba51..2afae3495c 100644 --- a/platform/telemetry/src/TelemetrySubscription.js +++ b/platform/telemetry/src/TelemetrySubscription.js @@ -33,6 +33,7 @@ define( function TelemetrySubscription($q, $timeout, domainObject, callback, lossless) { var delegator = new TelemetryDelegator($q), unsubscribePromise, + telemetryObjectPromise, latestValues = {}, telemetryObjects = [], pool = lossless ? new TelemetryQueue() : new TelemetryTable(), @@ -137,8 +138,8 @@ define( // will be unsubscribe functions. (This must be a promise // because delegation is supported, and retrieving delegate // telemetry-capable objects may be an asynchronous operation.) - unsubscribePromise = - promiseRelevantObjects(domainObject) + telemetryObjectPromise = promiseRelevantObjects(domainObject); + unsubscribePromise = telemetryObjectPromise .then(cacheObjectReferences) .then(subscribeAll); @@ -224,6 +225,17 @@ define( */ getMetadata: function () { return metadatas; + }, + /** + * Get a promise for all telemetry-providing objects + * associated with this subscription. + * @returns {Promise.} a promise for + * telemetry-providing objects + */ + promiseTelemetryObjects: function () { + // Unsubscribe promise is available after objects + // are loaded. + return telemetryObjectPromise; } }; }