@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.19

package/api/streams/command/CommandStreamNode.js

@@ -0,0 +1,69 @@
+import * as grpc from '@grpc/grpc-js';
+import { RocosCommandMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandClient } from '../../../grpc/rambo.v1_pb.grpc-client';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class CommandStreamNode extends CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`CommandStreamNode(${this.identifier})`);
+        const port = config.port ?? 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new CommandClient(`${this.url}:${port}`, credentials);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new Observable((emitter) => {
+            call = this.client.callCommand(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = 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.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 = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = 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('authorization', this.token);
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        if (subsystem) {
+            meta.add('r-s', subsystem);
+        }
+        return meta;
+    }
+}

package/api/streams/control/ControlStream.d.ts

@@ -0,0 +1,12 @@
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { IControlParams, IRocosControlMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+export declare class ControlStream extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): Promise<void>;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/api/streams/control/ControlStream.js

@@ -0,0 +1,75 @@
+import { RocosControlMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RobotControlClient } from '../../../grpc/conker_pb.client';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { stringToUint8Array } from '../../../helpers/stringToUint8Array';
+export class ControlStream extends ControlStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`ControlStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}`,
+        });
+        this.client = new RobotControlClient(transport);
+    }
+    async controlRobotCall(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        await this.client.controlRobotCall(request, { meta: metadata });
+    }
+    controlRobotCallWithAckStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const abortController = new AbortController();
+        return new Observable((emitter) => {
+            // Send the message to back-end.
+            const call = this.client.controlRobotCallWithAckStream(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const message = RocosControlMessage.fromMessage(update);
+                emitter.next(message);
+                this.logger.debug('controlRobotCallWithAckStream - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.complete();
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('controlRobotCallWithAckStream- on(error)', {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing controlRobotCallWithAckStream');
+                abortController.abort();
+            };
+        });
+    }
+    getPayload(payload) {
+        return stringToUint8Array(payload);
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}

package/api/streams/control/ControlStreamAbstract.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ControlActionType, IControlParams, IControlStream, IRocosControlMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { Logger } from 'loglevel';
+export declare abstract class ControlStreamAbstract implements IControlStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected abstract controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected abstract getPayload(payload: string): Uint8Array | undefined;
+    setToken(token: string): void;
+    stopStream(): void;
+    takeActionWithAck(action: ControlActionType, params: IControlParams, ackTimeoutInSeconds?: number): Observable<string>;
+    private rosbridgeControl;
+    sendCommand(params: IControlParams): void;
+    sendCommandWithAck(params: IControlParams): Observable<IRocosControlMessage>;
+    private sendCommandToRobot;
+    private setRequestMeta;
+}

package/api/streams/control/ControlStreamAbstract.js

@@ -0,0 +1,111 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { SubscriberStatusEnum, } from '../../../models';
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { IDENTIFIER_NAME_CONTROL } from '../../../constants/identifier';
+import { RocosStore } from '../../../store/RocosStore';
+import { StreamRegister } from '../../StreamRegister';
+import { filter } from 'rxjs/operators';
+export class ControlStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_CONTROL, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
+        RocosStore.getChangeSubject()
+            .pipe(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
+    }
+    takeActionWithAck(action, params, ackTimeoutInSeconds = 15) {
+        return new Observable((emitter) => {
+            if (action && params) {
+                switch (action) {
+                    case 'rosbridge-control':
+                        this.rosbridgeControl(params, emitter, ackTimeoutInSeconds);
+                        break;
+                    default:
+                        emitter.error(new Error(`Cannot handle this type: ${action}.`));
+                        emitter.complete();
+                        break;
+                }
+            }
+            else {
+                emitter.error(new Error('Cannot find the type or metadata.'));
+                emitter.complete();
+            }
+        });
+    }
+    rosbridgeControl(params, emitter, ackTimeoutInSeconds) {
+        if (!params.projectId || !params.callsign) {
+            emitter.error(new Error('Cannot find the type or metadata.'));
+            emitter.complete();
+            return;
+        }
+        const timer = setTimeout(() => {
+            emitter.error(new Error(`Timeout (${ackTimeoutInSeconds} seconds).`));
+            emitter.complete();
+            clearTimeout(timer);
+        }, ackTimeoutInSeconds * 1000);
+        this.sendCommandWithAck(params).subscribe({
+            next: (msg) => {
+                const { message } = msg;
+                if (msg.stage === 'final') {
+                    if (msg.success) {
+                        emitter.next(`${message}`);
+                        emitter.complete();
+                    }
+                    else {
+                        emitter.error(new Error('Failed!'));
+                        emitter.complete();
+                    }
+                }
+                clearTimeout(timer);
+            },
+            error: (err) => {
+                emitter.error(err);
+                emitter.complete();
+            },
+        });
+    }
+    sendCommand(params) {
+        this.sendCommandToRobot(params);
+    }
+    sendCommandWithAck(params) {
+        const request = ControlMessage.create({
+            payload: this.getPayload(params.payload),
+            destination: params.destination,
+        });
+        this.setRequestMeta(request, params.meta);
+        return this.controlRobotCallWithAckStream(request, params);
+    }
+    sendCommandToRobot(params) {
+        // Compose the request message
+        const request = ControlMessage.create({
+            destination: params.destination,
+            payload: this.getPayload(params.payload),
+        });
+        this.setRequestMeta(request, params.meta);
+        // Send the message to back-end.
+        this.controlRobotCall(request, params);
+    }
+    setRequestMeta(request, meta) {
+        if (meta) {
+            Object.keys(meta).forEach((item) => {
+                if (meta?.[item] !== undefined) {
+                    request.meta[item] = meta[item];
+                }
+            });
+        }
+    }
+}

package/api/streams/control/ControlStreamNode.d.ts

@@ -0,0 +1,12 @@
+import { ControlMessage } from '../../../grpc/conker_pb';
+import { IControlParams, IRocosControlMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+export declare class ControlStreamNode extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/api/streams/control/ControlStreamNode.js

@@ -0,0 +1,73 @@
+import * as grpc from '@grpc/grpc-js';
+import { RocosControlMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+import { RobotControlClient } from '../../../grpc/conker_pb.grpc-client';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class ControlStreamNode extends ControlStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`ControlStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new RobotControlClient(`${this.url}:${port}`, credentials);
+    }
+    controlRobotCall(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        this.client.controlRobotCall(request, metadata);
+    }
+    controlRobotCallWithAckStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new Observable((emitter) => {
+            call = this.client.controlRobotCallWithAckStream(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosControlMessage.fromMessage(update);
+                emitter.next(message);
+                this.logger.debug('controlRobotCallWithAckStream - on(data)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(error)', error);
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing controlRobotCallWithAckStream');
+                call.cancel();
+            };
+        });
+    }
+    getPayload(payload) {
+        const buffer = Buffer.from(payload);
+        return Uint8Array.from(buffer);
+    }
+    getMetadata(projectId, callsign) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        return meta;
+    }
+}

package/api/streams/fileAccessor/FileAccessorStream.d.ts

@@ -0,0 +1,8 @@
+import { IFileAccessorReqOpParams, IRocosOpResultMessage, IStreamConfig } from '../../../models';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+export declare class FileAccessorStream extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}

package/api/streams/fileAccessor/FileAccessorStream.js

@@ -0,0 +1,59 @@
+import { OpRequestTarget, RocosOpResultMessage, SubscriberStatusEnum, } from '../../../models';
+import { FilagreeClient } from '../../../grpc/filagree_pb.client';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { OpRequests } from '../../../grpc/filagree_pb';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class FileAccessorStream extends FileAccessorStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`FileAccessorStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}`,
+        });
+        this.client = new FilagreeClient(transport);
+    }
+    async serverReqOpInternal(params) {
+        this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+        this.statusStream$.next(this.subscriberStatus);
+        this.logger.debug('serverReqOp - request', {
+            status: this.subscriberStatus,
+            projectId: params.projectId,
+            callsign: params.callsign,
+        });
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const reqs = OpRequests.create({
+            requests: [
+                {
+                    opcode: params.opCode.valueOf(),
+                    path: params.path,
+                    target: params.target?.valueOf() ?? OpRequestTarget.AGENT,
+                    args: params.args,
+                },
+            ],
+        });
+        const response = await this.client.serverReqOp(reqs, { meta: metadata }).response;
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.statusStream$.next(this.subscriberStatus);
+        this.logger.debug('serverReqOp - response', {
+            status: this.subscriberStatus,
+            projectId: params.projectId,
+            callsign: params.callsign,
+        });
+        if (response) {
+            return RocosOpResultMessage.fromMessages(response);
+        }
+        throw new Error('Error in serverReqOp call');
+    }
+    getMetadata(projectId, callsign) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        if (callsign) {
+            result['r-cs'] = callsign;
+        }
+        return result;
+    }
+}

package/api/streams/fileAccessor/FileAccessorStreamAbstract.d.ts

@@ -0,0 +1,21 @@
+import { IFileAccessorParams, IFileAccessorReqOpParams, IFileAccessorStream, IRocosOpResultMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { BehaviorSubject } from 'rxjs';
+import { Logger } from 'loglevel';
+export declare abstract class FileAccessorStreamAbstract implements IFileAccessorStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    setToken(token: string): void;
+    stopStream(): void;
+    serverReqOp(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    listFolder(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    downloadFile(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    getDownloadFileLinkByUsingBlob(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    private getPathForBlobSas;
+}

package/api/streams/fileAccessor/FileAccessorStreamAbstract.js

@@ -0,0 +1,62 @@
+import { OpCode, OpRequestTarget, SubscriberStatusEnum, } from '../../../models';
+import { BehaviorSubject } from 'rxjs';
+import { IDENTIFIER_NAME_FILE_ACCESSOR } from '../../../constants/identifier';
+import { RocosStore } from '../../../store/RocosStore';
+import { StreamRegister } from '../../StreamRegister';
+import { filter } from 'rxjs/operators';
+export class FileAccessorStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_FILE_ACCESSOR, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
+        RocosStore.getChangeSubject()
+            .pipe(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
+    }
+    async serverReqOp(params) {
+        return this.serverReqOpInternal(params);
+    }
+    async listFolder(params) {
+        return this.serverReqOp({ ...params, opCode: OpCode.INFO });
+    }
+    async downloadFile(params) {
+        return this.serverReqOp({ ...params, opCode: OpCode.READFILE });
+    }
+    async getDownloadFileLinkByUsingBlob(params) {
+        const pathForBlobSas = this.getPathForBlobSas(params.callsign, params.path);
+        const msgs = await this.serverReqOp({
+            ...params,
+            path: pathForBlobSas,
+            opCode: OpCode.READFILE,
+            target: OpRequestTarget.SERVER,
+        });
+        if (msgs && msgs.length > 0) {
+            const [{ data: url }] = msgs;
+            if (url) {
+                return this.serverReqOp({
+                    ...params,
+                    opCode: OpCode.BLOBPUT,
+                    target: OpRequestTarget.AGENT,
+                    args: { url },
+                });
+            }
+        }
+        throw new Error('Could not create SAS');
+    }
+    getPathForBlobSas(callsign, path) {
+        return `/${callsign}${path}`;
+    }
+}

package/api/streams/fileAccessor/FileAccessorStreamNode.d.ts

@@ -0,0 +1,8 @@
+import { IFileAccessorReqOpParams, IRocosOpResultMessage, IStreamConfig } from '../../../models';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+export declare class FileAccessorStreamNode extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}

package/api/streams/fileAccessor/FileAccessorStreamNode.js

@@ -0,0 +1,66 @@
+import * as grpc from '@grpc/grpc-js';
+import { OpRequestTarget, RocosOpResultMessage, SubscriberStatusEnum, } from '../../../models';
+import { FilagreeClient } from '../../../grpc/filagree_pb.grpc-client';
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+import { OpRequests } from '../../../grpc/filagree_pb';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class FileAccessorStreamNode extends FileAccessorStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`FileAccessorStreamNode(${this.identifier})`);
+        const port = config.port ?? 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new FilagreeClient(`${this.url}:${port}`, credentials);
+    }
+    serverReqOpInternal(params) {
+        return new Promise((resolve, reject) => {
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            this.logger.debug('serverReqOp - request', {
+                status: this.subscriberStatus,
+                projectId: params.projectId,
+                callsign: params.callsign,
+            });
+            const reqs = OpRequests.create({
+                requests: [
+                    {
+                        opcode: params.opCode.valueOf(),
+                        path: params.path,
+                        target: params.target?.valueOf() ?? OpRequestTarget.AGENT,
+                        args: params.args,
+                    },
+                ],
+            });
+            const metadata = this.getMetadata(params.projectId, params.callsign);
+            this.client.serverReqOp(reqs, metadata, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (data) {
+                    resolve(RocosOpResultMessage.fromMessages(data));
+                }
+                else {
+                    reject('Error in serverReqOp call');
+                }
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('serverReqOp - response', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                });
+            });
+        });
+    }
+    getMetadata(projectId, callsign) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        if (projectId) {
+            meta.add('r-p', projectId);
+        }
+        if (callsign) {
+            meta.add('r-cs', callsign);
+        }
+        return meta;
+    }
+}

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

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