@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.20

package/cjs/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/cjs/api/streams/caller/CallerStream.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerStream = void 0;
+const models_1 = require("../../../models");
+const rxjs_1 = require("rxjs");
+const CallerStreamAbstract_1 = require("./CallerStreamAbstract");
+const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const serviette_v1_pb_client_1 = require("../../../grpc/serviette.v1_pb.client");
+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';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new grpcweb_transport_1.GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new serviette_v1_pb_client_1.WebServiceCallerClient(transport);
+    }
+    callService(request, params) {
+        const meta = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        const stream = this.client.callService(request, { meta });
+        return this.handleStream(stream, params, 'invoke');
+    }
+    cancelService(request, params) {
+        const meta = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        const stream = this.client.cancelService(request, { meta });
+        return this.handleStream(stream, params, 'cancel');
+    }
+    handleStream(stream, params, requestType) {
+        return new rxjs_1.Observable((emitter) => {
+            this.subscriberStatus = models_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            stream.responses.onMessage((message) => {
+                const msg = models_1.RocosCallerMessage.fromModel(message);
+                emitter.next(msg);
+                this.logger.debug(`${requestType}Request - on(data)`, {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+            });
+            stream.responses.onError((error) => {
+                this.logger.debug(`${requestType}Request - on(error)`, {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                emitter.error(error);
+            });
+            stream.responses.onComplete(() => {
+                this.subscriberStatus = models_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,
+                });
+                emitter.complete();
+            });
+        });
+    }
+    getPayload(payload) {
+        return (0, stringToUint8Array_1.stringToUint8Array)(payload);
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = {
+            'r-p': projectId,
+            'r-cs': callsign,
+            'r-s': subsystem ?? '',
+        };
+        if (this.token) {
+            meta.authorization = this.token;
+        }
+        return meta;
+    }
+}
+exports.CallerStream = CallerStream;

package/cjs/api/streams/caller/CallerStreamAbstract.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const models_1 = require("../../../models");
+const serviette_v1_pb_1 = require("../../../grpc/serviette.v1_pb");
+const serviette_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 operators_1 = require("rxjs/operators");
+const uuid_1 = require("uuid");
+class CallerStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = models_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(models_1.SubscriberStatusEnum.STOPPED);
+        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;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    invokeRequest(params) {
+        this.logger.info('invokeRequest', params);
+        const responseLevel = params.responseLevelNumber;
+        const request = this.createServiceRequest(params.projectId, params.callsign, params.component, params.topic, responseLevel, params.payload, params.uid, params.query);
+        return this.callService(request, params);
+    }
+    cancelRequest(params) {
+        this.logger.info('cancelRequest', params);
+        const request = this.createCancellationRequest(params.uid);
+        return this.cancelService(request, params);
+    }
+    createCancellationRequest(uid) {
+        return serviette_v1_pb_1.RequestCancellation.create({
+            uid: {
+                content: {
+                    oneofKind: 'hash',
+                    hash: uid,
+                },
+            },
+        });
+    }
+    createServiceRequest(projectId, callsign, component, topic, responseLevel, payload, uid, query) {
+        const uri = serviette_uri_v1_pb_1.RocosURI.create({
+            path: {
+                project: projectId,
+                callsign,
+                component,
+                topic,
+            },
+            scheme: serviette_uri_v1_pb_1.RocosURIScheme.GRPC,
+        });
+        if (query) {
+            const queryMap = uri.query;
+            Object.keys(query).forEach((key) => {
+                queryMap[key] = serviette_uri_v1_pb_1.RocosURIQueryValues.create({
+                    values: [...query[key]],
+                });
+            });
+        }
+        return serviette_v1_pb_1.ServiceRequest.create({
+            header: {
+                created: Date.now().toString(),
+                source: uri,
+                responseLevel,
+            },
+            uid: {
+                version: serviette_v1_pb_1.UIDVersion.HEADER_HASH_RAND,
+                content: {
+                    oneofKind: 'hash',
+                    hash: uid ?? (0, uuid_1.v4)(),
+                },
+            },
+            payload: this.getPayload(payload),
+        });
+    }
+}
+exports.CallerStreamAbstract = CallerStreamAbstract;

package/cjs/api/streams/caller/CallerStreamNode.js

@@ -0,0 +1,143 @@
+"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.CallerStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const models_1 = require("../../../models");
+const rxjs_1 = require("rxjs");
+const serviette_v1_pb_1 = require("../../../grpc/serviette.v1_pb");
+const CallerStreamAbstract_1 = require("./CallerStreamAbstract");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const serviette_v1_pb_grpc_client_1 = require("../../../grpc/serviette.v1_pb.grpc-client");
+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_pb_grpc_client_1.ServiceCallerClient(`${this.url}:${port}`, credentials);
+    }
+    cancelService(request, params) {
+        return this.callStream(serviette_v1_pb_1.RequestChannelMessage.create({
+            content: {
+                oneofKind: 'cancellations',
+                cancellations: {
+                    cancellations: [request],
+                },
+            },
+        }), params, 'cancel');
+    }
+    callService(request, params) {
+        return this.callStream(serviette_v1_pb_1.RequestChannelMessage.create({
+            content: {
+                oneofKind: 'requests',
+                requests: {
+                    requests: [request],
+                },
+            },
+        }), params, 'invoke');
+    }
+    callStream(request, params, requestType) {
+        const metadata = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.callServices(metadata);
+            this.logger.info(`${requestType}Request - call`);
+            this.subscriberStatus = models_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.write(request, () => {
+                if (this.logger.getLevel().valueOf() <= 2) {
+                    this.logger.info(`${requestType}Request write completed for - ${JSON.stringify(request, (_, v) => {
+                        return typeof v === 'bigint' ? `${v.toString()}n` : v;
+                    })}`);
+                }
+            });
+            call.on('data', (update) => {
+                const message = models_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 = models_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 = models_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(close)`);
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = models_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                if (/10 ABORTED: heartbeat watchdog strike/.exec(error.stack)) {
+                    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();
+            };
+        });
+    }
+    getPayload(payload) {
+        return Buffer.from(payload);
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = new grpc.Metadata();
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        meta.add('r-s', subsystem ?? '');
+        if (this.token)
+            meta.add('authorization', this.token);
+        return meta;
+    }
+}
+exports.CallerStreamNode = CallerStreamNode;

package/cjs/api/streams/command/CommandStream.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandStream = void 0;
+const models_1 = require("../../../models");
+const rxjs_1 = require("rxjs");
+const rambo_v1_pb_client_1 = require("../../../grpc/rambo.v1_pb.client");
+const CommandStreamAbstract_1 = require("./CommandStreamAbstract");
+const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+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';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = new grpcweb_transport_1.GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+        });
+        this.client = new rambo_v1_pb_client_1.CommandClient(transport);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const abortController = new AbortController();
+        return new rxjs_1.Observable((emitter) => {
+            const call = this.client.callCommand(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = models_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const message = models_1.RocosCommandMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug('invokeRequest - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('invokeRequest - on(error)', {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.error(error);
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = models_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();
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                abortController.abort();
+            };
+        });
+    }
+    getMetadata(projectId, callsign) {
+        const meta = {
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+        if (this.token) {
+            meta.authorization = this.token;
+        }
+        return meta;
+    }
+}
+exports.CommandStream = CommandStream;

package/cjs/api/streams/command/CommandStreamAbstract.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const models_1 = require("../../../models");
+const rambo_uri_v1_pb_1 = require("../../../grpc/rambo.uri.v1_pb");
+const rambo_v1_pb_1 = require("../../../grpc/rambo.v1_pb");
+const identifier_1 = require("../../../constants/identifier");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamRegister_1 = require("../../StreamRegister");
+const operators_1 = require("rxjs/operators");
+const getUnixTimeMs_1 = require("../../../helpers/getUnixTimeMs");
+const randomString_1 = require("../../../helpers/randomString");
+class CommandStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = models_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(models_1.SubscriberStatusEnum.STOPPED);
+        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;
+    }
+    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 = models_1.ResponseLevelEnum.ALL) {
+        const path = this.createRocosUriPath(projectId, callsign, commandId);
+        return rambo_v1_pb_1.CommandRequest.create({
+            txid: (0, randomString_1.randomString)(),
+            uri: {
+                path,
+                scheme: rambo_uri_v1_pb_1.RocosUriScheme.GRPC,
+            },
+            resLevel: responseLevel.valueOf(),
+            deadlineMs: (0, getUnixTimeMs_1.getUnixTimeMs)(timeoutMs).toString(),
+            parameters,
+        });
+    }
+    createRocosUriPath(projectId, callsign, commandId) {
+        return rambo_uri_v1_pb_1.RocosUriPath.create({
+            callsign,
+            project: projectId,
+            component: 'command-executor',
+            topic: commandId,
+        });
+    }
+}
+exports.CommandStreamAbstract = CommandStreamAbstract;

package/cjs/api/streams/command/CommandStreamNode.js

@@ -0,0 +1,97 @@
+"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.CommandStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const models_1 = require("../../../models");
+const rxjs_1 = require("rxjs");
+const rambo_v1_pb_grpc_client_1 = require("../../../grpc/rambo.v1_pb.grpc-client");
+const CommandStreamAbstract_1 = require("./CommandStreamAbstract");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+class CommandStreamNode extends CommandStreamAbstract_1.CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CommandStreamNode(${this.identifier})`);
+        const port = config.port ?? 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new rambo_v1_pb_grpc_client_1.CommandClient(`${this.url}:${port}`, credentials);
+    }
+    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 = models_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = models_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 = models_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('close', () => {
+                this.subscriberStatus = models_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = models_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(error)', error);
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                call.cancel();
+            };
+        });
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = new grpc.Metadata();
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        if (subsystem) {
+            meta.add('r-s', subsystem);
+        }
+        if (this.token)
+            meta.add('authorization', this.token);
+        return meta;
+    }
+}
+exports.CommandStreamNode = CommandStreamNode;