@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.19

package/services/SpotProvisioningServiceNode.js

@@ -0,0 +1,43 @@
+import { RocosError, errorCodes } from '../models';
+import { API_SPOTTY_URL } from '../constants/api';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { RocosStore } from '../store/RocosStore';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class SpotProvisioningServiceNode extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`SpotService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.SPOT_SERVICE_ERROR);
+    }
+    async getSpotCoreImage(projectId, profileId, robot, tag = 'stable', patMetadata, timezone) {
+        const userService = RocosStore.getSDKInstance(this.config).getUserService();
+        const pat = await userService.createPAT({
+            name: `Spot provisioning token for ${robot.callsign}`,
+            projectId,
+            scope: ['provisioning'],
+            robotDefinitionId: profileId,
+            metaData: {
+                defaultRobotDefinitionId: profileId,
+                singleUse: true,
+                ...patMetadata,
+            },
+            ttlDays: 90,
+        });
+        return this.callPost(formatServiceUrl(API_SPOTTY_URL, { url: this.config.url }, this.config.insecure), {
+            pat: pat.pat,
+            callsign: robot.callsign,
+            robotName: robot.name,
+            project: projectId,
+            agentImageTag: tag,
+            timezone,
+        }, 'Failed to get image.', {
+            responseType: 'stream',
+        });
+    }
+}

package/services/StreamService.d.ts

@@ -0,0 +1,98 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { ISource } from '../models/ISource';
+import { IStream } from '../models/IStream';
+import { IStreamSource } from '../models/IStreamSource';
+export declare class StreamService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Create a new stream.
+     *
+     * @param projectId - Project Id
+     * @param stream - Stream object
+     */
+    create(projectId: string, stream: IStream): Promise<any>;
+    /**
+     * Get streams list by project id.
+     */
+    list(projectId: string): Promise<IStream[]>;
+    /**
+     * Get stream information by project id and stream id.
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     */
+    info(projectId: string, streamId: string): Promise<IStream>;
+    /**
+     * Add new data to the stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param sources - Payload {@link IStreamSource[]}
+     */
+    addData(projectId: string, streamId: string, sources: IStreamSource[]): Promise<any>;
+    /**
+     * Get sources for stream.
+     */
+    sources(): Promise<ISource[]>;
+    /**
+     * Get source info
+     *
+     * @param sourceId - Source Id
+     */
+    sourceInfo(sourceId: string): Promise<ISource>;
+    /**
+     * Get streams list of robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot's Callsign
+     */
+    streamsForRobot(projectId: string, callsign: string): Promise<IStream[]>;
+    /**
+     * Bind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should bind with stream
+     */
+    bindRobot(projectId: string, streamId: string, callsigns: string[]): Promise<any>;
+    /**
+     * Unbind robot with stream
+     *
+     * @param projectId - Project Id
+     * @param streamId - Steam Id
+     * @param callsigns - The Robots' callsigns which should unbind with stream
+     */
+    unbindRobot(projectId: string, streamId: string, callsigns: string[]): Promise<any>;
+    /**
+     * Remove streams by list
+     *
+     * @param projectId - Project Id
+     * @param streamIds - Stream Ids
+     */
+    removeStreams(projectId: string, streamIds: string[]): Promise<any>;
+    /**
+     * Remove stream data by dataIds list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param dataIds - Data Ids, e.g. {sourceId: string, dataId: string}
+     */
+    removeStreamData(projectId: string, streamId: string, dataIds: any[]): Promise<any>;
+    /**
+     * Remove stream data by ids list
+     *
+     * @param projectId - Project Id
+     * @param streamId - Stream Id
+     * @param ids - ids list (string[])
+     */
+    removeStreamDataByIds(projectId: string, streamId: string, ids: string[]): Promise<any>;
+    /**
+     * Get stream data exporter templates list
+     */
+    dataExporterTemplates(): Promise<any>;
+}

package/services/StreamService.js

@@ -0,0 +1,142 @@
+import { API_PROJECT_CALLSIGN_STREAM_URL, API_PROJECT_STREAM_CALLSIGN_URL, API_PROJECT_STREAM_DATA_URL, API_PROJECT_STREAM_ID_URL, API_PROJECT_STREAM_URL, API_SOURCE_ID_URL, API_SOURCE_URL, API_TEMPLATE_EXPORTER_URL, } from '../constants/api';
+import { RocosError, errorCodes } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { Stream } from '../models/Stream';
+import { StreamSource } from '../models/StreamSource';
+import { cleanObject } from '../helpers/cleanObject';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class StreamService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`StreamService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError(e, 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(formatServiceUrl(API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), cleanObject(new Stream(stream)), `Failed to create stream for ${projectId}.`);
+    }
+    /**
+     * Get streams list by project id.
+     */
+    async list(projectId) {
+        const data = await this.callGet(formatServiceUrl(API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get streams for ${projectId}.`);
+        return data.map((stream) => cleanObject(new 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(formatServiceUrl(API_PROJECT_STREAM_ID_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to get stream for ${projectId}, streamId ${streamId}.`);
+        return cleanObject(new 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(formatServiceUrl(API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), { data: sources.map((source) => cleanObject(new StreamSource(source))) }, `Failed add data to stream for ${projectId}, streamId ${streamId}.`);
+    }
+    /**
+     * Get sources for stream.
+     */
+    async sources() {
+        return this.callGet(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(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(formatServiceUrl(API_TEMPLATE_EXPORTER_URL, { url: this.config.url }, this.config.insecure), 'Failed to get data exporters.');
+    }
+}

package/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(params: ITelemetrySubscriptionParams): Observable<IRocosTelemetryMessage>;
+    /**
+     * 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/services/TelemetryService.js

@@ -0,0 +1,154 @@
+import { BehaviorSubject, catchError, combineLatest, distinctUntilChanged, from, interval, map, mergeAll, of, startWith, } from 'rxjs';
+import { CallsignsLookup, CallsignsLookupType, CallsignStatus, errorCodes, RocosError, SubscriberStatusEnum, } from '../models';
+import { filter, finalize } from 'rxjs/operators';
+import { BaseStreamService } from './BaseStreamService';
+import { IDENTIFIER_NAME_TELEMETRY } from '../constants/identifier';
+import { RocosStore } from '../store/RocosStore';
+import { TelemetryStream } from '../api/streams/telemetry/TelemetryStream';
+import { arrayUnique } from '../helpers/arrayUnique';
+import { getUniqueId } from '../helpers/getUniqueId';
+import { flattenCallsignsLookup } from '../helpers/flattenCallsignsLookup';
+const HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+const HEARTBEAT_TIMEOUT = 5000; // if no heartbeat within 5 seconds then the robot is considered dead
+export class TelemetryService extends BaseStreamService {
+    constructor(config) {
+        super('TelemetryService', config);
+        this.changeStream$ = new BehaviorSubject(new Map());
+        RocosStore.getChangeSubject()
+            .pipe(filter((message) => {
+            return message.type === 'telemetry-subscription' && message.url === this.config.url;
+        }))
+            .subscribe((msg) => {
+            this.changeStream$.next(msg.data);
+        });
+        this.streamStatusSubject$ = new BehaviorSubject({
+            scope: 'default',
+            status: 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 = 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 RocosError('Params need to contain either callsigns or query.', errorCodes.TELEMETRY_SERVICE_ERROR);
+        }
+        let callsignsLookup = new CallsignsLookup([]);
+        if (params?.callsigns) {
+            this.logger.info('subscribe with callsigns', params);
+            callsignsLookup = new CallsignsLookup(params.callsigns);
+        }
+        else if (params?.query) {
+            this.logger.info('subscribe with query', params);
+            callsignsLookup = new 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: getUniqueId(params.projectId, callsignsLookup, sources, scope),
+            callsigns: callsignsLookup?.lookupType === 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 === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
+                    this.status$.next(msg);
+                });
+            }
+            return from(stream.messageStream$).pipe(finalize(() => stream?.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+        });
+        return from(stream).pipe(mergeAll(), 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(map(() => Date.now()));
+        return combineLatest([heartbeatTime$.pipe(startWith(startedAt)), interval(intervalMs)]).pipe(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 CallsignStatus.UNKNOWN;
+            }
+            if (now - lastHeartbeat > heartbeatTimeoutMs) {
+                return CallsignStatus.OFFLINE;
+            }
+            return CallsignStatus.ONLINE;
+        }), startWith(CallsignStatus.UNKNOWN), distinctUntilChanged(), catchError(() => of(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-${flattenCallsignsLookup(callsignsLookup).join()}`;
+        return `${params.projectId}-default`;
+    }
+    async createStream(projectId, callsignsLookup, sources, scope) {
+        const newStream = await this.createStreamFromConfig(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(config);
+    }
+}

package/services/TelemetryService.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/services/TelemetryService.spec.js

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

package/services/TelemetryServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { ITelemetryStream } from '../models/stream/ITelemetryStream';
+import { ITelemetryStreamConfig } from '../models/ITelemetryStreamConfig';
+import { TelemetryService } from './TelemetryService';
+export declare class TelemetryServiceNode extends TelemetryService {
+    protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
+}

package/services/TelemetryServiceNode.js

@@ -0,0 +1,7 @@
+import { TelemetryService } from './TelemetryService';
+import { TelemetryStreamNode } from '../api/streams/telemetry/TelemetryStreamNode';
+export class TelemetryServiceNode extends TelemetryService {
+    getStream(config) {
+        return new TelemetryStreamNode(config);
+    }
+}

package/services/TimeSyncerService.d.ts

@@ -0,0 +1,13 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+export declare class TimeSyncerService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Get Server Time
+     */
+    getServerTime(): Promise<any>;
+}

package/services/TimeSyncerService.js

@@ -0,0 +1,23 @@
+import { RocosError, errorCodes } from '../models/RocosError';
+import { API_SERVER_TIME_URL } from '../constants/api';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class TimeSyncerService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`TimeSyncerService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.TIME_SYNCER_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Get Server Time
+     */
+    getServerTime() {
+        return this.callGet(formatServiceUrl(API_SERVER_TIME_URL, { url: this.config.url }, this.config.insecure), 'Failed to get server time.');
+    }
+}