@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/api/atoms/StreamHeartbeat.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamHeartbeat = void 0;
+const RocosLogger_1 = require("../../logger/RocosLogger");
+class StreamHeartbeat {
+    constructor(identifier) {
+        this.beats = 0;
+        this.healthLastSeenDate = new Date();
+        this.healthMisses = 0;
+        this.healthTimeout = 6000; // check for healthy heartbeat every 6 seconds
+        this.healthMaxTimeout = 10;
+        this.healthMaxMisses = 5;
+        this.identifier = identifier;
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`StreamHeartbeat(${this.identifier})`);
+    }
+    setHealthTimeout(healthTimeout) {
+        this.healthTimeout = healthTimeout;
+        return this;
+    }
+    setHealthMaxTimeout(healthMaxTimeout) {
+        this.healthMaxTimeout = healthMaxTimeout;
+        return this;
+    }
+    setHealthMaxMisses(healthMaxMisses) {
+        this.healthMaxMisses = healthMaxMisses;
+        return this;
+    }
+    setHealthCheckStatusCallback(healthCheckStatusCallback) {
+        this.healthCheckStatusCallback = healthCheckStatusCallback;
+        return this;
+    }
+    setHealthCheckErrorCallback(healthCheckErrorCallback) {
+        this.healthCheckErrorCallback = healthCheckErrorCallback;
+        return this;
+    }
+    start(callback, timeout) {
+        if (!this.interval) {
+            this.callback = callback;
+            this.timeout = timeout;
+            this.logger.info('Creating stream heartbeat');
+            this.interval = setInterval(this.callback, this.timeout);
+        }
+        else {
+            this.logger.warn('Stream heartbeat already exists');
+        }
+    }
+    stop() {
+        try {
+            this.logger.info('Removing stream heartbeat timer');
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        catch (e) {
+            this.logger.error(`Error killing stream heartbeat timer ${e}`);
+        }
+    }
+    pump() {
+        // if the health check has not started yet, we initialise it
+        if (!this.healthInterval) {
+            this.logger.debug('Starting health check timer');
+            this.healthInterval = setInterval(this.checkHealth, this.healthTimeout);
+            this.healthLastSeenDate = new Date();
+            this.healthMisses = 0;
+        }
+        else {
+            this.logger.debug(`Updating health check timer: ${this.healthLastSeenDate}, ${this.healthMisses}`);
+            this.healthLastSeenDate = new Date();
+            this.healthMisses = 0;
+        }
+        return this.beats++;
+    }
+    async checkHealth() {
+        this.logger.debug('Checking health');
+        let status = true;
+        // check to see if we have received a heartbeat in in the last few seconds
+        const lastSeenInSeconds = (new Date().getTime() - this.healthLastSeenDate.getTime()) / 1000;
+        if (lastSeenInSeconds > this.healthMaxTimeout && this.healthMaxMisses) {
+            status = false;
+            this.healthMisses += 1;
+            this.logger.warn(`Heartbeat is more than ${this.healthMaxTimeout} seconds, delay: ${lastSeenInSeconds} seconds, misses: ${this.healthMisses}`);
+            if (this.healthMisses === this.healthMaxMisses) {
+                this.stopHealthCheck();
+                this.logger.error(`Stopping Heartbeat as it is more than ${this.healthMaxTimeout} seconds, delay - ${lastSeenInSeconds} seconds, misses: ${this.healthMisses}`);
+                if (this.healthCheckErrorCallback) {
+                    await this.healthCheckErrorCallback();
+                }
+            }
+        }
+        else if (lastSeenInSeconds > this.healthMaxTimeout) {
+            status = false;
+            this.logger.warn(`Stopping Heartbeat as it is more than ${this.healthMaxTimeout} seconds, delay - ${lastSeenInSeconds} seconds`);
+            this.stopHealthCheck();
+            if (this.healthCheckErrorCallback) {
+                await this.healthCheckErrorCallback();
+            }
+        }
+        if (this.healthCheckStatusCallback) {
+            await this.healthCheckStatusCallback(status);
+        }
+    }
+    stopHealthCheck() {
+        if (this.healthInterval) {
+            try {
+                this.logger.info('Stopping timer');
+                clearInterval(this.healthInterval);
+                this.healthInterval = undefined;
+                this.logger.info('Removed timer');
+            }
+            catch (e) {
+                this.logger.error('error removing timer', e);
+            }
+        }
+    }
+}
+exports.StreamHeartbeat = StreamHeartbeat;

package/api/streams/caller/CallerStream.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+import { ICallerParams } from '../../../models/params/ICallerParams';
+import { IRocosCallerMessage } from '../../../models/message/IRocosCallerMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class CallerStream extends CallerStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: ServiceRequest | RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected setPayload(request: ServiceRequest, payload: string): void;
+    private getMetadata;
+}

package/api/streams/caller/CallerStream.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerStream = void 0;
+const rxjs_1 = require("rxjs");
+const serviette_v1_pb_1 = require("../../../grpc/serviette/serviette.v1_pb");
+const serviette_v1_pb_service_1 = require("../../../grpc/serviette/serviette.v1_pb_service");
+const CallerStreamAbstract_1 = require("./CallerStreamAbstract");
+const RocosCallerMessage_1 = require("../../../models/message/RocosCallerMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const stringToUint8Array_1 = require("../../../helpers/stringToUint8Array");
+class CallerStream extends CallerStreamAbstract_1.CallerStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CallerStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new serviette_v1_pb_service_1.WebServiceCallerClient(`${protocol}://${this.url}`);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            let requestType = 'invoke';
+            if (request instanceof serviette_v1_pb_1.RequestCancellation) {
+                call = this.client.cancelService(request, metadata);
+                requestType = 'cancel';
+            }
+            else {
+                call = this.client.callService(request, metadata);
+            }
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosCallerMessage_1.RocosCallerMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug(`${requestType}Request - on(data)`, {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                // A result message will be sent from data, so we don't need to notify the subscriber this is the end.
+                this.logger.debug(`${requestType}Request - on(end)`, {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                emitter.complete();
+            });
+            call.on('status', (status) => {
+                this.logger.debug(`${requestType}Request - on(status)`, {
+                    status,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                // TODO: match fail status and emit an error
+                // emitter.error(error)
+            });
+            return () => {
+                this.logger.debug('unsubscribing callStream');
+                call.cancel();
+            };
+        });
+    }
+    setPayload(request, payload) {
+        request.setPayload(stringToUint8Array_1.stringToUint8Array(payload));
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+            'r-s': subsystem || '',
+        };
+    }
+}
+exports.CallerStream = CallerStream;

package/api/streams/caller/CallerStreamAbstract.d.ts

@@ -0,0 +1,28 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ICallerInvokeParams, ICallerParams } from '../../../models/params/ICallerParams';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette/serviette.v1_pb';
+import { ICallerStream } from '../../../models/stream/ICallerStream';
+import { IRocosCallerMessage } from '../../../models/message/IRocosCallerMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { Logger } from 'loglevel';
+import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
+export declare abstract class CallerStreamAbstract implements ICallerStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    constructor(config: IStreamConfig);
+    protected abstract callStream(request: ServiceRequest | RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected abstract setPayload(request: ServiceRequest, payload: string): void;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
+    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
+    private createCancellationRequest;
+    private createServiceHeader;
+    private createServiceRequest;
+    private createRocosUriPath;
+}

package/api/streams/caller/CallerStreamAbstract.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const serviette_v1_pb_1 = require("../../../grpc/serviette/serviette.v1_pb");
+const uri_v1_pb_1 = require("../../../grpc/serviette/uri.v1_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");
+const uuid_1 = require("uuid");
+class CallerStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_CALLER, 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
+    }
+    invokeRequest(params) {
+        this.logger.info('invokeRequest', params);
+        const responseLevel = params.responseLevelNumber;
+        const request = this.createServiceRequest(params.uid, params.projectId, params.callsign, params.component, params.topic, responseLevel, params.payload, params.query);
+        return this.callStream(request, params);
+    }
+    cancelRequest(params) {
+        this.logger.info('cancelRequest', params);
+        const request = this.createCancellationRequest(params.uid);
+        return this.callStream(request, params);
+    }
+    createCancellationRequest(uid) {
+        const request = new serviette_v1_pb_1.RequestCancellation();
+        const serviceCallUID = new serviette_v1_pb_1.ServiceCallUID();
+        serviceCallUID.setHash(uid);
+        request.setUid(serviceCallUID);
+        return request;
+    }
+    createServiceHeader(uri, responseLevel) {
+        const serviceRequestHeader = new serviette_v1_pb_1.ServiceRequestHeader();
+        serviceRequestHeader.setCreated(Date.now());
+        serviceRequestHeader.setSource(uri);
+        serviceRequestHeader.setResponselevel(responseLevel);
+        return serviceRequestHeader;
+    }
+    // eslint-disable-next-line max-params
+    createServiceRequest(uid, projectId, callsign, component, topic, responseLevel, payload, query) {
+        const path = this.createRocosUriPath(projectId, callsign, component, topic, undefined);
+        const uri = new uri_v1_pb_1.RocosURI();
+        uri.setPath(path);
+        uri.setScheme(uri_v1_pb_1.RocosURIScheme.GRPC);
+        if (query) {
+            const queryMap = uri.getQueryMap();
+            Object.keys(query).forEach((key) => {
+                const vals = new uri_v1_pb_1.RocosURIQueryValues();
+                query[key].forEach((v) => vals.addValues(v));
+                queryMap.set(key, vals);
+            });
+        }
+        const request = new serviette_v1_pb_1.ServiceRequest();
+        const serviceCallUID = new serviette_v1_pb_1.ServiceCallUID();
+        serviceCallUID.setVersion(serviette_v1_pb_1.UIDVersion.HEADER_HASH_RAND);
+        if (!uid) {
+            uid = uuid_1.v4();
+        }
+        serviceCallUID.setHash(uid);
+        const serviceRequestHeader = this.createServiceHeader(uri, responseLevel);
+        request.setUid(serviceCallUID);
+        request.setHeader(serviceRequestHeader);
+        this.setPayload(request, payload);
+        return request;
+    }
+    createRocosUriPath(projectId, callsign, component, topic, subsystem) {
+        const path = new uri_v1_pb_1.RocosURIPath();
+        path.setProject(projectId);
+        path.setCallsign(callsign);
+        path.setComponent(component);
+        path.setTopic(topic);
+        if (subsystem) {
+            path.setSubsystem(subsystem);
+        }
+        return path;
+    }
+}
+exports.CallerStreamAbstract = CallerStreamAbstract;

package/api/streams/caller/CallerStreamNode.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+import { ICallerParams } from '../../../models/params/ICallerParams';
+import { IRocosCallerMessage } from '../../../models/message/IRocosCallerMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class CallerStreamNode extends CallerStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: ServiceRequest | RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected setPayload(request: ServiceRequest, payload: string): void;
+    private getMetadata;
+}

package/api/streams/caller/CallerStreamNode.js

@@ -0,0 +1,128 @@
+"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.CallerStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const rxjs_1 = require("rxjs");
+const serviette_v1_pb_1 = require("../../../grpc/serviette/serviette.v1_pb");
+const CallerStreamAbstract_1 = require("./CallerStreamAbstract");
+const RocosCallerMessage_1 = require("../../../models/message/RocosCallerMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const serviette_v1_grpc_pb_1 = require("../../../grpc/serviette/serviette.v1_grpc_pb");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class CallerStreamNode extends CallerStreamAbstract_1.CallerStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CallerStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new serviette_v1_grpc_pb_1.ServiceCallerClient(`${this.url}:${port}`, credentials);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.callServices(metadata);
+            const req = new serviette_v1_pb_1.RequestChannelMessage();
+            let requestType = 'invoke';
+            if (request instanceof serviette_v1_pb_1.RequestCancellation) {
+                const rc = new serviette_v1_pb_1.RequestCancellations();
+                rc.addCancellations(request);
+                req.setCancellations(rc);
+                requestType = 'cancel';
+            }
+            else {
+                const sr = new serviette_v1_pb_1.ServiceRequests();
+                sr.addRequests(request);
+                req.setRequests(sr);
+            }
+            this.logger.info(`${requestType}Request - call`);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.write(req, () => {
+                this.logger.info(`${requestType}Request write completed for - ${req}`);
+            });
+            call.on('data', (update) => {
+                const message = RocosCallerMessage_1.RocosCallerMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug(`${requestType}Request - on(data)`, {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+            });
+            call.on('finish', () => {
+                this.logger.info(`${requestType}Request - on(finish) all writes are now complete`);
+                call.end();
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(end)`, {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                call.pause();
+                call.destroy();
+                this.client.close();
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(close)`);
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                if (error.stack.match('2 UNKNOWN: heartbeat watchdog strike')) {
+                    this.logger.debug(`${requestType}Request grpc Error heartbeat error`, error);
+                    call.end();
+                    emitter.complete();
+                }
+                else {
+                    this.logger.error(`${requestType}Request - on(error)`, error);
+                    emitter.error(error);
+                }
+            });
+            return () => {
+                this.logger.debug('unsubscribing callStream');
+                call.cancel();
+            };
+        });
+    }
+    setPayload(request, payload) {
+        request.setPayload(Buffer.from(payload).toString('base64'));
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = new grpc.Metadata();
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        meta.add('r-s', subsystem || '');
+        meta.add('authorization', this.token);
+        return meta;
+    }
+}
+exports.CallerStreamNode = CallerStreamNode;

package/api/streams/command/CommandStream.d.ts

@@ -0,0 +1,12 @@
+import { CommandRequest } from '../../../grpc/rambo/rambo.v1_pb';
+import { Observable } from 'rxjs';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+import { ICommandParams } from '../../../models/params/ICommandParams';
+import { IRocosCommandMessage } from '../../../models/message/IRocosCommandMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class CommandStream extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}

package/api/streams/command/CommandStream.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandStream = void 0;
+const rambo_v1_pb_service_1 = require("../../../grpc/rambo/rambo.v1_pb_service");
+const rxjs_1 = require("rxjs");
+const CommandStreamAbstract_1 = require("./CommandStreamAbstract");
+const RocosCommandMessage_1 = require("../../../models/message/RocosCommandMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class CommandStream extends CommandStreamAbstract_1.CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CommandStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new rambo_v1_pb_service_1.CommandClient(`${protocol}://${this.url}`);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.callCommand(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosCommandMessage_1.RocosCommandMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug('invokeRequest - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.complete();
+            });
+            call.on('status', (status) => {
+                this.logger.debug('invokeRequest - on(status)', {
+                    status,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                // TODO: match fail status and emit an error
+                // emitter.error(error)
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                call.cancel();
+            };
+        });
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}
+exports.CommandStream = CommandStream;

package/api/streams/command/CommandStreamAbstract.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { CommandRequest } from '../../../grpc/rambo/rambo.v1_pb';
+import { ICommandParams } from '../../../models/params/ICommandParams';
+import { ICommandStream } from '../../../models/stream/ICommandStream';
+import { IRocosCommandMessage } from '../../../models/message/IRocosCommandMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { Logger } from 'loglevel';
+import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
+export declare abstract class CommandStreamAbstract implements ICommandStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    constructor(config: IStreamConfig);
+    protected abstract callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICommandParams): Observable<IRocosCommandMessage>;
+    private createCommandRequest;
+    private createRocosUriPath;
+}

package/api/streams/command/CommandStreamAbstract.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const uri_v1_pb_1 = require("../../../grpc/rambo/uri.v1_pb");
+const rambo_v1_pb_1 = require("../../../grpc/rambo/rambo.v1_pb");
+const identifier_1 = require("../../../constants/identifier");
+const ResponseLevelEnum_1 = require("../../../models/ResponseLevelEnum");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamRegister_1 = require("../../StreamRegister");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const operators_1 = require("rxjs/operators");
+const getUnixTimeMs_1 = require("../../../helpers/getUnixTimeMs");
+const randomString_1 = require("../../../helpers/randomString");
+class CommandStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_COMMAND, 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
+    }
+    invokeRequest(params) {
+        if (params.timeoutMs === undefined || params.timeoutMs === null) {
+            params.timeoutMs = 30 * 1000; // Default 30 seconds.
+        }
+        this.logger.info('invokeRequest', params);
+        const request = this.createCommandRequest(params.projectId, params.callsign, params.commandId, params.parameters, params.timeoutMs, params.responseLevel);
+        return this.callStream(request, params);
+    }
+    createCommandRequest(projectId, callsign, commandId, parameters, timeoutMs = 30 * 1000, // Default 30 seconds.
+    responseLevel = ResponseLevelEnum_1.ResponseLevelEnum.ALL) {
+        const path = this.createRocosUriPath(projectId, callsign, commandId);
+        const uri = new uri_v1_pb_1.RocosUri();
+        uri.setPath(path);
+        uri.setScheme(uri_v1_pb_1.RocosUriScheme.GRPC);
+        const request = new rambo_v1_pb_1.CommandRequest();
+        request.setTxid(randomString_1.randomString());
+        request.setUri(uri);
+        request.setReslevel(responseLevel);
+        if (parameters) {
+            Object.keys(parameters).forEach((key) => {
+                request.getParametersMap().set(key, parameters[key]);
+            });
+        }
+        request.setDeadlinems(getUnixTimeMs_1.getUnixTimeMs(timeoutMs));
+        return request;
+    }
+    createRocosUriPath(projectId, callsign, commandId) {
+        const path = new uri_v1_pb_1.RocosUriPath();
+        path.setProject(projectId);
+        path.setCallsign(callsign);
+        path.setTopic(commandId);
+        path.setComponent('command-executor');
+        return path;
+    }
+}
+exports.CommandStreamAbstract = CommandStreamAbstract;