@theia/plugin-ext 1.33.0-next.5 → 1.33.0-next.8

package/src/common/rpc-protocol.ts

@@ -22,14 +22,17 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { Channel, Disposable, DisposableCollection, ReadBuffer, WriteBuffer } from '@theia/core';
 import { Emitter, Event } from '@theia/core/lib/common/event';
-import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
-import { Deferred } from '@theia/core/lib/common/promise-util';
+import { ChannelMultiplexer, MessageProvider } from '@theia/core/lib/common/message-rpc/channel';
+import { MsgPackMessageDecoder, MsgPackMessageEncoder } from '@theia/core/lib/common/message-rpc/rpc-message-encoder';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
+import { ClientProxyHandler, RpcInvocationHandler } from './proxy-handler';
+import { MsgPackExtensionManager } from '@theia/core/lib/common/message-rpc/msg-pack-extension-manager';
 import { URI as VSCodeURI } from '@theia/core/shared/vscode-uri';
 import URI from '@theia/core/lib/common/uri';
-import { CancellationToken, CancellationTokenSource } from '@theia/core/shared/vscode-languageserver-protocol';
-import { Range, Position } from '../plugin/types-impl';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { Range, Position } from '../plugin/types-impl';
 
 export interface MessageConnection {
     send(msg: string): void;
@@ -76,49 +79,29 @@ export namespace ConnectionClosedError {
 }
 
 export class RPCProtocolImpl implements RPCProtocol {
-
-    private readonly locals = new Map<string, any>();
+    private readonly locals = new Map<string, RpcInvocationHandler>();
     private readonly proxies = new Map<string, any>();
-    private lastMessageId = 0;
-    private readonly cancellationTokenSources = new Map<string, CancellationTokenSource>();
-    private readonly pendingRPCReplies = new Map<string, Deferred<any>>();
-    private readonly multiplexer: RPCMultiplexer;
-
-    private replacer: (key: string | undefined, value: any) => any;
-    private reviver: (key: string | undefined, value: any) => any;
+    private readonly multiplexer: ChannelMultiplexer;
+    private readonly encoder = new MsgPackMessageEncoder();
+    private readonly decoder = new MsgPackMessageDecoder();
 
     private readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as no disposed */ })
     );
 
-    constructor(connection: MessageConnection, transformations?: {
-        replacer?: (key: string | undefined, value: any) => any,
-        reviver?: (key: string | undefined, value: any) => any
-    }) {
-        this.toDispose.push(
-            this.multiplexer = new RPCMultiplexer(connection)
-        );
-        this.multiplexer.onMessage(msg => this.receiveOneMessage(msg));
-        this.toDispose.push(Disposable.create(() => {
-            this.proxies.clear();
-            for (const reply of this.pendingRPCReplies.values()) {
-                reply.reject(ConnectionClosedError.create());
-            }
-            this.pendingRPCReplies.clear();
-        }));
-
-        this.reviver = transformations?.reviver || ObjectsTransferrer.reviver;
-        this.replacer = transformations?.replacer || ObjectsTransferrer.replacer;
-    }
-
-    private get isDisposed(): boolean {
-        return this.toDispose.disposed;
+    constructor(channel: Channel) {
+        this.toDispose.push(this.multiplexer = new ChannelMultiplexer(new BatchingChannel(channel)));
+        this.toDispose.push(Disposable.create(() => this.proxies.clear()));
     }
 
     dispose(): void {
         this.toDispose.dispose();
     }
 
+    protected get isDisposed(): boolean {
+        return this.toDispose.disposed;
+    }
+
     getProxy<T>(proxyId: ProxyIdentifier<T>): T {
         if (this.isDisposed) {
             throw ConnectionClosedError.create();
@@ -131,274 +114,125 @@ export class RPCProtocolImpl implements RPCProtocol {
         return proxy;
     }
 
-    set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R {
-        if (this.isDisposed) {
-            throw ConnectionClosedError.create();
-        }
-        this.locals.set(identifier.id, instance);
-        if (Disposable.is(instance)) {
-            this.toDispose.push(instance);
-        }
-        this.toDispose.push(Disposable.create(() => this.locals.delete(identifier.id)));
-        return instance;
-    }
-
-    private createProxy<T>(proxyId: string): T {
-        const handler = {
-            get: (target: any, name: string) => {
-                if (!target[name] && name.charCodeAt(0) === 36 /* CharCode.DollarSign */) {
-                    target[name] = (...myArgs: any[]) =>
-                        this.remoteCall(proxyId, name, myArgs);
-                }
-                return target[name];
-            }
-        };
+    protected createProxy<T>(proxyId: string): T {
+        const handler = new ClientProxyHandler({ id: proxyId, encoder: this.encoder, decoder: this.decoder, channelProvider: () => this.multiplexer.open(proxyId) });
         return new Proxy(Object.create(null), handler);
     }
 
-    private remoteCall(proxyId: string, methodName: string, args: any[]): Promise<any> {
+    set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R {
         if (this.isDisposed) {
-            return Promise.reject(ConnectionClosedError.create());
-        }
-        const cancellationToken: CancellationToken | undefined = args.length && CancellationToken.is(args[args.length - 1]) ? args.pop() : undefined;
-        if (cancellationToken && cancellationToken.isCancellationRequested) {
-            return Promise.reject(canceled());
-        }
-
-        const callId = String(++this.lastMessageId);
-        const result = new Deferred();
-
-        if (cancellationToken) {
-            args.push('add.cancellation.token');
-            cancellationToken.onCancellationRequested(() =>
-                this.multiplexer.send(this.cancel(callId))
-            );
+            throw ConnectionClosedError.create();
         }
+        const invocationHandler = this.locals.get(identifier.id);
+        if (!invocationHandler) {
+            const handler = new RpcInvocationHandler({ id: identifier.id, target: instance, encoder: this.encoder, decoder: this.decoder });
 
-        this.pendingRPCReplies.set(callId, result);
-        this.multiplexer.send(this.request(callId, proxyId, methodName, args));
-        return result.promise;
-    }
-
-    private receiveOneMessage(rawmsg: string): void {
-        if (this.isDisposed) {
-            return;
-        }
-        try {
-            const msg = <RPCMessage>JSON.parse(rawmsg, this.reviver);
-
-            switch (msg.type) {
-                case MessageType.Request:
-                    this.receiveRequest(msg);
-                    break;
-                case MessageType.Reply:
-                    this.receiveReply(msg);
-                    break;
-                case MessageType.ReplyErr:
-                    this.receiveReplyErr(msg);
-                    break;
-                case MessageType.Cancel:
-                    this.receiveCancel(msg);
-                    break;
+            const channel = this.multiplexer.getOpenChannel(identifier.id);
+            if (channel) {
+                handler.listen(channel);
+            } else {
+                const channelOpenListener = this.multiplexer.onDidOpenChannel(event => {
+                    if (event.id === identifier.id) {
+                        handler.listen(event.channel);
+                        channelOpenListener.dispose();
+                    }
+                });
             }
-        } catch (e) {
-            // exception does not show problematic content: log it!
-            console.log('failed to parse message: ' + rawmsg);
-            throw e;
-        }
-
-    }
-
-    private receiveCancel(msg: CancelMessage): void {
-        const cancellationTokenSource = this.cancellationTokenSources.get(msg.id);
-        if (cancellationTokenSource) {
-            cancellationTokenSource.cancel();
-        }
-    }
-
-    private receiveRequest(msg: RequestMessage): void {
-        const callId = msg.id;
-        const proxyId = msg.proxyId;
-        // convert `null` to `undefined`, since we don't use `null` in internal plugin APIs
-        const args = msg.args.map(arg => arg === null ? undefined : arg); // eslint-disable-line no-null/no-null
-
-        const addToken = args.length && args[args.length - 1] === 'add.cancellation.token' ? args.pop() : false;
-        if (addToken) {
-            const tokenSource = new CancellationTokenSource();
-            this.cancellationTokenSources.set(callId, tokenSource);
-            args.push(tokenSource.token);
-        }
-        const invocation = this.invokeHandler(proxyId, msg.method, args);
-
-        invocation.then(result => {
-            this.cancellationTokenSources.delete(callId);
-            this.multiplexer.send(this.replyOK(callId, result));
-        }, error => {
-            this.cancellationTokenSources.delete(callId);
-            this.multiplexer.send(this.replyErr(callId, error));
-        });
-    }
-
-    private receiveReply(msg: ReplyMessage): void {
-        const callId = msg.id;
-        const pendingReply = this.pendingRPCReplies.get(callId);
-        if (!pendingReply) {
-            return;
-        }
-        this.pendingRPCReplies.delete(callId);
-        pendingReply.resolve(msg.res);
-    }
-
-    private receiveReplyErr(msg: ReplyErrMessage): void {
-        const callId = msg.id;
-        const pendingReply = this.pendingRPCReplies.get(callId);
-        if (!pendingReply) {
-            return;
-        }
-        this.pendingRPCReplies.delete(callId);
-
-        let err: Error | undefined = undefined;
-        if (msg.err && msg.err.$isError) {
-            err = new Error();
-            err.name = msg.err.name;
-            err.message = msg.err.message;
-            err.stack = msg.err.stack;
-        }
-        pendingReply.reject(err);
-    }
-
-    private invokeHandler(proxyId: string, methodName: string, args: any[]): Promise<any> {
-        try {
-            return Promise.resolve(this.doInvokeHandler(proxyId, methodName, args));
-        } catch (err) {
-            return Promise.reject(err);
-        }
-    }
-
-    private doInvokeHandler(proxyId: string, methodName: string, args: any[]): any {
-        const actor = this.locals.get(proxyId);
-        if (!actor) {
-            throw new Error('Unknown actor ' + proxyId);
-        }
-        const method = actor[methodName];
-        if (typeof method !== 'function') {
-            throw new Error('Unknown method ' + methodName + ' on actor ' + proxyId);
-        }
-        return method.apply(actor, args);
-    }
 
-    private cancel(req: string): string {
-        return `{"type":${MessageType.Cancel},"id":"${req}"}`;
-    }
-
-    private request(req: string, rpcId: string, method: string, args: any[]): string {
-        return `{"type":${MessageType.Request},"id":"${req}","proxyId":"${rpcId}","method":"${method}","args":${JSON.stringify(args, this.replacer)}}`;
-    }
-
-    private replyOK(req: string, res: any): string {
-        if (typeof res === 'undefined') {
-            return `{"type":${MessageType.Reply},"id":"${req}"}`;
-        }
-        return `{"type":${MessageType.Reply},"id":"${req}","res":${safeStringify(res, this.replacer)}}`;
-    }
+            this.locals.set(identifier.id, handler);
+            if (Disposable.is(instance)) {
+                this.toDispose.push(instance);
+            }
+            this.toDispose.push(Disposable.create(() => this.locals.delete(identifier.id)));
 
-    private replyErr(req: string, err: any): string {
-        err = typeof err === 'string' ? new Error(err) : err;
-        if (err instanceof Error) {
-            return `{"type":${MessageType.ReplyErr},"id":"${req}","err":${safeStringify(transformErrorForSerialization(err))}}`;
         }
-        return `{"type":${MessageType.ReplyErr},"id":"${req}","err":null}`;
+        return instance;
     }
 }
 
-function canceled(): Error {
-    const error = new Error('Canceled');
-    error.name = error.message;
-    return error;
-}
-
 /**
- * Sends/Receives multiple messages in one go:
+ * Wraps and underlying channel to send/receive multiple messages in one go:
  *  - multiple messages to be sent from one stack get sent in bulk at `process.nextTick`.
  *  - each incoming message is handled in a separate `process.nextTick`.
  */
-class RPCMultiplexer implements Disposable, MessageConnection {
-
-    private readonly connection: MessageConnection;
-    private readonly sendAccumulatedBound: () => void;
-
-    private messagesToSend: string[];
+export class BatchingChannel implements Channel {
+    protected messagesToSend: Uint8Array[] = [];
 
-    private readonly messageEmitter = new Emitter<string>();
-    private readonly toDispose = new DisposableCollection();
+    constructor(protected underlyingChannel: Channel) {
+        underlyingChannel.onMessage(msg => this.handleMessages(msg()));
+    }
 
-    constructor(connection: MessageConnection) {
-        this.connection = connection;
-        this.sendAccumulatedBound = this.sendAccumulated.bind(this);
+    protected onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
+    };
 
-        this.toDispose.push(Disposable.create(() => this.messagesToSend = []));
-        this.toDispose.push(this.connection.onMessage((msg: string) => {
-            const messages = JSON.parse(msg);
-            for (const message of messages) {
-                this.messageEmitter.fire(message);
-            }
-        }));
-        this.toDispose.push(this.messageEmitter);
+    readonly onClose = this.underlyingChannel.onClose;
+    readonly onError = this.underlyingChannel.onError;
 
+    close(): void {
+        this.underlyingChannel.close();
+        this.onMessageEmitter.dispose();
         this.messagesToSend = [];
     }
 
-    dispose(): void {
-        this.toDispose.dispose();
-    }
-
-    get onMessage(): Event<string> {
-        return this.messageEmitter.event;
+    getWriteBuffer(): WriteBuffer {
+        const writer = new Uint8ArrayWriteBuffer();
+        writer.onCommit(buffer => this.commitSingleMessage(buffer));
+        return writer;
     }
 
-    private sendAccumulated(): void {
-        const tmp = this.messagesToSend;
-        this.messagesToSend = [];
-        this.connection.send(JSON.stringify(tmp));
-    }
+    protected commitSingleMessage(msg: Uint8Array): void {
 
-    public send(msg: string): void {
-        if (this.toDispose.disposed) {
-            throw ConnectionClosedError.create();
-        }
         if (this.messagesToSend.length === 0) {
             if (typeof setImmediate !== 'undefined') {
-                setImmediate(this.sendAccumulatedBound);
+                setImmediate(() => this.sendAccumulated());
             } else {
-                setTimeout(this.sendAccumulatedBound, 0);
+                setTimeout(() => this.sendAccumulated(), 0);
             }
         }
         this.messagesToSend.push(msg);
     }
+
+    protected sendAccumulated(): void {
+        const cachedMessages = this.messagesToSend;
+        this.messagesToSend = [];
+        const writer = this.underlyingChannel.getWriteBuffer();
+
+        if (cachedMessages.length > 0) {
+            writer.writeLength(cachedMessages.length);
+            cachedMessages.forEach(msg => {
+                writer.writeBytes(msg);
+            });
+
+        }
+        writer.commit();
+    }
+
+    protected handleMessages(buffer: ReadBuffer): void {
+        // Read in the list of messages and dispatch each message individually
+        const length = buffer.readLength();
+        if (length > 0) {
+            for (let index = 0; index < length; index++) {
+                const message = buffer.readBytes();
+                this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(message));
+            }
+        }
+    }
 }
 
-/**
- * These functions are responsible for correct transferring objects via rpc channel.
- *
- * To reach that some specific kind of objects is converted to json in some custom way
- * and then, after receiving, revived to objects again,
- * so there is feeling that object was transferred via rpc channel.
- *
- * To distinguish between regular and altered objects, field $type is added to altered ones.
- * Also value of that field specifies kind of the object.
- */
-export namespace ObjectsTransferrer {
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    export function replacer(key: string | undefined, value: any): any {
-        if (value instanceof URI) {
-            return {
-                $type: SerializedObjectType.THEIA_URI,
-                data: value.toString()
-            } as SerializedObject;
-        } else if (value instanceof Range) {
-            const range = value as Range;
-            const serializedValue = {
+export function registerMsgPackExtensions(): void {
+    MsgPackExtensionManager.getInstance().registerExtensions(
+        {
+            class: URI,
+            tag: 2,
+            serialize: (instance: URI) => instance.toString(),
+            deserialize: data => new URI(data)
+        },
+        {
+            class: Range,
+            tag: 3,
+            serialize: (range: Range) => ({
                 start: {
                     line: range.start.line,
                     character: range.start.character
@@ -407,140 +241,33 @@ export namespace ObjectsTransferrer {
                     line: range.end.line,
                     character: range.end.character
                 }
-            };
-            return {
-                $type: SerializedObjectType.THEIA_RANGE,
-                data: JSON.stringify(serializedValue)
-            } as SerializedObject;
-        } else if (value && value['$mid'] === 1) {
-            // Given value is VSCode URI
-            // We cannot use instanceof here because VSCode URI has toJSON method which is invoked before this replacer.
-            const uri = VSCodeURI.revive(value);
-            return {
-                $type: SerializedObjectType.VSCODE_URI,
-                data: uri.toString()
-            } as SerializedObject;
-        } else if (value instanceof BinaryBuffer) {
-            const bytes = [...value.buffer.values()];
-            return {
-                $type: SerializedObjectType.TEXT_BUFFER,
-                data: JSON.stringify({ bytes })
-            };
-        }
-
-        return value;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    export function reviver(key: string | undefined, value: any): any {
-        if (isSerializedObject(value)) {
-            switch (value.$type) {
-                case SerializedObjectType.THEIA_URI:
-                    return new URI(value.data);
-                case SerializedObjectType.VSCODE_URI:
-                    return VSCodeURI.parse(value.data);
-                case SerializedObjectType.THEIA_RANGE:
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const obj: any = JSON.parse(value.data);
-                    const start = new Position(obj.start.line, obj.start.character);
-                    const end = new Position(obj.end.line, obj.end.character);
-                    return new Range(start, end);
-                case SerializedObjectType.TEXT_BUFFER:
-                    const data: { bytes: number[] } = JSON.parse(value.data);
-                    return BinaryBuffer.wrap(Uint8Array.from(data.bytes));
+            }),
+            deserialize: data => {
+                const start = new Position(data.start.line, data.start.character);
+                const end = new Position(data.end.line, data.end.character);
+                return new Range(start, end);
+            }
+        },
+        {
+            class: VSCodeURI,
+            tag: 4,
+            // eslint-disable-next-line arrow-body-style
+            serialize: (instance: URI) => {
+                return instance.toString();
+            },
+            deserialize: data => VSCodeURI.parse(data)
+        },
+        {
+            class: BinaryBuffer,
+            tag: 5,
+            // eslint-disable-next-line arrow-body-style
+            serialize: (instance: BinaryBuffer) => {
+                return instance.buffer;
+            },
+            // eslint-disable-next-line arrow-body-style
+            deserialize: buffer => {
+                return BinaryBuffer.wrap(buffer);
             }
         }
-
-        return value;
-    }
-
-}
-
-interface SerializedObject {
-    $type: SerializedObjectType;
-    data: string;
-}
-
-enum SerializedObjectType {
-    THEIA_URI,
-    VSCODE_URI,
-    THEIA_RANGE,
-    TEXT_BUFFER
-}
-
-function isSerializedObject(obj: unknown): obj is SerializedObject {
-    const serializedObject = obj as SerializedObject;
-    return !!obj && typeof obj === 'object' && serializedObject.$type !== undefined && serializedObject.data !== undefined;
-}
-
-export const enum MessageType {
-    Request = 1,
-    Reply = 2,
-    ReplyErr = 3,
-    Cancel = 4,
-    Terminate = 5,
-    Terminated = 6
-}
-
-class CancelMessage {
-    type: MessageType.Cancel;
-    id: string;
-}
-
-class RequestMessage {
-    type: MessageType.Request;
-    id: string;
-    proxyId: string;
-    method: string;
-    args: any[];
-}
-
-class ReplyMessage {
-    type: MessageType.Reply;
-    id: string;
-    res: any;
-}
-
-class ReplyErrMessage {
-    type: MessageType.ReplyErr;
-    id: string;
-    err: SerializedError;
-}
-
-type RPCMessage = RequestMessage | ReplyMessage | ReplyErrMessage | CancelMessage;
-
-export interface SerializedError {
-    readonly $isError: true;
-    readonly name: string;
-    readonly message: string;
-    readonly stack: string;
-}
-
-export function transformErrorForSerialization(error: Error): SerializedError {
-    if (error instanceof Error) {
-        const { name, message } = error;
-        const stack: string = (<any>error).stacktrace || error.stack;
-        return {
-            $isError: true,
-            name,
-            message,
-            stack
-        };
-    }
-
-    // return as is
-    return error;
-}
-
-interface JSONStringifyReplacer {
-    (key: string, value: any): any;
-}
-
-function safeStringify(obj: any, replacer?: JSONStringifyReplacer): string {
-    try {
-        return JSON.stringify(obj, replacer);
-    } catch (err) {
-        console.error('error stringifying response: ', err);
-        return 'null';
-    }
+    );
 }

package/src/hosted/browser/hosted-plugin-watcher.ts

@@ -21,7 +21,8 @@ import { LogPart } from '../../common/types';
 
 @injectable()
 export class HostedPluginWatcher {
-    private onPostMessage = new Emitter<{ pluginHostId: string, message: string }>();
+    private onPostMessage = new Emitter<{ pluginHostId: string, message: Uint8Array }>();
+
     private onLogMessage = new Emitter<LogPart>();
 
     private readonly onDidDeployEmitter = new Emitter<void>();
@@ -31,7 +32,7 @@ export class HostedPluginWatcher {
         const messageEmitter = this.onPostMessage;
         const logEmitter = this.onLogMessage;
         return {
-            postMessage(pluginHostId, message: string): Promise<void> {
+            postMessage(pluginHostId, message: Uint8Array): Promise<void> {
                 messageEmitter.fire({ pluginHostId, message });
                 return Promise.resolve();
             },
@@ -43,7 +44,7 @@ export class HostedPluginWatcher {
         };
     }
 
-    get onPostMessageEvent(): Event<{ pluginHostId: string, message: string }> {
+    get onPostMessageEvent(): Event<{ pluginHostId: string, message: Uint8Array }> {
         return this.onPostMessage.event;
     }
 

package/src/hosted/browser/hosted-plugin.ts

@@ -66,6 +66,8 @@ import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/stan
 import { ILanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/language';
 import { LanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageService';
 import { Measurement, Stopwatch } from '@theia/core/lib/common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
+import { BasicChannel } from '@theia/core/lib/common/message-rpc/channel';
 
 export type PluginHost = 'frontend' | string;
 export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
@@ -534,18 +536,25 @@ export class HostedPluginSupport {
     }
 
     protected createServerRpc(pluginHostId: string): RPCProtocol {
-        const emitter = new Emitter<string>();
+
+        const channel = new BasicChannel(() => {
+            const writer = new Uint8ArrayWriteBuffer();
+            writer.onCommit(buffer => {
+                this.server.onMessage(pluginHostId, buffer);
+            });
+            return writer;
+        });
+
+        // Create RPC protocol before adding the listener to the watcher to receive the watcher's cached messages after the rpc protocol was created.
+        const rpc = new RPCProtocolImpl(channel);
+
         this.watcher.onPostMessageEvent(received => {
             if (pluginHostId === received.pluginHostId) {
-                emitter.fire(received.message);
-            }
-        });
-        return new RPCProtocolImpl({
-            onMessage: emitter.event,
-            send: message => {
-                this.server.onMessage(pluginHostId, message);
+                channel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(received.message));
             }
         });
+
+        return rpc;
     }
 
     protected async updateStoragePath(): Promise<void> {