@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/api/streams/fileAccessor/FileAccessorStreamNode.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAccessorStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const filagree_pb_1 = require("../../../grpc/file-accessor/filagree_pb");
+const filagree_grpc_pb_1 = require("../../../grpc/file-accessor/filagree_grpc_pb");
+const FileAccessorStreamAbstract_1 = require("./FileAccessorStreamAbstract");
+const FileEnums_1 = require("../../../models/file/FileEnums");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const RocosOpResultMessage_1 = require("../../../models/message/RocosOpResultMessage");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class FileAccessorStreamNode extends FileAccessorStreamAbstract_1.FileAccessorStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`FileAccessorStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new filagree_grpc_pb_1.FilagreeClient(`${this.url}:${port}`, credentials);
+    }
+    serverReqOpInternal(params) {
+        return new Promise((resolve, reject) => {
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            this.logger.debug('serverReqOp - request', {
+                status: this.subscriberStatus,
+                projectId: params.projectId,
+                callsign: params.callsign,
+            });
+            const req = new filagree_pb_1.OpRequest();
+            req.setOpcode(params.opCode);
+            req.setPath(params.path);
+            req.setTarget(params.target || FileEnums_1.OpRequestTarget.AGENT);
+            // Set map values
+            if (params.args) {
+                Object.keys(params.args).forEach((key) => {
+                    var _a;
+                    if ((_a = params === null || params === void 0 ? void 0 : params.args) === null || _a === void 0 ? void 0 : _a[key]) {
+                        req.getArgsMap().set(key, params.args[key]);
+                    }
+                });
+            }
+            const reqs = new filagree_pb_1.OpRequests();
+            reqs.setRequestsList([req]);
+            const metadata = this.getMetadata(params.projectId, params.callsign);
+            this.client.serverReqOp(reqs, metadata, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (data) {
+                    resolve(RocosOpResultMessage_1.RocosOpResultMessage.fromMessages(data));
+                }
+                else {
+                    reject('Error in serverReqOp call');
+                }
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('serverReqOp - response', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                });
+            });
+        });
+    }
+    getMetadata(projectId, callsign) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        if (projectId) {
+            meta.add('r-p', projectId);
+        }
+        if (callsign) {
+            meta.add('r-cs', callsign);
+        }
+        return meta;
+    }
+}
+exports.FileAccessorStreamNode = FileAccessorStreamNode;

package/api/streams/search/SearchStream.d.ts

@@ -0,0 +1,16 @@
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane/slowlane_pb';
+import { ISearchParams, ISearchQueryParams, ISearchStreamParams } from '../../../models/params/ISearchParams';
+import { Observable } from 'rxjs';
+import { IRocosSearchMessage } from '../../../models/message/IRocosSearchMessage';
+import { IRocosSearchStatusMessage } from '../../../models/message/IRocosSearchStatusMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { SearchStreamAbstract } from './SearchStreamAbstract';
+export declare class SearchStream extends SearchStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private getMetadata;
+}

package/api/streams/search/SearchStream.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchStream = void 0;
+const slowlane_pb_1 = require("../../../grpc/slowlane/slowlane_pb");
+const rxjs_1 = require("rxjs");
+const slowlane_pb_service_1 = require("../../../grpc/slowlane/slowlane_pb_service");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const RocosSearchMessage_1 = require("../../../models/message/RocosSearchMessage");
+const SearchStreamAbstract_1 = require("./SearchStreamAbstract");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class SearchStream extends SearchStreamAbstract_1.SearchStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`SearchStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new slowlane_pb_service_1.streamClient(`${protocol}://${this.url}`);
+    }
+    searchStreamInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.searchStream(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const dataSetList = update.getDatasetList();
+                const results = dataSetList.map((item) => {
+                    return RocosSearchMessage_1.RocosSearchMessage.fromMessage(item);
+                });
+                emitter.next(results);
+                this.logger.debug('searchStream - on(data)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(end)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+                emitter.complete();
+            });
+            call.on('status', (status) => {
+                this.logger.debug('searchStream - on(status)', {
+                    status,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+                // TODO: match fail status and emit an error
+                // emitter.error(error)
+            });
+            return () => {
+                this.logger.debug('unsubscribing searchStream');
+                call.cancel();
+            };
+        });
+    }
+    queryDataInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.queryData(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.getResult());
+                }
+                else {
+                    reject('Error with search query.');
+                }
+            });
+        });
+    }
+    healthCheckInternal(params) {
+        const request = new slowlane_pb_1.Empty();
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.healthCheck(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.toObject());
+                }
+                else {
+                    reject('Error with health check.');
+                }
+            });
+        });
+    }
+    deleteProjectDataInternal(params) {
+        const request = new slowlane_pb_1.DeleteProjectMessage();
+        request.setProjectid(params.projectId);
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.deleteProjectData(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.toObject());
+                }
+                else {
+                    reject('Error with health check.');
+                }
+            });
+        });
+    }
+    getMetadata(projectId) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+        };
+    }
+}
+exports.SearchStream = SearchStream;

package/api/streams/search/SearchStreamAbstract.d.ts

@@ -0,0 +1,30 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane/slowlane_pb';
+import { ISearchParams, ISearchQueryParams, ISearchStreamParams } from '../../../models/params/ISearchParams';
+import { IRocosSearchMessage } from '../../../models/message/IRocosSearchMessage';
+import { IRocosSearchStatusMessage } from '../../../models/message/IRocosSearchStatusMessage';
+import { ISearchStream } from '../../../models/stream/ISearchStream';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { Logger } from 'loglevel';
+import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
+export declare abstract class SearchStreamAbstract implements ISearchStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    constructor(config: IStreamConfig);
+    protected abstract searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected abstract queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected abstract healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected abstract deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    setToken(token: string): void;
+    stopStream(): void;
+    searchStream(params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    queryData(params: ISearchQueryParams): Promise<string>;
+    healthCheck(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    deleteProjectData(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private convertToQueryMessage;
+}

package/api/streams/search/SearchStreamAbstract.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const slowlane_pb_1 = require("../../../grpc/slowlane/slowlane_pb");
+const identifier_1 = require("../../../constants/identifier");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamRegister_1 = require("../../StreamRegister");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const operators_1 = require("rxjs/operators");
+class SearchStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_SEARCH, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new rxjs_1.BehaviorSubject(SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED);
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe(operators_1.filter((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    searchStream(params) {
+        const request = this.convertToQueryMessage(params.query);
+        return this.searchStreamInternal(request, params);
+    }
+    queryData(params) {
+        const request = new slowlane_pb_1.QueryDSLMessage();
+        request.setDslquery(params.query);
+        request.setProjectid(params.projectId);
+        return this.queryDataInternal(request, params);
+    }
+    healthCheck(params) {
+        return this.healthCheckInternal(params);
+    }
+    deleteProjectData(params) {
+        return this.deleteProjectDataInternal(params);
+    }
+    convertToQueryMessage(query) {
+        const filtersForSearching = query.filters.map((filter) => {
+            const newFilter = new slowlane_pb_1.Filter();
+            newFilter.setIdsList(filter.ids);
+            newFilter.setKeyword(filter.keyword);
+            return newFilter;
+        });
+        const reqMsg = new slowlane_pb_1.QueryMessage();
+        reqMsg.setFiltersList(filtersForSearching);
+        reqMsg.setGroupbyfieldsList(query.groupByFields);
+        reqMsg.setPayloadidsList(query.payloadIds);
+        reqMsg.setStartdate(`${query.startDate}`);
+        reqMsg.setEnddate(`${query.endDate}`);
+        reqMsg.setInterval(query.interval);
+        reqMsg.setRefreshdelay(query.refreshDelay);
+        reqMsg.setDisabledatehistogram(query.disableDateHistogram ? 1 : 0);
+        if (query.dateField) {
+            reqMsg.setDatefield(query.dateField);
+        }
+        if (query.projectId) {
+            reqMsg.setProjectid(query.projectId);
+        }
+        return reqMsg;
+    }
+}
+exports.SearchStreamAbstract = SearchStreamAbstract;

package/api/streams/search/SearchStreamNode.d.ts

@@ -0,0 +1,16 @@
+import { QueryDSLMessage, QueryMessage } from '../../../grpc/slowlane/slowlane_pb';
+import { ISearchParams, ISearchQueryParams, ISearchStreamParams } from '../../../models/params/ISearchParams';
+import { Observable } from 'rxjs';
+import { IRocosSearchMessage } from '../../../models/message/IRocosSearchMessage';
+import { IRocosSearchStatusMessage } from '../../../models/message/IRocosSearchStatusMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { SearchStreamAbstract } from './SearchStreamAbstract';
+export declare class SearchStreamNode extends SearchStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected searchStreamInternal(request: QueryMessage, params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    protected queryDataInternal(request: QueryDSLMessage, params: ISearchQueryParams): Promise<string>;
+    protected healthCheckInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    protected deleteProjectDataInternal(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private getMetadata;
+}

package/api/streams/search/SearchStreamNode.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const slowlane_pb_1 = require("../../../grpc/slowlane/slowlane_pb");
+const rxjs_1 = require("rxjs");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const RocosSearchMessage_1 = require("../../../models/message/RocosSearchMessage");
+const SearchStreamAbstract_1 = require("./SearchStreamAbstract");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const slowlane_grpc_pb_1 = require("../../../grpc/slowlane/slowlane_grpc_pb");
+class SearchStreamNode extends SearchStreamAbstract_1.SearchStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`SearchStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new slowlane_grpc_pb_1.streamClient(`${this.url}:${port}`, credentials);
+    }
+    searchStreamInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.searchStream(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const dataSetList = update.getDatasetList();
+                const results = dataSetList.map((item) => {
+                    return RocosSearchMessage_1.RocosSearchMessage.fromMessage(item);
+                });
+                emitter.next(results);
+                this.logger.debug('searchStream - on(data)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(end)', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    query: params.query,
+                });
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(error)', error);
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing searchStream');
+                call.cancel();
+            };
+        });
+    }
+    queryDataInternal(request, params) {
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.queryData(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.getResult());
+                }
+                else {
+                    reject('Error with search query.');
+                }
+            });
+        });
+    }
+    healthCheckInternal(params) {
+        const request = new slowlane_pb_1.Empty();
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.healthCheck(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.toObject());
+                }
+                else {
+                    reject('Error with health check.');
+                }
+            });
+        });
+    }
+    deleteProjectDataInternal(params) {
+        const request = new slowlane_pb_1.DeleteProjectMessage();
+        request.setProjectid(params.projectId);
+        const metadata = this.getMetadata(params.projectId);
+        return new Promise((resolve, reject) => {
+            this.client.deleteProjectData(request, metadata, (error, response) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response) {
+                    resolve(response.toObject());
+                }
+                else {
+                    reject('Error with health check.');
+                }
+            });
+        });
+    }
+    getMetadata(projectId) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        meta.add('r-p', projectId);
+        return meta;
+    }
+}
+exports.SearchStreamNode = SearchStreamNode;

package/api/streams/telemetry/TelemetryStream.d.ts

@@ -0,0 +1,17 @@
+import { TelemetryAckStatusMap, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby/teletubby_pb';
+import { ITelemetryStreamConfig } from '../../../models/ITelemetryStreamConfig';
+import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
+export declare class TelemetryStream extends TelemetryStreamAbstract {
+    private client;
+    private receiverCall?;
+    constructor(config: ITelemetryStreamConfig);
+    protected stopInternal(): void;
+    protected registerReceiver(): () => void;
+    private onError;
+    private onEnd;
+    private getMetadata;
+    protected requestTelemetry(req: TelemetryRequest): Promise<void>;
+    protected requestTelemetryQuery(req: TelemetryQueryRequest): Promise<void>;
+    protected sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatusMap[keyof TelemetryAckStatusMap], noRetry: boolean): boolean;
+    protected sendHeartbeat(): void;
+}

package/api/streams/telemetry/TelemetryStream.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryStream = void 0;
+const teletubby_pb_1 = require("../../../grpc/teletubby/teletubby_pb");
+const teletubby_pb_service_1 = require("../../../grpc/teletubby/teletubby_pb_service");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const RocosTelemetryMessage_1 = require("../../../models/message/RocosTelemetryMessage");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const TelemetryStreamAbstract_1 = require("./TelemetryStreamAbstract");
+const grpc_web_1 = require("@improbable-eng/grpc-web");
+class TelemetryStream extends TelemetryStreamAbstract_1.TelemetryStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new teletubby_pb_service_1.TelemetryGatewayClient(`${protocol}://${this.url}`);
+    }
+    stopInternal() {
+        if (this.receiverCall) {
+            this.logger.info('Starting stop stream process');
+            this.receiverCall.cancel();
+            this.receiverCall = undefined;
+            this.logger.info('Finished stop stream process');
+        }
+    }
+    registerReceiver() {
+        this.logger.info('registerReceiver');
+        // Reset counter
+        this.receivedMessagesCount = 0;
+        const call = this.client.registerReceiver(new teletubby_pb_1.RegistrationMessage(), this.getMetadata(this.projectId));
+        call.on('data', (msg) => {
+            this.onData(RocosTelemetryMessage_1.RocosTelemetryMessage.fromTelemetryMessage(msg));
+        });
+        // on status or on end always fire at the same time
+        // {@link: src/grpc/teletubby/teletubby_pb_service.js:279}
+        call.on('status', (status) => {
+            if (status.code !== grpc_web_1.grpc.Code.OK) {
+                void this.onError(status);
+            }
+        });
+        call.on('end', (status) => {
+            this.onEnd(status);
+        });
+        this.receiverCall = call;
+        this.listenMessagesAndRenew();
+        return () => {
+            call.cancel();
+        };
+    }
+    async onError(e) {
+        this.logger.error(`Telemetry Stream Error: ${e}, SubscriberId: ${this.subscriberId}`);
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
+        this.statusStream$.next(this.subscriberStatus);
+        // TODO: handle stream error and re register
+        // await this.stopandReRegisterStream()
+    }
+    /*
+    grpc.Code:
+     0   OK
+     1   Canceled
+     2   Unknown
+     3   InvalidArgument
+     4   DeadlineExceeded
+     5   NotFound
+     6   AlreadyExists
+     7   PermissionDenied
+     8   ResourceExhausted
+     9   FailedPrecondition
+     10  Aborted
+     11  OutOfRange
+     12  Unimplemented
+     13  Internal
+     14  Unavailable
+     15  DataLoss
+     16  Unauthenticated
+     */
+    onEnd(status) {
+        this.logger.debug('registerReceiver', 'end', status);
+        if ((status === null || status === void 0 ? void 0 : status.code) === grpc_web_1.grpc.Code.OK) {
+            // ResourceExhausted
+            this.stopInternal();
+            this.registerReceiver();
+        }
+    }
+    getMetadata(projectId) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        return result;
+    }
+    requestTelemetry(req) {
+        this.logger.debug('Sending telemetry request');
+        return new Promise((resolve, reject) => {
+            this.client.requestTelemetry(req, this.getMetadata(this.projectId), (err, ack) => {
+                this.logger.debug('subscribeSources with callsigns callback', err, ack);
+                if (err) {
+                    this.logger.error('error requestTelemetry ', err);
+                    return reject(err);
+                }
+                return resolve();
+            });
+        });
+    }
+    requestTelemetryQuery(req) {
+        this.logger.debug('Requesting telemetry with query');
+        return new Promise((resolve, reject) => {
+            this.client.requestTelemetryQuery(req, this.getMetadata(this.projectId), (err, ack) => {
+                this.logger.debug('subscribeSources with query callback', err, ack);
+                if (err) {
+                    this.logger.error('error requestTelemetryQuery ', err);
+                    return reject(err);
+                }
+                return resolve();
+            });
+        });
+    }
+    sendAcknowledgmentInternal(uid, status, noRetry) {
+        this.logger.error('Error can not send Acknowledgment on grpc-web client', { uid, status, noRetry });
+        return false;
+    }
+    sendHeartbeat() {
+        // can not send heartbeat on grpc-web
+    }
+}
+exports.TelemetryStream = TelemetryStream;