@dronedeploy/rocos-js-sdk 3.0.1-alpha.1 → 3.0.1-alpha.11

package/cjs/services/StreamService.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamService = void 0;
+const api_1 = require("../constants/api");
+const RocosError_1 = require("../models/RocosError");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const Stream_1 = require("../models/Stream");
+const StreamSource_1 = require("../models/StreamSource");
+const cleanObject_1 = require("../helpers/cleanObject");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`StreamService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.STREAM_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a new stream.
+     *
+     * @param projectId - Project Id
+     * @param stream - Stream object
+     */
+    // TODO: map the response object
+    async create(projectId, stream) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), (0, cleanObject_1.cleanObject)(new Stream_1.Stream(stream)), `Failed to create stream for ${projectId}.`);
+    }
+    /**
+     * Get streams list by project id.
+     */
+    async list(projectId) {
+        const data = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get streams for ${projectId}.`);
+        return data.map((stream) => (0, cleanObject_1.cleanObject)(new Stream_1.Stream(stream)));
+    }
+    /**
+     * Get stream information by project id and stream id.
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     */
+    async info(projectId, streamId) {
+        const data = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_ID_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to get stream for ${projectId}, streamId ${streamId}.`);
+        return (0, cleanObject_1.cleanObject)(new Stream_1.Stream(data));
+    }
+    /**
+     * Add new data to the stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param sources - Payload {@link IStreamSource[]}
+     */
+    // TODO: map the response object
+    async addData(projectId, streamId, sources) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), { data: sources.map((source) => (0, cleanObject_1.cleanObject)(new StreamSource_1.StreamSource(source))) }, `Failed add data to stream for ${projectId}, streamId ${streamId}.`);
+    }
+    /**
+     * Get sources for stream.
+     */
+    async sources() {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_SOURCE_URL, { url: this.config.url }, this.config.insecure), 'Failed to get sources for stream.');
+    }
+    /**
+     * Get source info
+     *
+     * @param sourceId - Source Id
+     */
+    async sourceInfo(sourceId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_SOURCE_ID_URL, { url: this.config.url, sourceId }, this.config.insecure), `Failed add et source info for ${sourceId}.`);
+    }
+    /**
+     * Get streams list of robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot's Callsign
+     */
+    async streamsForRobot(projectId, callsign) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_CALLSIGN_STREAM_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed get streams for ${projectId}, callsign ${callsign}.`);
+    }
+    /**
+     * Bind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should bind with stream
+     */
+    // TODO: map the response object
+    async bindRobot(projectId, streamId, callsigns) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), callsigns, `Failed to bind robot with stream for ${projectId}, streamId ${streamId}.`);
+    }
+    /**
+     * Unbind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should unbind with stream
+     */
+    // TODO: map the response object
+    async unbindRobot(projectId, streamId, callsigns) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to unbind robot with stream for ${projectId}, streamId ${streamId}.`, callsigns);
+    }
+    /**
+     * Remove streams by list
+     *
+     * @param projectId - Project Id
+     * @param streamIds - Stream Ids
+     */
+    // TODO: map the response object
+    async removeStreams(projectId, streamIds) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to remove stream for ${projectId}.`, streamIds);
+    }
+    /**
+     * Remove stream data by dataIds list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param dataIds - Data Ids, e.g. {sourceId: string, dataId: string}
+     */
+    // TODO: map the response object
+    async removeStreamData(projectId, streamId, dataIds) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, dataIds);
+    }
+    /**
+     * Remove stream data by ids list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param ids - ids list (string[])
+     */
+    // TODO: map the response object
+    async removeStreamDataByIds(projectId, streamId, ids) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, ids);
+    }
+    /**
+     * Get stream data exporter templates list
+     */
+    // TODO: map the response object
+    async dataExporterTemplates() {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_TEMPLATE_EXPORTER_URL, { url: this.config.url }, this.config.insecure), 'Failed to get data exporters.');
+    }
+}
+exports.StreamService = StreamService;

package/cjs/services/TelemetryService.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { CallsignStatus, IRocosSDKConfig, IRocosTelemetryMessage, IStreamStatusMessage, ITelemetryStream, ITelemetryStreamConfig, ITelemetrySubscriptionParams, ITelemetrySubscriptions } from '../models';
+import { BaseStreamService } from './BaseStreamService';
+export declare class TelemetryService extends BaseStreamService<ITelemetryStream, ITelemetryStreamConfig> {
+    private statusSubscription;
+    private changeStream$;
+    private streamStatusSubject$;
+    constructor(config: IRocosSDKConfig);
+    /**
+     * The main method for subscribing to telemetry messages
+     *
+     * @param params - Subscription params
+     *
+     * @returns An Observable that outputs telemetry messages
+     */
+    subscribe<R = unknown>(params: ITelemetrySubscriptionParams): Observable<IRocosTelemetryMessage<'json', R>>;
+    /**
+     * A method to keep track of the current subscriptions
+     *
+     * @returns An Observable that outputs subscription changes
+     */
+    getSubscriptionChanges(): Observable<ITelemetrySubscriptions>;
+    /**
+     * A method to keep track of the stream status
+     *
+     * @returns An Observable that outputs stream status
+     */
+    getStatusChanges(): Observable<IStreamStatusMessage>;
+    /**
+     * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     * @param projectId
+     * @param callsign
+     * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
+     */
+    getRobotStatusChanges(projectId: string, callsign: string, heartbeatTimeoutMs?: number, intervalMs?: number): Observable<CallsignStatus>;
+    protected initStream(stream: ITelemetryStream): Promise<void>;
+    private buildScope;
+    private createStream;
+    protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
+}

package/cjs/services/TelemetryService.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryService = void 0;
+const rxjs_1 = require("rxjs");
+const models_1 = require("../models");
+const operators_1 = require("rxjs/operators");
+const BaseStreamService_1 = require("./BaseStreamService");
+const identifier_1 = require("../constants/identifier");
+const RocosStore_1 = require("../store/RocosStore");
+const TelemetryStream_1 = require("../api/streams/telemetry/TelemetryStream");
+const arrayUnique_1 = require("../helpers/arrayUnique");
+const flattenCallsignsLookup_1 = require("../helpers/flattenCallsignsLookup");
+const getUniqueId_1 = require("../helpers/getUniqueId");
+const HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+const HEARTBEAT_TIMEOUT = 5000; // if no heartbeat within 5 seconds then the robot is considered dead
+class TelemetryService extends BaseStreamService_1.BaseStreamService {
+    constructor(config) {
+        super('TelemetryService', config);
+        this.changeStream$ = new rxjs_1.BehaviorSubject(new Map());
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe((0, operators_1.filter)((message) => {
+            return message.type === 'telemetry-subscription' && message.url === this.config.url;
+        }))
+            .subscribe((msg) => {
+            this.changeStream$.next(msg.data);
+        });
+        this.streamStatusSubject$ = new rxjs_1.BehaviorSubject({
+            scope: 'default',
+            status: models_1.SubscriberStatusEnum.STOPPED,
+        });
+    }
+    /**
+     * The main method for subscribing to telemetry messages
+     *
+     * @param params - Subscription params
+     *
+     * @returns An Observable that outputs telemetry messages
+     */
+    subscribe(params) {
+        const sources = (0, arrayUnique_1.arrayUnique)(params.sources).map((item) => item.trim()) ?? [];
+        if (!params?.callsigns && params?.query) {
+            this.logger.error('Error: params need to contain either callsigns or query', params);
+            throw new models_1.RocosError('Params need to contain either callsigns or query.', models_1.errorCodes.TELEMETRY_SERVICE_ERROR);
+        }
+        let callsignsLookup = new models_1.CallsignsLookup([]);
+        if (params?.callsigns) {
+            this.logger.info('subscribe with callsigns', params);
+            callsignsLookup = new models_1.CallsignsLookup(params.callsigns);
+        }
+        else if (params?.query) {
+            this.logger.info('subscribe with query', params);
+            callsignsLookup = new models_1.CallsignsLookup(params.query);
+        }
+        // scope is used as a key to generate unique streams
+        // ideally there should be just one concurrent stream opened
+        const scope = this.buildScope(params, callsignsLookup);
+        const callsigns = callsignsLookup.lookupValue;
+        const subscriptionParams = {
+            uniqueId: (0, getUniqueId_1.getUniqueId)(params.projectId, callsignsLookup, sources, scope),
+            callsigns: callsignsLookup?.lookupType === models_1.CallsignsLookupType.List ? callsignsLookup.lookupValue : [],
+            sources,
+        };
+        const stream = this.createStream(params.projectId, callsignsLookup, sources, scope).then((stream) => {
+            stream.addSubscription(subscriptionParams);
+            if (!this.statusSubscription) {
+                this.statusSubscription = stream.statusStream$.subscribe((msg) => {
+                    this.status = msg === models_1.SubscriberStatusEnum.STOPPED || msg === models_1.SubscriberStatusEnum.ALIVE;
+                    this.status$.next(msg);
+                });
+            }
+            return (0, rxjs_1.from)(stream.messageStream$).pipe((0, operators_1.finalize)(() => stream?.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+        });
+        return (0, rxjs_1.from)(stream).pipe((0, rxjs_1.mergeAll)(), (0, operators_1.filter)((message) => {
+            return callsigns.includes(message.callsign) && sources.includes(message.source);
+        }));
+    }
+    /**
+     * A method to keep track of the current subscriptions
+     *
+     * @returns An Observable that outputs subscription changes
+     */
+    getSubscriptionChanges() {
+        return this.changeStream$.asObservable();
+    }
+    /**
+     * A method to keep track of the stream status
+     *
+     * @returns An Observable that outputs stream status
+     */
+    getStatusChanges() {
+        return this.streamStatusSubject$.asObservable();
+    }
+    /**
+     * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     * @param projectId
+     * @param callsign
+     * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
+     */
+    getRobotStatusChanges(projectId, callsign, heartbeatTimeoutMs = HEARTBEAT_TIMEOUT, intervalMs = 2000) {
+        const startedAt = Date.now();
+        const heartbeatTime$ = this.subscribe({
+            projectId,
+            sources: [HEARTBEAT_SOURCE],
+            callsigns: [callsign],
+        }).pipe((0, rxjs_1.map)(() => Date.now()));
+        return (0, rxjs_1.combineLatest)([heartbeatTime$.pipe((0, rxjs_1.startWith)(startedAt)), (0, rxjs_1.interval)(intervalMs)]).pipe((0, rxjs_1.map)(([lastHeartbeat, _]) => {
+            const now = Date.now();
+            // If we haven't received a heartbeat, but we've only just started
+            if (lastHeartbeat === startedAt && now - startedAt <= heartbeatTimeoutMs) {
+                return models_1.CallsignStatus.UNKNOWN;
+            }
+            if (now - lastHeartbeat > heartbeatTimeoutMs) {
+                return models_1.CallsignStatus.OFFLINE;
+            }
+            return models_1.CallsignStatus.ONLINE;
+        }), (0, rxjs_1.startWith)(models_1.CallsignStatus.UNKNOWN), (0, rxjs_1.distinctUntilChanged)(), (0, rxjs_1.catchError)(() => (0, rxjs_1.of)(models_1.CallsignStatus.ERROR)));
+    }
+    async initStream(stream) {
+        await super.initStream(stream);
+        stream.init();
+    }
+    buildScope(params, callsignsLookup) {
+        // prefix with project id to avoid stream instance to be shared across projects
+        if (params.scope)
+            return `${params.projectId}-${params.scope}`;
+        this.logger.debug('No scope is set, generating default');
+        if (callsignsLookup)
+            return `${params.projectId}-default-${(0, flattenCallsignsLookup_1.flattenCallsignsLookup)(callsignsLookup).join()}`;
+        return `${params.projectId}-default`;
+    }
+    async createStream(projectId, callsignsLookup, sources, scope) {
+        const newStream = await this.createStreamFromConfig(identifier_1.IDENTIFIER_NAME_TELEMETRY, {
+            url: this.config.url,
+            projectId,
+            callsignsLookup,
+            sources,
+            token: this.config.token,
+            scope: scope ?? 'default',
+            options: this.config.options,
+            port: this.config.port,
+            insecure: this.config.insecure,
+        });
+        if (!newStream.isNew) {
+            newStream.stream.statusStream$.subscribe((msg) => {
+                this.streamStatusSubject$.next({
+                    scope,
+                    status: msg,
+                });
+            });
+        }
+        return newStream.stream;
+    }
+    getStream(config) {
+        return new TelemetryStream_1.TelemetryStream(config);
+    }
+}
+exports.TelemetryService = TelemetryService;

package/cjs/services/TelemetryService.spec.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../models");
+const rxjs_1 = require("rxjs");
+const TelemetryService_1 = require("./TelemetryService");
+describe('TelemetryService', () => {
+    describe('getRobotStatusChanges', () => {
+        it('should emit unknown to begin with', async () => {
+            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue(rxjs_1.NEVER);
+            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign').pipe((0, rxjs_1.take)(1)));
+            expect(lastValue).toEqual(models_1.CallsignStatus.UNKNOWN);
+        });
+        it('should emit online if the robot emits a heartbeat', async () => {
+            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest
+                .spyOn(service, 'subscribe')
+                .mockReturnValue((0, rxjs_1.from)([0, 1, 2, 3, 4]).pipe((0, rxjs_1.delay)(100)));
+            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 1000, 10).pipe((0, rxjs_1.take)(2)));
+            expect(lastValue).toEqual(models_1.CallsignStatus.ONLINE);
+        }, 10000);
+        it('should emit offline if the robot never emits', async () => {
+            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue(rxjs_1.NEVER);
+            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe((0, rxjs_1.take)(2)));
+            expect(lastValue).toEqual(models_1.CallsignStatus.OFFLINE);
+        });
+        it('should emit an error if the telemetry errors', async () => {
+            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue((0, rxjs_1.throwError)(() => new Error('test')));
+            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe((0, rxjs_1.take)(2)));
+            expect(lastValue).toEqual(models_1.CallsignStatus.ERROR);
+        });
+    });
+});

package/cjs/services/TelemetryServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryServiceNode = void 0;
+const TelemetryService_1 = require("./TelemetryService");
+const TelemetryStreamNode_1 = require("../api/streams/telemetry/TelemetryStreamNode");
+class TelemetryServiceNode extends TelemetryService_1.TelemetryService {
+    getStream(config) {
+        return new TelemetryStreamNode_1.TelemetryStreamNode(config);
+    }
+}
+exports.TelemetryServiceNode = TelemetryServiceNode;

package/cjs/services/TimeSyncerService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSyncerService = void 0;
+const RocosError_1 = require("../models/RocosError");
+const api_1 = require("../constants/api");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class TimeSyncerService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`TimeSyncerService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.TIME_SYNCER_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Get Server Time
+     */
+    getServerTime() {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_SERVER_TIME_URL, { url: this.config.url }, this.config.insecure), 'Failed to get server time.');
+    }
+}
+exports.TimeSyncerService = TimeSyncerService;