@dronedeploy/rocos-js-sdk 3.0.1-alpha.3 → 3.0.1-alpha.5

package/cjs/api/streams/search/SearchStreamNode.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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_pb");
+const models_1 = require("../../../models");
+const rxjs_1 = require("rxjs");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SearchStreamAbstract_1 = require("./SearchStreamAbstract");
+const slowlane_pb_grpc_client_1 = require("../../../grpc/slowlane_pb.grpc-client");
+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_pb_grpc_client_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 = models_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const dataSetList = update.dataset;
+                const results = dataSetList.map((item) => {
+                    return models_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 = models_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 = models_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('searchStream - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = models_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.result);
+                }
+                else {
+                    reject('Error with search query.');
+                }
+            });
+        });
+    }
+    healthCheckInternal(params) {
+        const request = slowlane_pb_1.Empty.create();
+        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);
+                }
+                else {
+                    reject('Error with health check.');
+                }
+            });
+        });
+    }
+    deleteProjectDataInternal(params) {
+        const request = slowlane_pb_1.DeleteProjectMessage.create({ projectId: 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);
+                }
+                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/cjs/api/streams/telemetry/TelemetryStream.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryStream = void 0;
+const models_1 = require("../../../models");
+const teletubby_pb_1 = require("../../../grpc/teletubby_pb");
+const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const teletubby_pb_client_1 = require("../../../grpc/teletubby_pb.client");
+const TelemetryStreamAbstract_1 = require("./TelemetryStreamAbstract");
+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';
+        const transport = new grpcweb_transport_1.GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}`,
+        });
+        this.client = new teletubby_pb_client_1.TelemetryGatewayClient(transport);
+    }
+    stopInternal() {
+        if (this.abortController) {
+            this.logger.info('Starting stop stream process');
+            this.abortController.abort();
+            this.abortController = undefined;
+            this.logger.info('Finished stop stream process');
+        }
+    }
+    registerReceiver() {
+        this.logger.info('registerReceiver');
+        // Reset counter
+        this.receivedMessagesCount = 0;
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        const call = this.client.registerReceiver(teletubby_pb_1.RegistrationMessage.create(), {
+            meta: this.getMetadata(this.projectId),
+            abort: abortController.signal,
+        });
+        call.responses.onMessage((msg) => {
+            this.onData(msg, false);
+        });
+        call.responses.onError((error) => {
+            void this.onError(error);
+            this.onEnd(false);
+        });
+        call.responses.onComplete(() => {
+            this.onEnd(true);
+        });
+        this.listenMessagesAndRenew();
+        return () => {
+            abortController.abort();
+        };
+    }
+    async onError(e) {
+        this.logger.error(`Telemetry Stream Error: ${e}, SubscriberId: ${this.subscriberId}`);
+        this.subscriberStatus = models_1.SubscriberStatusEnum.ERROR;
+        this.statusStream$.next(this.subscriberStatus);
+    }
+    onEnd(ok) {
+        this.logger.debug('registerReceiver', 'end');
+        if (ok) {
+            // ResourceExhausted
+            this.stopInternal();
+            this.registerReceiver();
+        }
+    }
+    getMetadata(projectId) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        return result;
+    }
+    async requestTelemetry(req) {
+        this.logger.debug('Sending telemetry request');
+        try {
+            await this.client.requestTelemetry(req, { meta: this.getMetadata(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetry ', e);
+            throw e;
+        }
+    }
+    async requestTelemetryQuery(req) {
+        this.logger.debug('Requesting telemetry with query');
+        try {
+            await this.client.requestTelemetryQuery(req, { meta: this.getMetadata(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetryQuery ', e);
+            throw e;
+        }
+    }
+    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;

package/cjs/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const models_1 = require("../../../models");
+const grpc_1 = require("../../../constants/grpc");
+const teletubby_pb_1 = require("../../../grpc/teletubby_pb");
+const identifier_1 = require("../../../constants/identifier");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamHeartbeat_1 = require("../../atoms/StreamHeartbeat");
+const StreamRegister_1 = require("../../StreamRegister");
+const arrayUnique_1 = require("../../../helpers/arrayUnique");
+const operators_1 = require("rxjs/operators");
+const getSubscriptionsDifference_1 = require("../../../helpers/getSubscriptionsDifference");
+class TelemetryStreamAbstract {
+    constructor(config) {
+        // /////////////////
+        // Subscriber Check
+        this.timerIntervalInSec = 1;
+        this.subscriberStatus = models_1.SubscriberStatusEnum.STOPPED;
+        this.retryTimes = 0;
+        this.receivedMessagesCount = 0;
+        // send heartbeat timeout is set to 5 seconds 5000
+        this.sendHeartbeatTime = 5000;
+        this.receivedDataStats = {};
+        this.subscriptions = new Map();
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_TELEMETRY, config.scope);
+        this.projectId = config.projectId;
+        this.callsignsLookup = config.callsignsLookup;
+        this.token = config.token;
+        this.scope = config.scope;
+        this.url = config.url;
+        // make sure sources are unique for later comparison
+        this.sources = (0, arrayUnique_1.arrayUnique)(config.sources);
+        this.options = models_1.StreamOptions.fromModel(config.options);
+        this.messageStream$ = new rxjs_1.Subject();
+        this.statusStream$ = new rxjs_1.BehaviorSubject(models_1.SubscriberStatusEnum.STOPPED);
+        this.heartbeat = new StreamHeartbeat_1.StreamHeartbeat(this.identifier);
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe((0, operators_1.filter)((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    init() {
+        this.logger.info('Creating new stream instance');
+        // Register Receiver
+        this.registerReceiver();
+    }
+    stopStream() {
+        this.heartbeat?.stop();
+        this.stopInternal();
+        if (this.messagesTimer) {
+            clearInterval(this.messagesTimer);
+        }
+        this.subscriberStatus = models_1.SubscriberStatusEnum.STOPPED;
+        this.statusStream$.next(this.subscriberStatus);
+    }
+    addSubscription(params) {
+        this.logger.info('Adding subscriptions from stream', params.uniqueId);
+        if (!this.subscriptions.has(params.uniqueId)) {
+            // get subscriptions before change
+            const before = this.getSubscriptions();
+            this.subscriptions.set(params.uniqueId, {
+                ...params,
+                count: 1, // set the count to one just in case it's set in param
+            });
+            // get subscriptions after change
+            const after = this.getSubscriptions();
+            // assign the current values from state after change
+            this.callsignsLookup = new models_1.CallsignsLookup(Object.keys(after));
+            this.sources = (0, arrayUnique_1.arrayUnique)(Object.values(after).reduce((a, v) => a.concat(v), []));
+            // compare before and after subscriptions and only add the difference
+            const { toAdd } = (0, getSubscriptionsDifference_1.getSubscriptionsDifference)(before, after);
+            // only subscribe if the subscriberId exists, otherwise the messages will be subscribed on lazy load
+            if (toAdd.callsigns.length && toAdd.sources.length) {
+                this.logger.debug('New subscriptions added, we need to refresh sources', { toAdd });
+                void this.takeTelemetryAction('subscribe', new models_1.CallsignsLookup(toAdd.callsigns), toAdd.sources);
+            }
+        }
+        else {
+            const subs = this.subscriptions.get(params.uniqueId);
+            subs.count++;
+            this.subscriptions.set(params.uniqueId, subs);
+            this.logger.info('Stream subscriptions already exists, increasing count', params.uniqueId, subs.count);
+        }
+        RocosStore_1.RocosStore.getChangeSubject().next({ type: 'telemetry-subscription', url: this.url, data: this.subscriptions });
+    }
+    async removeSubscription(params, terminateReceiverGroup = false) {
+        this.logger.info('Removing subscriptions from stream', params.uniqueId);
+        if (!this.subscriptions.has(params.uniqueId))
+            return;
+        const subs = this.subscriptions.get(params.uniqueId);
+        subs.count--;
+        if (subs.count)
+            return;
+        this.logger.info('Removing subscriptions from stream registry', params.uniqueId);
+        const before = this.getSubscriptions();
+        this.subscriptions.delete(params.uniqueId);
+        const after = this.getSubscriptions();
+        // assign the current values from state after change
+        this.callsignsLookup = new models_1.CallsignsLookup(Object.keys(after));
+        this.sources = (0, arrayUnique_1.arrayUnique)(Object.values(after).reduce((a, v) => a.concat(v), []));
+        const { toRemove } = (0, getSubscriptionsDifference_1.getSubscriptionsDifference)(before, after);
+        if (toRemove.callsigns.length && toRemove.sources.length) {
+            this.logger.debug('Subscriptions removed, we need to refresh sources', { toRemove });
+            try {
+                await this.takeTelemetryAction('unsubscribe', new models_1.CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
+            }
+            catch (err) {
+                this.logger.error(`Failed to unsubscribe: ${err}`);
+            }
+        }
+        if (!this.subscriptions.size) {
+            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
+            this.stopStream();
+            // self remove when no subscriptions a re left
+            void StreamRegister_1.StreamRegister.getInstance().removeStream(this);
+            this.logger.info('Stream closed');
+        }
+    }
+    sendAcknowledgment(uid, status, noRetry) {
+        return this.sendAcknowledgmentInternal(uid, status, noRetry);
+    }
+    getSubscriptions() {
+        const subs = {};
+        this.subscriptions.forEach((data) => {
+            if (data.callsigns) {
+                data.callsigns.forEach((item) => {
+                    if (!subs[item]) {
+                        subs[item] = (0, arrayUnique_1.arrayUnique)([...data.sources]);
+                    }
+                    else {
+                        subs[item] = (0, arrayUnique_1.arrayUnique)([...subs[item], ...data.sources]);
+                    }
+                });
+            }
+        });
+        return subs;
+    }
+    onData(message, isStream) {
+        this.receivedMessagesCount++;
+        let rocosMessage;
+        const data = {
+            subscriberId: this.subscriberId,
+            subId: this.scope,
+            projectId: this.projectId,
+        };
+        if (isStream) {
+            rocosMessage = models_1.RocosTelemetryMessage.fromTelemetryStreamMessage(message, data, 'json');
+        }
+        else {
+            rocosMessage = models_1.RocosTelemetryMessage.fromTelemetryMessage(message, data, 'json');
+        }
+        const { source, callsign } = rocosMessage;
+        let isRobotMessage = true;
+        const now = new Date();
+        // Update last message received time
+        this.lastMessageReceived = now;
+        switch (source) {
+            // Subscribe message
+            case grpc_1.GRPC_SOURCE_SUBSCRIBED: {
+                const { subscriberId } = rocosMessage.payload;
+                if (this.subscriberId && subscriberId) {
+                    this.logger.warn(`Replacing old subscriberId (${this.subscriberId}) with a new one (${subscriberId})`);
+                }
+                // Update the subscriberId
+                this.subscriberId = subscriberId;
+                rocosMessage.subscriberId = this.subscriberId;
+                this.logger.info('onData', `subscriberId has been updated - ${subscriberId}`, { subscriberId });
+                void this.takeTelemetryAction('subscribe');
+                this.heartbeat.start(this.sendHeartbeat, this.sendHeartbeatTime);
+                isRobotMessage = false;
+                break;
+            }
+            // Server heartbeat message
+            case grpc_1.GRPC_SOURCE_NOOP:
+                isRobotMessage = false;
+                break;
+        }
+        // Update robot last message timestamp
+        if (isRobotMessage) {
+            this.lastRobotMessageReceived = now;
+        }
+        // Update stats
+        this.updateReceivedDataStatsWithMessage(rocosMessage);
+        // Send message to subscribers
+        if (this.isRegisteredMessage(callsign, source) && this.messageStream$) {
+            this.messageStream$.next(rocosMessage);
+            if (rocosMessage.isackable && this.options.autoAcknowledgmentEnabled) {
+                this.sendAcknowledgment(rocosMessage.uid, teletubby_pb_1.TelemetryAckStatus.OK, false);
+            }
+        }
+        else if (isRobotMessage) {
+            // acknowledge any way, as the user never receives this message
+            if (rocosMessage.isackable) {
+                this.sendAcknowledgment(rocosMessage.uid, teletubby_pb_1.TelemetryAckStatus.REJECT, true);
+            }
+            // All messages received should be subscribed.
+            this.logger.debug('onData', 'received unsubscribed message', {
+                callsign,
+                source,
+                callsigns: this.callsignsLookup,
+                sources: this.sources,
+            });
+        }
+    }
+    async takeTelemetryAction(actionType, callsignsLookup, sources, terminate) {
+        this.logger.debug('takeTelemetryAction', actionType);
+        if (!this.subscriberId || !this.projectId) {
+            this.logger.debug('takeTelemetryAction', actionType, `${actionType} without subscriberId or projectId - message will not send out`, {
+                subscriberId: this.subscriberId,
+                projectId: this.projectId,
+            });
+            return Promise.resolve();
+        }
+        const actionSources = sources ?? this.sources;
+        const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
+        if (this.callsignsLookup.lookupType === models_1.CallsignsLookupType.List) {
+            // Compose the request message
+            const req = teletubby_pb_1.TelemetryRequest.create({
+                subscriberId: this.subscriberId,
+                requestedActions: [
+                    {
+                        operation: actionType,
+                        callsigns: actionCallsigns.lookupValue,
+                        sources: actionSources,
+                    },
+                ],
+            });
+            if (actionType === 'unsubscribe' && terminate) {
+                this.addTerminateToAction(req.requestedActions[0]);
+            }
+            this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
+            // Send the message to back-end.
+            return this.requestTelemetry(req);
+        }
+        else if (actionCallsigns.lookupType === models_1.CallsignsLookupType.Query) {
+            const lookupValue = actionCallsigns.lookupValue;
+            // We don't support nested query at the moment
+            const queryOrPredicatesList = [];
+            // Loop through user provided predicates to construct a telemetry query request
+            lookupValue.predicates.forEach((callsignsPredicate) => {
+                const queryOrPredicate = teletubby_pb_1.QueryOrPredicate.create({
+                    content: {
+                        oneofKind: 'predicate',
+                        predicate: {
+                            attribute: callsignsPredicate.attribute.valueOf(),
+                            operation: callsignsPredicate.operation.valueOf(),
+                            value: callsignsPredicate.value,
+                        },
+                    },
+                });
+                queryOrPredicatesList.push(queryOrPredicate);
+            });
+            // Compose the request message
+            const req = teletubby_pb_1.TelemetryQueryRequest.create({
+                subscriberId: this.subscriberId,
+                sources: actionSources,
+                operation: actionType,
+                callsignQuery: {
+                    operation: lookupValue.operation.valueOf(),
+                    queryOrPredicates: queryOrPredicatesList,
+                },
+            });
+            this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
+            // Send the telemetry query request to back-end.
+            return this.requestTelemetryQuery(req);
+        }
+        return Promise.reject('Unsupported lookupType');
+    }
+    listenMessagesAndRenew() {
+        const timer = this.messagesTimer;
+        this.checkerStartedAt = new Date();
+        // Clear the previous timer first.
+        if (timer) {
+            clearInterval(timer);
+        }
+        this.messagesTimer = setInterval(() => {
+            const now = new Date();
+            const latest = this.lastMessageReceived;
+            const latestRobot = this.lastRobotMessageReceived;
+            const startedAt = this.checkerStartedAt ?? new Date();
+            const timeout = this.options.messageTimeoutInSec;
+            let shouldRetry = false;
+            let shouldAutoResubscribe = false;
+            const hasExceededTimeoutSinceLastMessage = latest && (now.getTime() - latest.getTime()) / 1000 > timeout;
+            const hasExceededTimeoutBeforeMessages = !latest && startedAt && (now.getTime() - startedAt.getTime()) / 1000 > timeout;
+            if (hasExceededTimeoutSinceLastMessage || hasExceededTimeoutBeforeMessages) {
+                shouldRetry = true;
+            }
+            if (latestRobot) {
+                // If we get robot messages at least once.
+                if ((now.getTime() - latestRobot.getTime()) / 1000 > timeout) {
+                    // Offline
+                    this.subscriberStatus = models_1.SubscriberStatusEnum.DEAD;
+                }
+                else {
+                    // Online
+                    this.subscriberStatus = models_1.SubscriberStatusEnum.ALIVE;
+                }
+            }
+            else if ((now.getTime() - startedAt.getTime()) / 1000 > timeout) {
+                // If there is no robot messages received, then we compare with startedAt time.
+                // Timeout
+                this.subscriberStatus = models_1.SubscriberStatusEnum.DEAD;
+            }
+            else if (this.retryTimes <= 0) {
+                // Still trying, status unknown.
+                this.subscriberStatus = models_1.SubscriberStatusEnum.STOPPED;
+            }
+            else {
+                // Tried multiple times. dead already.
+                this.subscriberStatus = models_1.SubscriberStatusEnum.DEAD;
+            }
+            if (this.options.autoResubscribeEnabled &&
+                this.receivedMessagesCount > this.options.autoResubscribeMessageLimit &&
+                (now.getTime() - startedAt.getTime()) / 1000 > this.options.autoResubscribeMinimumTime) {
+                // If received messages above the limit of resubscribing, we need to resubscribe.
+                shouldAutoResubscribe = true;
+            }
+            if (shouldRetry) {
+                this.logger.debug('listenMessagesAndRenew', { shouldRetry: true });
+                // Retry
+                this.messageTimeoutTryAgain();
+            }
+            else if (shouldAutoResubscribe) {
+                this.logger.debug('listenMessagesAndRenew', {
+                    shouldAutoResubscribe: true,
+                });
+                // Resubscribe
+                this.autoResubscribe();
+            }
+            // Update subscriber status.
+            this.statusStream$.next(this.subscriberStatus);
+            // Debug stats
+            this.logger.debug('listenMessagesAndRenew', 'Message stats', this.receivedDataStats);
+        }, this.timerIntervalInSec * 1000);
+    }
+    addTerminateToAction(telemetryAction) {
+        const unsubscribeOperation = teletubby_pb_1.UnsubscribeOperation.create({
+            options: [
+                {
+                    content: {
+                        receivergroupUnsubscribeOption: {
+                            terminate: true,
+                        },
+                        oneofKind: 'receivergroupUnsubscribeOption',
+                    },
+                },
+            ],
+        });
+        telemetryAction.content = {
+            oneofKind: 'unsubscribeOperation',
+            unsubscribeOperation,
+        };
+    }
+    messageTimeoutTryAgain() {
+        // Increase retry times.
+        this.retryTimes++;
+        // Remove the received call anyway.
+        this.stopInternal();
+        this.lastMessageReceived = undefined;
+        this.lastRobotMessageReceived = undefined;
+        this.registerReceiver();
+    }
+    /**
+     * Auto resubscribe to reduce CPU usage.
+     */
+    autoResubscribe() {
+        // Reset
+        this.retryTimes = 0;
+        // Remove the received call anyway.
+        this.stopInternal();
+        this.lastMessageReceived = undefined;
+        this.lastRobotMessageReceived = undefined;
+        this.registerReceiver();
+    }
+    isFoundCallsign(callsign) {
+        return this.callsignsLookup.lookupType === models_1.CallsignsLookupType.List
+            ? this.callsignsLookup.lookupValue.indexOf(callsign) !== -1
+            : true; // If callsigns lookup option is query, we always return true
+    }
+    isFoundSource(source) {
+        return this.sources.indexOf(source) !== -1;
+    }
+    isRegisteredMessage(callsign, source) {
+        return this.isFoundCallsign(callsign) && this.isFoundSource(source);
+    }
+    updateReceivedDataStatsWithMessage(msg) {
+        const { source } = msg;
+        const { callsign } = msg;
+        const id = `${callsign}-${source}`;
+        if (!this.receivedDataStats) {
+            this.receivedDataStats = {};
+        }
+        const count = this.receivedDataStats[id] ? this.receivedDataStats[id] : 0;
+        this.receivedDataStats[id] = count + 1;
+    }
+}
+exports.TelemetryStreamAbstract = TelemetryStreamAbstract;