RPC Protocol ClientProxyHandler Init Events #13172

* add an event to listen for init events on rpc proxy handler
* eager initialize DOCUMENTS_EXT Proxy when EDITORS_AND_DOCUMENTS_EXT
was initialized

packages/plugin-ext/src/common/proxy-handler.ts

@@ -25,6 +25,7 @@ export interface RpcHandlerOptions {
 }
 export interface ProxyHandlerOptions extends RpcHandlerOptions {
     channelProvider: () => Promise<Channel>,
+    onInitialize?: () => void,
 }
 
 export interface InvocationHandlerOptions extends RpcHandlerOptions {
@@ -40,26 +41,30 @@ export class ClientProxyHandler<T extends object> implements ProxyHandler<T> {
 
     readonly id: string;
     private readonly channelProvider: () => Promise<Channel>;
+    private readonly onInitialize?: () => void;
     private readonly encoder: RpcMessageEncoder;
     private readonly decoder: RpcMessageDecoder;
 
     constructor(options: ProxyHandlerOptions) {
         Object.assign(this, options);
     }
 
-    private initializeRpc(): void {
-        const clientOptions: RpcProtocolOptions = { encoder: this.encoder, decoder: this.decoder, mode: 'clientOnly' };
-        this.channelProvider().then(channel => {
-            const rpc = new RpcProtocol(channel, undefined, clientOptions);
-            this.rpcDeferred.resolve(rpc);
-            this.isRpcInitialized = true;
-        });
+    initializeRpc(): void {
+        if (!this.isRpcInitialized) {
+            const clientOptions: RpcProtocolOptions = { encoder: this.encoder, decoder: this.decoder, mode: 'clientOnly' };
+            this.channelProvider().then(channel => {
+                const rpc = new RpcProtocol(channel, undefined, clientOptions);
+                this.rpcDeferred.resolve(rpc);
+                this.isRpcInitialized = true;
+                if (this.onInitialize) {
+                    this.onInitialize();
+                }
+            });
+        }
     }
 
     get(target: any, name: string, receiver: any): any {
-        if (!this.isRpcInitialized) {
-            this.initializeRpc();
-        }
+        this.initializeRpc();
 
         if (target[name] || name.charCodeAt(0) !== 36 /* CharCode.DollarSign */) {
             return target[name];

packages/plugin-ext/src/common/rpc-protocol.ts

@@ -50,6 +50,16 @@ export interface RPCProtocol extends Disposable {
      */
     set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R;
 
+    /**
+     * Sent when a proxy handler is initialized.
+     */
+    onInitialize: Event<string>;
+
+    /**
+     * Makes sure that the proxy is eagerly initialized.
+     */
+    initialize<T>(proxyId: ProxyIdentifier<T>): void;
+
 }
 
 export class ProxyIdentifier<T> {
@@ -80,9 +90,11 @@ export namespace ConnectionClosedError {
 export class RPCProtocolImpl implements RPCProtocol {
     private readonly locals = new Map<string, RpcInvocationHandler>();
     private readonly proxies = new Map<string, any>();
+    private readonly handler = new Map<string, any>();
     private readonly multiplexer: ChannelMultiplexer;
     private readonly encoder = new MsgPackMessageEncoder();
     private readonly decoder = new MsgPackMessageDecoder();
+    private readonly onInitializeEmitter: Emitter<string> = new Emitter();
 
     private readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as no disposed */ })
@@ -91,6 +103,8 @@ export class RPCProtocolImpl implements RPCProtocol {
     constructor(channel: Channel) {
         this.toDispose.push(this.multiplexer = new ChannelMultiplexer(new BatchingChannel(channel)));
         this.toDispose.push(Disposable.create(() => this.proxies.clear()));
+        this.toDispose.push(Disposable.create(() => this.handler.clear()));
+        this.toDispose.push(this.onInitializeEmitter);
     }
 
     dispose(): void {
@@ -114,7 +128,12 @@ export class RPCProtocolImpl implements RPCProtocol {
     }
 
     protected createProxy<T>(proxyId: string): T {
-        const handler = new ClientProxyHandler({ id: proxyId, encoder: this.encoder, decoder: this.decoder, channelProvider: () => this.multiplexer.open(proxyId) });
+        const handler = new ClientProxyHandler({
+            id: proxyId, encoder: this.encoder, decoder: this.decoder,
+            channelProvider: () => this.multiplexer.open(proxyId),
+            onInitialize: () => this.onInitializeEmitter.fire(proxyId),
+        });
+        this.handler.set(proxyId, handler);
         return new Proxy(Object.create(null), handler);
     }
 
@@ -147,6 +166,18 @@ export class RPCProtocolImpl implements RPCProtocol {
         }
         return instance;
     }
+
+    get onInitialize(): Event<string> {
+        return this.onInitializeEmitter.event;
+    };
+
+    initialize<T>(proxyId: ProxyIdentifier<T>): void {
+        /* make sure proxy exists */
+        this.getProxy(proxyId);
+        /* init */
+        const handler = this.handler.get(proxyId.id);
+        handler.initializeRpc();
+    }
 }
 
 /**

packages/plugin-ext/src/main/browser/documents-main.ts

@@ -98,6 +98,11 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         private untitledResourceResolver: UntitledResourceResolver,
         private languageService: MonacoLanguages,
     ) {
+        rpc.onInitialize(proxyId => {
+            if (proxyId === MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT.id) {
+                rpc.initialize(MAIN_RPC_CONTEXT.DOCUMENTS_EXT);
+            }
+        });
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.DOCUMENTS_EXT);
 
         this.toDispose.push(editorsAndDocuments);

packages/plugin-ext/src/plugin/node/debug/debug.spec.ts

@@ -18,13 +18,16 @@ import * as chai from 'chai';
 import { ProxyIdentifier, RPCProtocol } from '../../../common/rpc-protocol';
 
 import { DebugExtImpl } from '../../debug/debug-ext';
+import { Emitter, Event } from '@theia/core';
 
 const expect = chai.expect;
 
 describe('Debug API', () => {
 
     describe('#asDebugSourceURI', () => {
 
+        const mockEmitter = new Emitter<string>();
+
         const mockRPCProtocol: RPCProtocol = {
             getProxy<T>(_proxyId: ProxyIdentifier<T>): T {
                 return {} as T;
@@ -34,6 +37,12 @@ describe('Debug API', () => {
             },
             dispose(): void {
                 // Nothing
+            },
+            get onInitialize(): Event<string> {
+                return mockEmitter.event;
+            },
+            initialize<T>(_proxyId: ProxyIdentifier<T>): void {
+                // Nothing
             }
         };