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

package/services/MapService.js

@@ -0,0 +1,149 @@
+import { API_MAPS_COPY_URL, API_MAPS_DEPLOYED_URL, API_MAPS_DEPLOY_URL, API_MAPS_GEOJSON_URL, API_MAPS_MERGE_URL, API_MAPS_URL, API_MAP_ID_URL, } from '../constants/api';
+import { RocosError, errorCodes } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+/**
+ * Integrations to retrieve data from the linked project in DroneDeploy
+ */
+export class MapService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`MapService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.MAPS_SERVICE_ERROR);
+    }
+    async list(projectId, callsign) {
+        const resp = await this.callGet(formatServiceUrl(API_MAPS_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), 'Failed to get maps.', callsign ? { callsign } : undefined);
+        return resp.maps;
+    }
+    /** List maps to be deployed to a callsign
+     *
+     * @param projectId
+     * @param callsign
+     */
+    async listDeployedMaps(projectId, callsign) {
+        const safeCallsign = encodeURIComponent(callsign);
+        const resp = await this.callGet(formatServiceUrl(API_MAPS_DEPLOYED_URL, {
+            url: this.config.url,
+            projectId,
+            callsign: safeCallsign,
+        }, this.config.insecure), 'Failed to get deployed maps.');
+        return resp.maps;
+    }
+    /**
+     * Creates a new map by merging two existing maps
+     * @param projectId Project ID
+     * @param maps Array of two map IDs to merge
+     * @param options Options to create the new map
+     */
+    async merge(projectId, maps, options) {
+        if (maps.length !== 2)
+            throw new Error('You must provide two maps to merge.');
+        const payload = {
+            projectID: projectId,
+            mapIDLeft: maps[0],
+            mapIDRight: maps[1],
+            name: options.name,
+            description: options.description,
+            callsign: options.callsign,
+        };
+        return this.callPost(formatServiceUrl(API_MAPS_MERGE_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), payload, 'Failed to merge maps.');
+    }
+    /** Returns a map in its canonical form
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    async get(projectId, mapId) {
+        return this.callGet(formatServiceUrl(API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to get map.');
+    }
+    /**
+     * Updates a maps metadata
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options New metadata
+     */
+    async update(projectId, mapId, options) {
+        return this.callPut(formatServiceUrl(API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), options, 'Failed to update map.');
+    }
+    /**
+     * Begins uploading a map from the agent
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     * @param hash Map hash
+     */
+    async sendToCloud(projectId, mapId, callsign, hash) {
+        return this.callPost(formatServiceUrl(API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), { callsign, hash }, 'Failed to start map upload.');
+    }
+    async delete(projectId, mapId, callsign, hash) {
+        return this.callDelete(formatServiceUrl(API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to delete map.', callsign ? { callsign, hash } : {});
+    }
+    /**
+     * Makes a copy of an uploaded map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options Options to create the new map
+     */
+    async copy(projectId, mapId, options) {
+        return this.callPost(formatServiceUrl(API_MAPS_COPY_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), options, 'Failed to copy map.');
+    }
+    /** Deploy a map from the cloud to a robot
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     */
+    async deploy(projectId, mapId, callsign) {
+        return this.callPost(formatServiceUrl(API_MAPS_DEPLOY_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), { callsign }, 'Failed to deploy map.');
+    }
+    /** Get a GeoJSON representation of a map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    async getGeoJSON(projectId, mapId) {
+        return this.callGet(formatServiceUrl(API_MAPS_GEOJSON_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to get map GeoJSON.');
+    }
+}

package/services/PlatformTimeService.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from 'loglevel';
+import { TimeSyncerService } from './TimeSyncerService';
+export interface IPlatformTime {
+    now: number;
+    duration: number;
+}
+export interface IPlatformTimeMeasurement {
+    clientTimeStampEnd: number;
+    clientTimeStampStart: number;
+    serverTime: IPlatformTime;
+}
+export declare class PlatFormTimeService {
+    protected static instance: PlatFormTimeService;
+    protected backoffTimeouts: number[];
+    protected isSyncing: boolean;
+    protected backoffFailCount: number;
+    protected serverTimeOffset: number;
+    protected lastPlatformTimeSyncedAt: number;
+    protected timeSyncerService: TimeSyncerService;
+    protected logger: Logger;
+    protected constructor(timeSyncerService: TimeSyncerService);
+    static getInstance(timeSyncerService?: TimeSyncerService): PlatFormTimeService;
+    get platformTimeOffset(): number;
+    get platformTime(): number;
+    private getClockOffsetBetweenClientAndServer;
+    private getPlatformTime;
+    protected handleServerTimeNotReliable(): void;
+    private backoff;
+    protected isReliableServerTime(platformTimeMeasurements: IPlatformTimeMeasurement[]): boolean;
+    private handleGetServerTimeError;
+    protected calculateOffset(platformTimeMeasurements: IPlatformTimeMeasurement[]): number;
+    private saveOffset;
+    protected removeLongestAndShortest(serverTimeMeasurements: IPlatformTimeMeasurement[]): IPlatformTimeMeasurement[];
+    private getServerTime;
+}

package/services/PlatformTimeService.js

@@ -0,0 +1,156 @@
+import { RocosLogger } from '../logger/RocosLogger';
+import { standardDeviation } from '../helpers/standardDeviation';
+const NUMBER_OF_SERVER_TIME_USED_TO_CALIBRATE = 5;
+const MAX_CLIENT_WAITING_TIME_STANDARD_DEVIATION_ALLOWED = 100; // 100 miliseconds
+const KEY_GR_PLATFORM_TIME_OFFSET = 'gr_platformTimeOffset';
+const KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT = 'gr_lastPlatformTimeSyncedAt';
+const GR_PLATFORM_TIME_TTL = 30 * 60 * 1000; // 30 minutes
+export class PlatFormTimeService {
+    // Make this a singleton, so that we don't have multi platform time
+    constructor(timeSyncerService) {
+        this.backoffTimeouts = [5 * 1000, 30 * 1000, 60 * 1000, 300 * 1000]; // in miliseconds
+        this.isSyncing = false;
+        this.backoffFailCount = 0;
+        this.serverTimeOffset = 0;
+        this.lastPlatformTimeSyncedAt = 0;
+        this.logger = RocosLogger.getInstance('PlatformTimeService');
+        if (window?.localStorage) {
+            this.lastPlatformTimeSyncedAt = Number(window.localStorage.getItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT)) || 0;
+            this.serverTimeOffset = Number(window.localStorage.getItem(KEY_GR_PLATFORM_TIME_OFFSET)) || 0;
+        }
+        this.timeSyncerService = timeSyncerService;
+        this.logger.debug('stored platform time: ', this.platformTime);
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, 2000);
+    }
+    static getInstance(timeSyncerService) {
+        if (!PlatFormTimeService.instance) {
+            if (!timeSyncerService) {
+                throw new Error('platform time service object is not instantiated yet, please pass timeSyncerService to create it');
+            }
+            PlatFormTimeService.instance = new PlatFormTimeService(timeSyncerService);
+        }
+        return PlatFormTimeService.instance;
+    }
+    get platformTimeOffset() {
+        return this.serverTimeOffset;
+    }
+    get platformTime() {
+        const now = Date.now();
+        return now - this.serverTimeOffset;
+    }
+    async getClockOffsetBetweenClientAndServer() {
+        let serverTimeOffsets = [];
+        if (this.isSyncing) {
+            return;
+        }
+        this.isSyncing = true;
+        for (let count = 0; count < NUMBER_OF_SERVER_TIME_USED_TO_CALIBRATE; count++) {
+            try {
+                const platformTime = await this.getPlatformTime();
+                serverTimeOffsets.push(platformTime);
+            }
+            catch (e) {
+                this.handleGetServerTimeError(e);
+                return;
+            }
+        }
+        if (this.isReliableServerTime(serverTimeOffsets)) {
+            serverTimeOffsets = this.removeLongestAndShortest(serverTimeOffsets);
+            const serverTimeOffset = this.calculateOffset(serverTimeOffsets);
+            this.saveOffset(serverTimeOffset);
+        }
+        else {
+            this.handleServerTimeNotReliable();
+        }
+    }
+    async getPlatformTime() {
+        const clientTimeStampStart = Date.now();
+        // exception should be handled by the caller
+        const serverTime = await this.getServerTime();
+        const clientTimeStampEnd = Date.now();
+        return {
+            clientTimeStampEnd,
+            clientTimeStampStart,
+            serverTime,
+        };
+    }
+    handleServerTimeNotReliable() {
+        this.logger.error('not able to get reliable server time, will try again...');
+        this.isSyncing = false;
+        this.backoff();
+    }
+    backoff() {
+        this.backoffFailCount++;
+        this.logger.debug('backoff count: ', this.backoffFailCount);
+        const backoffTimeoutIndex = this.backoffFailCount - 1;
+        let delay;
+        if (backoffTimeoutIndex >= this.backoffTimeouts.length) {
+            // Use the longest delay if backoff failed too many times
+            delay = this.backoffTimeouts[this.backoffTimeouts.length - 1];
+        }
+        else {
+            delay = this.backoffTimeouts[backoffTimeoutIndex];
+        }
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, delay);
+    }
+    isReliableServerTime(platformTimeMeasurements) {
+        const stdDeviation = standardDeviation(
+        // get the standardDeviation of the client waiting time
+        platformTimeMeasurements.map((x) => x.clientTimeStampEnd - x.clientTimeStampStart));
+        this.logger.debug('standard deviation', stdDeviation);
+        // We judge server time is reliable only the standard deviation of client waiting time is less
+        // than the threshold
+        return stdDeviation < MAX_CLIENT_WAITING_TIME_STANDARD_DEVIATION_ALLOWED;
+    }
+    handleGetServerTimeError(e) {
+        this.logger.error('Fail to get server time, will try again...', { e });
+        this.isSyncing = false;
+        this.backoff();
+    }
+    calculateOffset(platformTimeMeasurements) {
+        //  Timestamp when Received the Response - Time Request Duration / 2 - Timestamp within the Response .
+        let totalServerTimeOffset = 0;
+        const measurementsWithValues = platformTimeMeasurements.filter((x) => !!x?.serverTime);
+        measurementsWithValues.forEach((x) => {
+            // eslint-disable-next-line operator-linebreak
+            totalServerTimeOffset +=
+                // eslint-disable-next-line no-mixed-operators
+                x.clientTimeStampEnd - (x.clientTimeStampEnd - x.clientTimeStampStart) / 2 - x.serverTime.now / 10 ** 6;
+        });
+        // final platformTimeOffset is in miliseconds
+        return Math.round(totalServerTimeOffset / measurementsWithValues.length);
+    }
+    saveOffset(timeOffset) {
+        this.backoffFailCount = 0;
+        this.isSyncing = false;
+        this.serverTimeOffset = timeOffset;
+        this.lastPlatformTimeSyncedAt = Date.now();
+        if (window?.localStorage) {
+            window.localStorage.setItem(KEY_GR_PLATFORM_TIME_OFFSET, String(this.serverTimeOffset));
+            window.localStorage.setItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT, String(this.lastPlatformTimeSyncedAt));
+        }
+        this.logger.debug('calibrated server time offset', timeOffset);
+        // resync the time in 30 minutes
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, GR_PLATFORM_TIME_TTL);
+    }
+    removeLongestAndShortest(serverTimeMeasurements) {
+        let result = [];
+        if (serverTimeMeasurements.length > 2) {
+            // remove the server time responses with shortest/longest client waiting duration
+            serverTimeMeasurements.sort((a, b) => {
+                return a.clientTimeStampEnd - a.clientTimeStampStart - (b.clientTimeStampEnd - b.clientTimeStampStart);
+            });
+            result = serverTimeMeasurements.slice(1, serverTimeMeasurements.length - 1);
+        }
+        return result;
+    }
+    getServerTime() {
+        return this.timeSyncerService.getServerTime();
+    }
+}

package/services/PlatformTimeService.spec.d.ts

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

package/services/PlatformTimeService.spec.js

@@ -0,0 +1,180 @@
+import { PlatFormTimeService } from "./PlatformTimeService";
+import { TimeSyncerService } from "./TimeSyncerService";
+import { standardDeviation } from "../helpers";
+// Subclass PlatformTimeService so that we can test the protected methods
+class PlatformtimeServicePublic extends PlatFormTimeService {
+    constructor(timeSyncerService) {
+        super(timeSyncerService);
+    }
+    isReliableServerTime(platformTimeMeasurement) {
+        return super.isReliableServerTime(platformTimeMeasurement);
+    }
+    calculateOffset(platformTimeMeasurement) {
+        return super.calculateOffset(platformTimeMeasurement);
+    }
+    removeLongestAndShortest(platformTimeMeasurement) {
+        return super.removeLongestAndShortest(platformTimeMeasurement);
+    }
+    static getInstance(timeSyncerService) {
+        const instance = super.getInstance(timeSyncerService);
+        return instance;
+    }
+}
+describe('platformTimeService', () => {
+    it('should calculate standard deviation correctly', () => {
+        let numbers = [10, 12, 23, 23, 16, 23, 21, 16];
+        let stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 4.8989794855664)).toBeLessThan(0.000001);
+        numbers = [100, 12, 23, 23, 116, 23, 21, 162];
+        stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 53.702886328394)).toBeLessThan(0.000001);
+    });
+    it('should be able to tell reliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 20,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        mocks.push(mock);
+        let isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 4; i++) {
+            mocks.push({ ...mock });
+            isReliableServerTime = p.isReliableServerTime(mocks);
+            expect(isReliableServerTime).toBeTruthy();
+        }
+    });
+    it('should be able to tell unreliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let isReliableServerTime = false;
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 60;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 70;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 80;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        // std dev = 113.13708498985
+        expect(isReliableServerTime).toBeFalsy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 100;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeFalsy();
+    });
+    it('should be able to remove shortest and longest correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 100;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 300;
+        mocks.push(mockClone);
+        const platformTimeMeasurement = p.removeLongestAndShortest(mocks);
+        platformTimeMeasurement.forEach((p) => {
+            expect(p.clientTimeStampEnd).not.toEqual(100);
+            expect(p.clientTimeStampEnd).not.toEqual(500);
+        });
+    });
+    it('should be able to calculate the offset correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (200-(200)/2 + 500 - (500)/2 + 400 - (400)/2)/3 = 183.333333333, round to 183
+        expect(offset).toEqual(183);
+    });
+    it('should be able to filter where service time is not provided', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mockClone.serverTime = undefined;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (500 - (500)/2 + 400 - (400)/2)/2 = 225
+        expect(offset).toEqual(225);
+    });
+});