@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/services/PlatformTimeService.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatFormTimeService = void 0;
+const RocosLogger_1 = require("../logger/RocosLogger");
+const standardDeviation_1 = require("../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
+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_1.RocosLogger.getInstance('PlatformTimeService');
+        if (window === null || window === void 0 ? void 0 : 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_1.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 === null || x === void 0 ? void 0 : 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 === null || window === void 0 ? void 0 : 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();
+    }
+}
+exports.PlatFormTimeService = PlatFormTimeService;

package/services/ProfileService.d.ts

@@ -0,0 +1,244 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+export declare class ProfileService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     *  Create a robot definition
+     *
+     * @param projectId - Project Id
+     * @param model - Payload
+     * @description - Renamed from robotDefsCreate
+     */
+    create(projectId: string, model: any): Promise<any>;
+    /**
+     * Get robot definitions
+     *
+     * @param projectId - Project Id
+     * @description - Renamed from robotDefsList
+     */
+    list(projectId: string): Promise<any>;
+    /**
+     * Delete robot definitions
+     *
+     * @param projectId - Project Id
+     * @param defIds - Definition Id's
+     * @description - Renamed from robotDefsRemove
+     */
+    remove(projectId: string, defIds: string[]): Promise<any>;
+    /**
+     * Get a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotDefsGetOne
+     */
+    get(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Delete a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotDefsDeleteOne
+     */
+    delete(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Definition payload
+     * @description - Renamed from robotDefsUpdateOne
+     */
+    update(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get definitions for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @description - Renamed from robotDefsForRobot
+     */
+    getForRobot(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update storage streams for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefsUpdateStorageStreams
+     */
+    updateStorageStreams(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Copy a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefCopyDef
+     */
+    copyDef(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get robot list got a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotListForDefs
+     */
+    robotList(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Get dashboards for a definition
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @description - Renamed from robotDefDashboards
+     */
+    dashboards(projectId: string, profileId: string): Promise<any>;
+    /**
+     * Get Dashboard data which stored in Azure Blob.
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @description - Renamed from robotDefDashboardBlob
+     */
+    dashboardBlob(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update dashboard for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateDashboards
+     */
+    updateDashboards(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get settings for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @description - Renamed from robotDefGetSettings
+     */
+    getSettings(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update settings for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateSettings
+     */
+    updateSettings(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get agent settings
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetAgentSettings
+     */
+    getAgentSettings(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update agent settings
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateAgentSettings
+     */
+    updateAgentSettings(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get commands fora robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommands
+     */
+    getCommands(projectId: string, definitionId: string): Promise<any>;
+    /**
+     *
+     * Update commands fora robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateCommands
+     */
+    updateCommands(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get command V2 for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommandsV2
+     */
+    getCommandsV2(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update command V2 for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateCommandsV2
+     */
+    updateCommandsV2(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get command actions for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommandActions
+     */
+    getCommandActions(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Get buttons for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetButtons
+     */
+    getButtons(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update buttons for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateButtons
+     */
+    updateButtons(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get triggers for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetTriggers
+     */
+    getTriggers(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update triggers for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateTriggers
+     */
+    updateTriggers(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get gamepads for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetGamepads
+     */
+    getGamepads(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update gamepads for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - \payload
+     * @description - Renamed from robotDefUpdateGamepads
+     */
+    updateGamepads(projectId: string, definitionId: string, model: any): Promise<any>;
+}