ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-06-15 13:48:12 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Add time context to telemetry requests (#5887)

Browse Source 
* add time context to telemetry requests

* change to empty array

* refactor telemetry api to use time context

* removed unused function

* add tests

* add test, rename function

* make function public
This commit is contained in:
Scott Bell
2022-10-21 20:25:24 +02:00
committed by GitHub
parent bd1e869f6a
commit 9e23f79bc8
6 changed files with 181 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
src/api/telemetry/TelemetryAPI.js
View File

@ -27,7 +27,6 @@ import TelemetryMetadataManager from './TelemetryMetadataManager';
import TelemetryValueFormatter from './TelemetryValueFormatter'; import TelemetryValueFormatter from './TelemetryValueFormatter';
import DefaultMetadataProvider from './DefaultMetadataProvider'; import DefaultMetadataProvider from './DefaultMetadataProvider';
import objectUtils from 'objectUtils'; import objectUtils from 'objectUtils';
import _ from 'lodash';
export default class TelemetryAPI { export default class TelemetryAPI {
@ -73,7 +72,7 @@ export default class TelemetryAPI {
* @returns {boolean} true if the object is a telemetry object. * @returns {boolean} true if the object is a telemetry object.
*/ */
isTelemetryObject(domainObject) { isTelemetryObject(domainObject) {
return Boolean(this.findMetadataProvider(domainObject)); return Boolean(this.#findMetadataProvider(domainObject));
} }
/** /**
@ -87,7 +86,7 @@ export default class TelemetryAPI {
* @memberof module:openmct.TelemetryAPI~TelemetryProvider# * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
*/ */
canProvideTelemetry(domainObject) { canProvideTelemetry(domainObject) {
return Boolean(this.findSubscriptionProvider(domainObject)) return Boolean(this.#findSubscriptionProvider(domainObject))
|| Boolean(this.findRequestProvider(domainObject)); || Boolean(this.findRequestProvider(domainObject));
} }
@ -120,7 +119,7 @@ export default class TelemetryAPI {
/** /**
* @private * @private
*/ */
findSubscriptionProvider() { #findSubscriptionProvider() {
const args = Array.prototype.slice.apply(arguments); const args = Array.prototype.slice.apply(arguments);
function supportsDomainObject(provider) { function supportsDomainObject(provider) {
return provider.supportsSubscribe.apply(provider, args); return provider.supportsSubscribe.apply(provider, args);
@ -130,9 +129,10 @@ export default class TelemetryAPI {
} }
/** /**
* @private * Returns a telemetry request provider that supports
* a given domain object and options.
*/ */
findRequestProvider(domainObject) { findRequestProvider() {
const args = Array.prototype.slice.apply(arguments); const args = Array.prototype.slice.apply(arguments);
function supportsDomainObject(provider) { function supportsDomainObject(provider) {
return provider.supportsRequest.apply(provider, args); return provider.supportsRequest.apply(provider, args);
@ -144,7 +144,7 @@ export default class TelemetryAPI {
/** /**
* @private * @private
*/ */
findMetadataProvider(domainObject) { #findMetadataProvider(domainObject) {
return this.metadataProviders.filter(function (p) { return this.metadataProviders.filter(function (p) {
return p.supportsMetadata(domainObject); return p.supportsMetadata(domainObject);
})[0]; })[0];
@ -153,7 +153,7 @@ export default class TelemetryAPI {
/** /**
* @private * @private
*/ */
findLimitEvaluator(domainObject) { #findLimitEvaluator(domainObject) {
return this.limitProviders.filter(function (p) { return this.limitProviders.filter(function (p) {
return p.supportsLimits(domainObject); return p.supportsLimits(domainObject);
})[0]; })[0];
@ -161,6 +161,7 @@ export default class TelemetryAPI {
/** /**
* @private * @private
* Though used in TelemetryCollection as well
*/ */
standardizeRequestOptions(options) { standardizeRequestOptions(options) {
if (!Object.prototype.hasOwnProperty.call(options, 'start')) { if (!Object.prototype.hasOwnProperty.call(options, 'start')) {
@ -174,6 +175,10 @@ export default class TelemetryAPI {
if (!Object.prototype.hasOwnProperty.call(options, 'domain')) { if (!Object.prototype.hasOwnProperty.call(options, 'domain')) {
options.domain = this.openmct.time.timeSystem().key; options.domain = this.openmct.time.timeSystem().key;
} }
if (!Object.prototype.hasOwnProperty.call(options, 'timeContext')) {
options.timeContext = this.openmct.time;
}
} }
/** /**
@ -241,7 +246,7 @@ export default class TelemetryAPI {
/** /**
* Request historical telemetry for a domain object. * Request historical telemetry for a domain object.
* The `options` argument allows you to specify filters * The `options` argument allows you to specify filters
* (start, end, etc.), sort order, and strategies for retrieving * (start, end, etc.), sort order, time context, and strategies for retrieving
* telemetry (aggregation, latest available, etc.). * telemetry (aggregation, latest available, etc.).
* *
* @method request * @method request
@ -255,7 +260,7 @@ export default class TelemetryAPI {
*/ */
async request(domainObject) { async request(domainObject) {
if (this.noRequestProviderForAllObjects) { if (this.noRequestProviderForAllObjects) {
return Promise.resolve([]); return [];
} }
if (arguments.length === 1) { if (arguments.length === 1) {
@ -273,22 +278,24 @@ export default class TelemetryAPI {
if (!provider) { if (!provider) {
this.requestAbortControllers.delete(abortController); this.requestAbortControllers.delete(abortController);
return this.handleMissingRequestProvider(domainObject); return this.#handleMissingRequestProvider(domainObject);
} }
arguments[1] = await this.applyRequestInterceptors(domainObject, arguments[1]); arguments[1] = await this.applyRequestInterceptors(domainObject, arguments[1]);
try {
const telemetry = await provider.request(...arguments);
return provider.request.apply(provider, arguments) return telemetry;
.catch((rejected) => { } catch (error) {
if (rejected.name !== 'AbortError') { if (error.name !== 'AbortError') {
this.openmct.notifications.error('Error requesting telemetry data, see console for details'); this.openmct.notifications.error('Error requesting telemetry data, see console for details');
console.error(rejected); console.error(error);
} }
return Promise.reject(rejected); throw new Error(error);
}).finally(() => { } finally {
this.requestAbortControllers.delete(abortController); this.requestAbortControllers.delete(abortController);
}); }
} }
/** /**
@ -306,7 +313,7 @@ export default class TelemetryAPI {
* the subscription * the subscription
*/ */
subscribe(domainObject, callback, options) { subscribe(domainObject, callback, options) {
const provider = this.findSubscriptionProvider(domainObject); const provider = this.#findSubscriptionProvider(domainObject);
if (!this.subscribeCache) { if (!this.subscribeCache) {
this.subscribeCache = {}; this.subscribeCache = {};
@ -353,7 +360,7 @@ export default class TelemetryAPI {
*/ */
getMetadata(domainObject) { getMetadata(domainObject) {
if (!this.metadataCache.has(domainObject)) { if (!this.metadataCache.has(domainObject)) {
const metadataProvider = this.findMetadataProvider(domainObject); const metadataProvider = this.#findMetadataProvider(domainObject);
if (!metadataProvider) { if (!metadataProvider) {
return; return;
} }
@ -369,33 +376,6 @@ export default class TelemetryAPI {
return this.metadataCache.get(domainObject); return this.metadataCache.get(domainObject);
} }
/**
* Return an array of valueMetadatas that are common to all supplied
* telemetry objects and match the requested hints.
*
*/
commonValuesForHints(metadatas, hints) {
const options = metadatas.map(function (metadata) {
const values = metadata.valuesForHints(hints);
return _.keyBy(values, 'key');
}).reduce(function (a, b) {
const results = {};
Object.keys(a).forEach(function (key) {
if (Object.prototype.hasOwnProperty.call(b, key)) {
results[key] = a[key];
}
});
return results;
});
const sortKeys = hints.map(function (h) {
return 'hints.' + h;
});
return _.sortBy(options, sortKeys);
}
/** /**
* Get a value formatter for a given valueMetadata. * Get a value formatter for a given valueMetadata.
* *
@ -450,7 +430,7 @@ export default class TelemetryAPI {
* *
* @returns Promise * @returns Promise
*/ */
handleMissingRequestProvider(domainObject) { #handleMissingRequestProvider(domainObject) {
this.noRequestProviderForAllObjects = this.requestProviders.every(requestProvider => { this.noRequestProviderForAllObjects = this.requestProviders.every(requestProvider => {
const supportsRequest = requestProvider.supportsRequest.apply(requestProvider, arguments); const supportsRequest = requestProvider.supportsRequest.apply(requestProvider, arguments);
const hasRequestProvider = Object.prototype.hasOwnProperty.call(requestProvider, 'request') && typeof requestProvider.request === 'function'; const hasRequestProvider = Object.prototype.hasOwnProperty.call(requestProvider, 'request') && typeof requestProvider.request === 'function';
@ -540,7 +520,7 @@ export default class TelemetryAPI {
* @memberof module:openmct.TelemetryAPI~TelemetryProvider# * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
*/ */
getLimitEvaluator(domainObject) { getLimitEvaluator(domainObject) {
const provider = this.findLimitEvaluator(domainObject); const provider = this.#findLimitEvaluator(domainObject);
if (!provider) { if (!provider) {
return { return {
evaluate: function () {} evaluate: function () {}
@ -578,7 +558,7 @@ export default class TelemetryAPI {
* @memberof module:openmct.TelemetryAPI~TelemetryProvider# * @memberof module:openmct.TelemetryAPI~TelemetryProvider#
*/ */
getLimits(domainObject) { getLimits(domainObject) {
const provider = this.findLimitEvaluator(domainObject); const provider = this.#findLimitEvaluator(domainObject);
if (!provider || !provider.getLimits) { if (!provider || !provider.getLimits) {
return { return {
limits: function () { limits: function () {

224
src/api/telemetry/TelemetryAPISpec.js
View File

@ -23,11 +23,11 @@ import { createOpenMct, resetApplicationState } from 'utils/testing';
import TelemetryAPI from './TelemetryAPI'; import TelemetryAPI from './TelemetryAPI';
import TelemetryCollection from './TelemetryCollection'; import TelemetryCollection from './TelemetryCollection';
describe('Telemetry API', function () { describe('Telemetry API', () => {
let openmct; let openmct;
let telemetryAPI; let telemetryAPI;
beforeEach(function () { beforeEach(() => {
openmct = { openmct = {
time: jasmine.createSpyObj('timeAPI', [ time: jasmine.createSpyObj('timeAPI', [
'timeSystem', 'timeSystem',
@ -47,11 +47,11 @@ describe('Telemetry API', function () {
}); });
describe('telemetry providers', function () { describe('telemetry providers', () => {
let telemetryProvider; let telemetryProvider;
let domainObject; let domainObject;
beforeEach(function () { beforeEach(() => {
telemetryProvider = jasmine.createSpyObj('telemetryProvider', [ telemetryProvider = jasmine.createSpyObj('telemetryProvider', [
'supportsSubscribe', 'supportsSubscribe',
'subscribe', 'subscribe',
@ -73,19 +73,16 @@ describe('Telemetry API', function () {
}; };
}); });
it('provides consistent results without providers', function (done) { it('provides consistent results without providers', async () => {
const unsubscribe = telemetryAPI.subscribe(domainObject); const unsubscribe = telemetryAPI.subscribe(domainObject);
expect(unsubscribe).toEqual(jasmine.any(Function)); expect(unsubscribe).toEqual(jasmine.any(Function));
telemetryAPI.request(domainObject) const data = await telemetryAPI.request(domainObject);
.then((data) => { expect(data).toEqual([]);
expect(data).toEqual([]);
})
.finally(done);
}); });
it('skips providers that do not match', function (done) { it('skips providers that do not match', async () => {
telemetryProvider.supportsSubscribe.and.returnValue(false); telemetryProvider.supportsSubscribe.and.returnValue(false);
telemetryProvider.supportsRequest.and.returnValue(false); telemetryProvider.supportsRequest.and.returnValue(false);
telemetryProvider.request.and.returnValue(Promise.resolve([])); telemetryProvider.request.and.returnValue(Promise.resolve([]));
@ -98,14 +95,13 @@ describe('Telemetry API', function () {
expect(telemetryProvider.subscribe).not.toHaveBeenCalled(); expect(telemetryProvider.subscribe).not.toHaveBeenCalled();
expect(unsubscribe).toEqual(jasmine.any(Function)); expect(unsubscribe).toEqual(jasmine.any(Function));
telemetryAPI.request(domainObject).then((response) => { await telemetryAPI.request(domainObject);
expect(telemetryProvider.supportsRequest) expect(telemetryProvider.supportsRequest)
.toHaveBeenCalledWith(domainObject, jasmine.any(Object)); .toHaveBeenCalledWith(domainObject, jasmine.any(Object));
expect(telemetryProvider.request).not.toHaveBeenCalled(); expect(telemetryProvider.request).not.toHaveBeenCalled();
}).finally(done);
}); });
it('sends subscribe calls to matching providers', function () { it('sends subscribe calls to matching providers', () => {
const unsubFunc = jasmine.createSpy('unsubscribe'); const unsubFunc = jasmine.createSpy('unsubscribe');
telemetryProvider.subscribe.and.returnValue(unsubFunc); telemetryProvider.subscribe.and.returnValue(unsubFunc);
telemetryProvider.supportsSubscribe.and.returnValue(true); telemetryProvider.supportsSubscribe.and.returnValue(true);
@ -133,7 +129,7 @@ describe('Telemetry API', function () {
expect(callback).not.toHaveBeenCalledWith('otherValue'); expect(callback).not.toHaveBeenCalledWith('otherValue');
}); });
it('subscribes once per object', function () { it('subscribes once per object', () => {
const unsubFunc = jasmine.createSpy('unsubscribe'); const unsubFunc = jasmine.createSpy('unsubscribe');
telemetryProvider.subscribe.and.returnValue(unsubFunc); telemetryProvider.subscribe.and.returnValue(unsubFunc);
telemetryProvider.supportsSubscribe.and.returnValue(true); telemetryProvider.supportsSubscribe.and.returnValue(true);
@ -164,7 +160,7 @@ describe('Telemetry API', function () {
expect(callbacktwo).not.toHaveBeenCalledWith('anotherValue'); expect(callbacktwo).not.toHaveBeenCalledWith('anotherValue');
}); });
it('only deletes subscription cache when there are no more subscribers', function () { it('only deletes subscription cache when there are no more subscribers', () => {
const unsubFunc = jasmine.createSpy('unsubscribe'); const unsubFunc = jasmine.createSpy('unsubscribe');
telemetryProvider.subscribe.and.returnValue(unsubFunc); telemetryProvider.subscribe.and.returnValue(unsubFunc);
telemetryProvider.supportsSubscribe.and.returnValue(true); telemetryProvider.supportsSubscribe.and.returnValue(true);
@ -187,7 +183,7 @@ describe('Telemetry API', function () {
unsubscribeThree(); unsubscribeThree();
}); });
it('does subscribe/unsubscribe', function () { it('does subscribe/unsubscribe', () => {
const unsubFunc = jasmine.createSpy('unsubscribe'); const unsubFunc = jasmine.createSpy('unsubscribe');
telemetryProvider.subscribe.and.returnValue(unsubFunc); telemetryProvider.subscribe.and.returnValue(unsubFunc);
telemetryProvider.supportsSubscribe.and.returnValue(true); telemetryProvider.supportsSubscribe.and.returnValue(true);
@ -203,7 +199,7 @@ describe('Telemetry API', function () {
unsubscribe(); unsubscribe();
}); });
it('subscribes for different object', function () { it('subscribes for different object', () => {
const unsubFuncs = []; const unsubFuncs = [];
const notifiers = []; const notifiers = [];
telemetryProvider.supportsSubscribe.and.returnValue(true); telemetryProvider.supportsSubscribe.and.returnValue(true);
@ -243,120 +239,120 @@ describe('Telemetry API', function () {
expect(unsubFuncs[1]).toHaveBeenCalled(); expect(unsubFuncs[1]).toHaveBeenCalled();
}); });
it('sends requests to matching providers', function (done) { it('sends requests to matching providers', async () => {
const telemPromise = Promise.resolve([]); const telemPromise = Promise.resolve([]);
telemetryProvider.supportsRequest.and.returnValue(true); telemetryProvider.supportsRequest.and.returnValue(true);
telemetryProvider.request.and.returnValue(telemPromise); telemetryProvider.request.and.returnValue(telemPromise);
telemetryAPI.addProvider(telemetryProvider); telemetryAPI.addProvider(telemetryProvider);
telemetryAPI.request(domainObject).then(() => { await telemetryAPI.request(domainObject);
expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith( expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith(
domainObject, domainObject,
jasmine.any(Object) jasmine.any(Object)
); );
expect(telemetryProvider.request).toHaveBeenCalledWith( expect(telemetryProvider.request).toHaveBeenCalledWith(
domainObject, domainObject,
jasmine.any(Object) jasmine.any(Object)
); );
}).finally(done);
}); });
it('generates default request options', function (done) { it('generates default request options', async () => {
telemetryProvider.supportsRequest.and.returnValue(true); telemetryProvider.supportsRequest.and.returnValue(true);
telemetryProvider.request.and.returnValue(Promise.resolve([])); telemetryProvider.request.and.returnValue(Promise.resolve([]));
telemetryAPI.addProvider(telemetryProvider); telemetryAPI.addProvider(telemetryProvider);
telemetryAPI.request(domainObject).then(() => { await telemetryAPI.request(domainObject);
const { signal } = new AbortController(); const { signal } = new AbortController();
expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith( expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith(
jasmine.any(Object), jasmine.any(Object),
{ {
signal, signal,
start: 0, start: 0,
end: 1, end: 1,
domain: 'system' domain: 'system',
} timeContext: jasmine.any(Object)
); }
);
expect(telemetryProvider.request).toHaveBeenCalledWith( expect(telemetryProvider.request).toHaveBeenCalledWith(
jasmine.any(Object), jasmine.any(Object),
{ {
signal, signal,
start: 0, start: 0,
end: 1, end: 1,
domain: 'system' domain: 'system',
} timeContext: jasmine.any(Object)
); }
);
telemetryProvider.supportsRequest.calls.reset(); telemetryProvider.supportsRequest.calls.reset();
telemetryProvider.request.calls.reset(); telemetryProvider.request.calls.reset();
telemetryAPI.request(domainObject, {}).then(() => { await telemetryAPI.request(domainObject, {});
expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith( expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith(
jasmine.any(Object), jasmine.any(Object),
{ {
signal, signal,
start: 0, start: 0,
end: 1, end: 1,
domain: 'system' domain: 'system',
} timeContext: jasmine.any(Object)
); }
);
expect(telemetryProvider.request).toHaveBeenCalledWith(
jasmine.any(Object),
{
signal,
start: 0,
end: 1,
domain: 'system'
}
);
});
}).finally(done);
expect(telemetryProvider.request).toHaveBeenCalledWith(
jasmine.any(Object),
{
signal,
start: 0,
end: 1,
domain: 'system',
timeContext: jasmine.any(Object)
}
);
}); });
it('do not overwrite existing request options', function (done) { it('do not overwrite existing request options', async () => {
telemetryProvider.supportsRequest.and.returnValue(true); telemetryProvider.supportsRequest.and.returnValue(true);
telemetryProvider.request.and.returnValue(Promise.resolve([])); telemetryProvider.request.and.returnValue(Promise.resolve([]));
telemetryAPI.addProvider(telemetryProvider); telemetryAPI.addProvider(telemetryProvider);
telemetryAPI.request(domainObject, { await telemetryAPI.request(domainObject, {
start: 20, start: 20,
end: 30, end: 30,
domain: 'someDomain' domain: 'someDomain'
}).then(() => { });
const { signal } = new AbortController(); const { signal } = new AbortController();
expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith( expect(telemetryProvider.supportsRequest).toHaveBeenCalledWith(
jasmine.any(Object), jasmine.any(Object),
{ {
start: 20, start: 20,
end: 30, end: 30,
domain: 'someDomain', domain: 'someDomain',
signal signal,
} timeContext: jasmine.any(Object)
); }
);
expect(telemetryProvider.request).toHaveBeenCalledWith( expect(telemetryProvider.request).toHaveBeenCalledWith(
jasmine.any(Object), jasmine.any(Object),
{ {
start: 20, start: 20,
end: 30, end: 30,
domain: 'someDomain', domain: 'someDomain',
signal signal,
} timeContext: jasmine.any(Object)
); }
);
}).finally(done);
}); });
}); });
describe('metadata', function () { describe('metadata', () => {
let mockMetadata = {}; let mockMetadata = {};
let mockObjectType = { let mockObjectType = {
definition: {} definition: {}
}; };
beforeEach(function () { beforeEach(() => {
telemetryAPI.addProvider({ telemetryAPI.addProvider({
key: 'mockMetadataProvider', key: 'mockMetadataProvider',
supportsMetadata() { supportsMetadata() {
@ -369,7 +365,7 @@ describe('Telemetry API', function () {
openmct.types.get.and.returnValue(mockObjectType); openmct.types.get.and.returnValue(mockObjectType);
}); });
it('respects explicit priority', function () { it('respects explicit priority', () => {
mockMetadata.values = [ mockMetadata.values = [
{ {
key: "name", key: "name",
@ -408,7 +404,7 @@ describe('Telemetry API', function () {
expect(value.hints.priority).toBe(index + 1); expect(value.hints.priority).toBe(index + 1);
}); });
}); });
it('if no explicit priority, defaults to order defined', function () { it('if no explicit priority, defaults to order defined', () => {
mockMetadata.values = [ mockMetadata.values = [
{ {
key: "name", key: "name",
@ -435,7 +431,7 @@ describe('Telemetry API', function () {
expect(value.key).toBe(mockMetadata.values[index].key); expect(value.key).toBe(mockMetadata.values[index].key);
}); });
}); });
it('respects domain priority', function () { it('respects domain priority', () => {
mockMetadata.values = [ mockMetadata.values = [
{ {
key: "name", key: "name",
@ -477,7 +473,7 @@ describe('Telemetry API', function () {
expect(values[0].key).toBe('timestamp-local'); expect(values[0].key).toBe('timestamp-local');
expect(values[1].key).toBe('timestamp-utc'); expect(values[1].key).toBe('timestamp-utc');
}); });
it('respects range priority', function () { it('respects range priority', () => {
mockMetadata.values = [ mockMetadata.values = [
{ {
key: "name", key: "name",
@ -519,7 +515,7 @@ describe('Telemetry API', function () {
expect(values[0].key).toBe('cos'); expect(values[0].key).toBe('cos');
expect(values[1].key).toBe('sin'); expect(values[1].key).toBe('sin');
}); });
it('respects priority and domain ordering', function () { it('respects priority and domain ordering', () => {
mockMetadata.values = [ mockMetadata.values = [
{ {
key: "id", key: "id",
@ -588,7 +584,7 @@ describe('Telemetry API', function () {
definition: {} definition: {}
}; };
beforeEach(function () { beforeEach(() => {
openmct.telemetry = telemetryAPI; openmct.telemetry = telemetryAPI;
telemetryAPI.addProvider({ telemetryAPI.addProvider({
key: 'mockMetadataProvider', key: 'mockMetadataProvider',
@ -644,16 +640,14 @@ describe('Telemetery', () => {
return resetApplicationState(openmct); return resetApplicationState(openmct);
}); });
it('should not abort request without navigation', function (done) { it('should not abort request without navigation', async () => {
telemetryAPI.addProvider(telemetryProvider); telemetryAPI.addProvider(telemetryProvider);
telemetryAPI.request({}).finally(() => { await telemetryAPI.request({});
expect(watchedSignal.aborted).toBe(false); expect(watchedSignal.aborted).toBe(false);
done();
});
}); });
it('should abort request on navigation', function (done) { it('should abort request on navigation', (done) => {
telemetryAPI.addProvider(telemetryProvider); telemetryAPI.addProvider(telemetryProvider);
telemetryAPI.request({}).finally(() => { telemetryAPI.request({}).finally(() => {

19
src/api/time/TimeAPISpec.js
View File

@ -229,6 +229,25 @@ describe("The Time API", function () {
expect(api.clock()).toBeUndefined(); expect(api.clock()).toBeUndefined();
}); });
it('Provides a default time context', () => {
const timeContext = api.getContextForView([]);
expect(timeContext).not.toBe(null);
});
it("Without a clock, is in fixed time mode", () => {
const timeContext = api.getContextForView([]);
expect(timeContext.isRealTime()).toBe(false);
});
it("Provided a clock, is in real-time mode", () => {
const timeContext = api.getContextForView([]);
timeContext.clock('mts', {
start: 0,
end: 1
});
expect(timeContext.isRealTime()).toBe(true);
});
}); });
it("on tick, observes offsets, and indicates tick in bounds callback", function () { it("on tick, observes offsets, and indicates tick in bounds callback", function () {

12
src/api/time/TimeContext.js
View File

@ -362,6 +362,18 @@ class TimeContext extends EventEmitter {
this.boundsVal = newBounds; this.boundsVal = newBounds;
this.emit('bounds', this.boundsVal, true); this.emit('bounds', this.boundsVal, true);
} }
/**
* Checks if this time context is in real-time mode or not.
* @returns {boolean} true if this context is in real-time mode, false if not
*/
isRealTime() {
if (this.clock()) {
return true;
}
return false;
}
} }
export default TimeContext; export default TimeContext;

5
src/plugins/LADTable/components/LADRow.vue
View File

@ -114,6 +114,8 @@ export default {
this.formats = this.openmct.telemetry.getFormatMap(this.metadata); this.formats = this.openmct.telemetry.getFormatMap(this.metadata);
this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier); this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
this.timeContext = this.openmct.time.getContextForView(this.objectPath);
this.limitEvaluator = this.openmct this.limitEvaluator = this.openmct
.telemetry .telemetry
.limitEvaluator(this.domainObject); .limitEvaluator(this.domainObject);
@ -134,7 +136,8 @@ export default {
this.telemetryCollection = this.openmct.telemetry.requestCollection(this.domainObject, { this.telemetryCollection = this.openmct.telemetry.requestCollection(this.domainObject, {
size: 1, size: 1,
strategy: 'latest' strategy: 'latest',
timeContext: this.timeContext
}); });
this.telemetryCollection.on('add', this.setLatestValues); this.telemetryCollection.on('add', this.setLatestValues);
this.telemetryCollection.on('clear', this.resetValues); this.telemetryCollection.on('clear', this.resetValues);

5
src/plugins/displayLayout/components/TelemetryView.vue
View File

@ -282,12 +282,15 @@ export default {
this.limitEvaluator = this.openmct.telemetry.limitEvaluator(this.domainObject); this.limitEvaluator = this.openmct.telemetry.limitEvaluator(this.domainObject);
this.formats = this.openmct.telemetry.getFormatMap(this.metadata); this.formats = this.openmct.telemetry.getFormatMap(this.metadata);
this.timeContext = this.openmct.time.getContextForView(this.objectPath);
const valueMetadata = this.metadata ? this.metadata.value(this.item.value) : {}; const valueMetadata = this.metadata ? this.metadata.value(this.item.value) : {};
this.customStringformatter = this.openmct.telemetry.customStringFormatter(valueMetadata, this.item.format); this.customStringformatter = this.openmct.telemetry.customStringFormatter(valueMetadata, this.item.format);
this.telemetryCollection = this.openmct.telemetry.requestCollection(this.domainObject, { this.telemetryCollection = this.openmct.telemetry.requestCollection(this.domainObject, {
size: 1, size: 1,
strategy: 'latest' strategy: 'latest',
timeContext: this.timeContext
}); });
this.telemetryCollection.on('add', this.setLatestValues); this.telemetryCollection.on('add', this.setLatestValues);
this.telemetryCollection.on('clear', this.refreshData); this.telemetryCollection.on('clear', this.refreshData);