@dronedeploy/rocos-js-sdk 1.0.0-alpha-2 → 2.6.1

package/api/streams/caller/CallerStream.js

@@ -1,37 +1,38 @@
-import { RocosCallerMessage, SubscriberStatusEnum, } from '../../../models';
-import { Observable } from 'rxjs';
-import { CallerStreamAbstract } from './CallerStreamAbstract';
-import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
-import { RocosLogger } from '../../../logger/RocosLogger';
-import { WebServiceCallerClient } from '../../../grpc/serviette.v1_pb.client';
-import { stringToUint8Array } from '../../../helpers/stringToUint8Array';
-export class CallerStream extends CallerStreamAbstract {
+"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.getInstance(`CallerStream(${this.identifier})`);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CallerStream(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
-        const transport = new GrpcWebFetchTransport({
-            baseUrl: `${protocol}://${this.url}`,
-        });
-        this.client = new 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');
+        this.client = new serviette_v1_pb_service_1.WebServiceCallerClient(`${protocol}://${this.url}`);
     }
-    handleStream(stream, params, requestType) {
-        return new Observable((emitter) => {
-            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+    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);
-            stream.responses.onMessage((message) => {
-                const msg = RocosCallerMessage.fromModel(message);
-                emitter.next(msg);
+            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,
@@ -40,38 +41,45 @@ export class CallerStream extends CallerStreamAbstract {
                     topic: params.topic,
                 });
             });
-            stream.responses.onError((error) => {
-                this.logger.debug(`${requestType}Request - on(error)`, {
-                    error,
+            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.error(error);
+                emitter.complete();
             });
-            stream.responses.onComplete(() => {
-                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
-                this.statusStream$.next(this.subscriberStatus);
-                this.logger.debug(`${requestType}Request - on(end)`, {
+            call.on('status', (status) => {
+                this.logger.debug(`${requestType}Request - on(status)`, {
+                    status,
                     projectId: params.projectId,
                     callsign: params.callsign,
                     component: params.component,
                     topic: params.topic,
                 });
-                emitter.complete();
+                // TODO: match fail status and emit an error
+                // emitter.error(error)
             });
+            return () => {
+                this.logger.debug('unsubscribing callStream');
+                call.cancel();
+            };
         });
     }
-    getPayload(payload) {
-        return stringToUint8Array(payload);
+    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 ?? '',
+            'r-s': subsystem || '',
         };
     }
 }
+exports.CallerStream = CallerStream;

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

@@ -1,7 +1,11 @@
 import { BehaviorSubject, Observable } from 'rxjs';
-import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
-import { RequestCancellation } from '../../../grpc/serviette.v1_pb';
+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>;
@@ -10,14 +14,15 @@ export declare abstract class CallerStreamAbstract implements ICallerStream {
     protected url: string;
     protected subscriberStatus: SubscriberStatusEnum;
     protected logger: Logger;
-    protected constructor(config: IStreamConfig);
-    protected abstract cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
-    protected abstract callService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
-    protected abstract getPayload(payload: string): Uint8Array;
+    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

@@ -1,22 +1,25 @@
-import { BehaviorSubject } from 'rxjs';
-import { SubscriberStatusEnum, } from '../../../models';
-import { RequestCancellation, ServiceRequest, UIDVersion } from '../../../grpc/serviette.v1_pb';
-import { RocosURI, RocosURIQueryValues, RocosURIScheme } from '../../../grpc/serviette.uri.v1_pb';
-import { IDENTIFIER_NAME_CALLER } from '../../../constants/identifier';
-import { RocosStore } from '../../../store/RocosStore';
-import { StreamRegister } from '../../StreamRegister';
-import { filter } from 'rxjs/operators';
-import { v4 as uuidv4 } from 'uuid';
-export class CallerStreamAbstract {
+"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.STOPPED;
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
         this.scope = config.scope;
-        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_CALLER, this.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 BehaviorSubject(SubscriberStatusEnum.STOPPED);
-        RocosStore.getChangeSubject()
-            .pipe(filter((message) => {
+        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) => {
@@ -32,56 +35,65 @@ export class CallerStreamAbstract {
     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);
+        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.cancelService(request, params);
+        return this.callStream(request, params);
     }
     createCancellationRequest(uid) {
-        return RequestCancellation.create({
-            uid: {
-                content: {
-                    oneofKind: 'hash',
-                    hash: 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;
     }
-    createServiceRequest(projectId, callsign, component, topic, responseLevel, payload, uid, query) {
-        const uri = RocosURI.create({
-            path: {
-                project: projectId,
-                callsign,
-                component,
-                topic,
-            },
-            scheme: RocosURIScheme.GRPC,
-        });
+    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.query;
+            const queryMap = uri.getQueryMap();
             Object.keys(query).forEach((key) => {
-                queryMap[key] = RocosURIQueryValues.create({
-                    values: [...query[key]],
-                });
+                const vals = new uri_v1_pb_1.RocosURIQueryValues();
+                query[key].forEach((v) => vals.addValues(v));
+                queryMap.set(key, vals);
             });
         }
-        return ServiceRequest.create({
-            header: {
-                created: BigInt(Date.now()),
-                source: uri,
-                responseLevel,
-            },
-            uid: {
-                version: UIDVersion.HEADER_HASH_RAND,
-                content: {
-                    oneofKind: 'hash',
-                    hash: uid ?? uuidv4(),
-                },
-            },
-            payload: this.getPayload(payload),
-        });
+        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

@@ -1,13 +1,13 @@
-import { ICallerParams, IRocosCallerMessage, IStreamConfig } from '../../../models';
 import { Observable } from 'rxjs';
-import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette.v1_pb';
+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 cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
-    protected callService(request: ServiceRequest, params: ICallerParams): Observable<IRocosCallerMessage>;
-    private callStream;
-    protected getPayload(payload: string): Uint8Array;
+    protected callStream(request: ServiceRequest | RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected setPayload(request: ServiceRequest, payload: string): void;
     private getMetadata;
 }

package/api/streams/caller/CallerStreamNode.js

@@ -1,55 +1,67 @@
-import * as grpc from '@grpc/grpc-js';
-import { RocosCallerMessage, SubscriberStatusEnum, } from '../../../models';
-import { Observable } from 'rxjs';
-import { RequestChannelMessage, } from '../../../grpc/serviette.v1_pb';
-import { CallerStreamAbstract } from './CallerStreamAbstract';
-import { RocosLogger } from '../../../logger/RocosLogger';
-import { ServiceCallerClient } from '../../../grpc/serviette.v1_pb.grpc-client';
-export class CallerStreamNode extends CallerStreamAbstract {
+"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.getInstance(`CallerStreamNode(${this.identifier})`);
-        const port = config.port ?? 443;
+        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 ServiceCallerClient(`${this.url}:${port}`, credentials);
+        this.client = new serviette_v1_grpc_pb_1.ServiceCallerClient(`${this.url}:${port}`, credentials);
     }
-    cancelService(request, params) {
-        return this.callStream(RequestChannelMessage.create({
-            content: {
-                oneofKind: 'cancellations',
-                cancellations: {
-                    cancellations: [request],
-                },
-            },
-        }), params, 'cancel');
-    }
-    callService(request, params) {
-        return this.callStream(RequestChannelMessage.create({
-            content: {
-                oneofKind: 'requests',
-                requests: {
-                    requests: [request],
-                },
-            },
-        }), params, 'invoke');
-    }
-    callStream(request, params, requestType) {
+    callStream(request, params) {
         const metadata = this.getMetadata(params.projectId, params.callsign, params.subSystem);
         let call;
-        return new Observable((emitter) => {
+        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.ALIVE;
+            this.subscriberStatus = SubscriberStatusEnum_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.write(req, () => {
+                this.logger.info(`${requestType}Request write completed for - ${req}`);
             });
             call.on('data', (update) => {
-                const message = RocosCallerMessage.fromModel(update);
+                const message = RocosCallerMessage_1.RocosCallerMessage.fromModel(update);
                 emitter.next(message);
                 this.logger.debug(`${requestType}Request - on(data)`, {
                     message,
@@ -64,7 +76,7 @@ export class CallerStreamNode extends CallerStreamAbstract {
                 call.end();
             });
             call.on('end', () => {
-                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
                 this.statusStream$.next(this.subscriberStatus);
                 this.logger.debug(`${requestType}Request - on(end)`, {
                     projectId: params.projectId,
@@ -78,14 +90,14 @@ export class CallerStreamNode extends CallerStreamAbstract {
                 emitter.complete();
             });
             call.on('close', () => {
-                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                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.ERROR;
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
                 this.statusStream$.next(this.subscriberStatus);
-                if (/10 ABORTED: heartbeat watchdog strike/.exec(error.stack)) {
+                if (error.stack.match('2 UNKNOWN: heartbeat watchdog strike')) {
                     this.logger.debug(`${requestType}Request grpc Error heartbeat error`, error);
                     call.end();
                     emitter.complete();
@@ -101,15 +113,16 @@ export class CallerStreamNode extends CallerStreamAbstract {
             };
         });
     }
-    getPayload(payload) {
-        return Buffer.from(payload);
+    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('r-s', subsystem || '');
         meta.add('authorization', this.token);
         return meta;
     }
 }
+exports.CallerStreamNode = CallerStreamNode;

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

@@ -1,7 +1,9 @@
-import { ICommandParams, IRocosCommandMessage, IStreamConfig } from '../../../models';
+import { CommandRequest } from '../../../grpc/rambo/rambo.v1_pb';
 import { Observable } from 'rxjs';
-import { CommandRequest } from '../../../grpc/rambo.v1_pb';
 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);

package/api/streams/command/CommandStream.js

@@ -1,28 +1,28 @@
-import { RocosCommandMessage, SubscriberStatusEnum, } from '../../../models';
-import { Observable } from 'rxjs';
-import { CommandClient } from '../../../grpc/rambo.v1_pb.client';
-import { CommandStreamAbstract } from './CommandStreamAbstract';
-import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
-import { RocosLogger } from '../../../logger/RocosLogger';
-export class CommandStream extends CommandStreamAbstract {
+"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.getInstance(`CommandStream(${this.identifier})`);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CommandStream(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
-        const transport = new GrpcWebFetchTransport({
-            baseUrl: `${protocol}://${this.url}`,
-        });
-        this.client = new CommandClient(transport);
+        this.client = new rambo_v1_pb_service_1.CommandClient(`${protocol}://${this.url}`);
     }
     callStream(request, params) {
         const metadata = this.getMetadata(params.projectId, params.callsign);
-        const abortController = new AbortController();
-        return new Observable((emitter) => {
-            const call = this.client.callCommand(request, { meta: metadata, abort: abortController.signal });
-            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+        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.responses.onMessage((update) => {
-                const message = RocosCommandMessage.fromModel(update);
+            call.on('data', (update) => {
+                const message = RocosCommandMessage_1.RocosCommandMessage.fromModel(update);
                 emitter.next(message);
                 this.logger.debug('invokeRequest - on(data)', {
                     message,
@@ -31,28 +31,29 @@ export class CommandStream extends CommandStreamAbstract {
                     commandId: params.commandId,
                 });
             });
-            call.responses.onError((error) => {
-                this.logger.debug('invokeRequest - on(error)', {
-                    error,
+            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.error(error);
+                emitter.complete();
             });
-            call.responses.onComplete(() => {
-                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
-                this.statusStream$.next(this.subscriberStatus);
-                this.logger.debug('invokeRequest - on(end)', {
+            call.on('status', (status) => {
+                this.logger.debug('invokeRequest - on(status)', {
+                    status,
                     projectId: params.projectId,
                     callsign: params.callsign,
                     commandId: params.commandId,
                 });
-                emitter.complete();
+                // TODO: match fail status and emit an error
+                // emitter.error(error)
             });
             return () => {
                 this.logger.debug('unsubscribing commandStream');
-                abortController.abort();
+                call.cancel();
             };
         });
     }
@@ -64,3 +65,4 @@ export class CommandStream extends CommandStreamAbstract {
         };
     }
 }
+exports.CommandStream = CommandStream;

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

@@ -1,16 +1,20 @@
 import { BehaviorSubject, Observable } from 'rxjs';
-import { ICommandParams, ICommandStream, IRocosCommandMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
-import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+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 readonly scope;
+    private scope;
     protected url: string;
     protected subscriberStatus: SubscriberStatusEnum;
     protected logger: Logger;
-    protected constructor(config: IStreamConfig);
+    constructor(config: IStreamConfig);
     protected abstract callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
     setToken(token: string): void;
     stopStream(): void;