@opensumi/ide-connection 2.27.3-next-1706686746.0 → 2.27.3-rc-1706687185.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opensumi/ide-connection",
-  "version": "2.27.3-next-1706686746.0",
+  "version": "2.27.3-rc-1706687185.0",
   "files": [
     "lib",
     "src"
@@ -19,16 +19,16 @@
   "dependencies": {
     "@furyjs/fury": "0.5.6-beta",
     "@opensumi/events": "^0.1.0",
-    "@opensumi/ide-core-common": "2.27.3-next-1706686746.0",
+    "@opensumi/ide-core-common": "2.27.3-rc-1706687185.0",
     "@opensumi/vscode-jsonrpc": "^8.0.0-next.2",
     "path-match": "^1.2.4",
     "reconnecting-websocket": "^4.4.0",
     "ws": "^8.15.1"
   },
   "devDependencies": {
-    "@opensumi/ide-components": "2.27.3-next-1706686746.0",
+    "@opensumi/ide-components": "2.27.3-rc-1706687185.0",
     "@opensumi/ide-dev-tool": "1.3.1",
     "@opensumi/mock-socket": "^9.3.1"
   },
-  "gitHead": "2a072e19dab9fea8c3925eba3d0a7386415ae485"
+  "gitHead": "922ed9010fe3658f626401b559c5d1cae6afa760"
 }

package/src/browser/ws-channel-handler.ts

@@ -72,6 +72,10 @@ export class WSChannelHandler {
 
       const channel = this.channelMap.get(msg.id);
       if (channel) {
+        if (!channel.hasMessageListener()) {
+          // 要求前端发送初始化消息，但后端最先发送消息时，前端并未准备好
+          this.logger.error(this.LOG_TAG, 'channel not ready!', msg);
+        }
         channel.handleMessage(msg);
       } else {
         this.logger.warn(this.LOG_TAG, `channel ${msg.id} not found`);

package/src/common/connection/drivers/base.ts

@@ -2,8 +2,14 @@ import { IDisposable } from '@opensumi/ide-core-common';
 
 import { IConnectionShape } from '../types';
 
+import { createQueue } from './utils';
+
 export abstract class BaseConnection<T> implements IConnectionShape<T> {
   abstract send(data: T): void;
   abstract onMessage(cb: (data: T) => void): IDisposable;
   abstract onceClose(cb: () => void): IDisposable;
+
+  createQueue(): IConnectionShape<T> {
+    return createQueue(this);
+  }
 }

package/src/common/ext-rpc-protocol.ts

@@ -25,8 +25,6 @@ export interface IProxyIdentifier {
   countId: number;
 }
 
-const CancellationTokenStr = 'add.cancellation.token';
-
 export class ProxyIdentifier<T = any> {
   public static count = 0;
 
@@ -263,7 +261,7 @@ export class RPCProtocol implements IRPCProtocol {
     const result = new Deferred();
 
     if (cancellationToken) {
-      args.push(CancellationTokenStr);
+      args.push('add.cancellation.token');
       cancellationToken.onCancellationRequested(() => this._protocol.send(MessageIO.cancel(callId)));
     }
     this._pendingRPCReplies.set(callId, result);
@@ -344,7 +342,7 @@ export class RPCProtocol implements IRPCProtocol {
     const method = msg.method;
     const args = msg.args.map((arg) => (arg === null ? undefined : arg));
 
-    const addToken = args.length && args[args.length - 1] === CancellationTokenStr ? args.pop() : false;
+    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);

package/src/common/proxy/base.ts

@@ -1,36 +1,28 @@
 import { Deferred, isDefined } from '@opensumi/ide-core-common';
 
 import { ILogger, IRPCServiceMap } from '../types';
-import { ICapturedMessage, MessageType, ResponseStatus, getCapturer } from '../utils';
-
-import type { ServiceRunner } from './runner';
+import { ICapturedMessage, getCapturer, getServiceMethods } from '../utils';
 
 interface IBaseConnection {
   listen(): void;
 }
 
-let requestId = 0;
-
 export abstract class ProxyBase<T extends IBaseConnection> {
+  protected proxyService: any = {};
+
   protected logger: ILogger;
   protected connection: T;
 
   protected connectionPromise: Deferred<void> = new Deferred<void>();
 
-  protected abstract engine: 'legacy' | 'sumi';
+  protected abstract engine: 'legacy';
 
-  constructor(public runner: ServiceRunner, logger?: ILogger) {
+  constructor(public target?: IRPCServiceMap, logger?: ILogger) {
     this.logger = logger || console;
-
-    this.runner.onServicesUpdate((services) => {
-      if (this.connection) {
-        this.bindMethods(services);
-      }
-    });
   }
 
   // capture messages for opensumi devtools
-  private capture(message: ICapturedMessage): void {
+  protected capture(message: ICapturedMessage): void {
     const capturer = getCapturer();
     if (isDefined(capturer)) {
       capturer({
@@ -40,80 +32,36 @@ export abstract class ProxyBase<T extends IBaseConnection> {
     }
   }
 
-  protected nextRequestId() {
-    return String(requestId++);
-  }
-
-  protected captureOnRequest(requestId: string, serviceMethod: string, args: any[]): void {
-    this.capture({ type: MessageType.OnRequest, requestId, serviceMethod, arguments: args });
-  }
-
-  protected captureOnRequestResult(requestId: string, serviceMethod: string, data: any): void {
-    this.capture({
-      type: MessageType.OnRequestResult,
-      status: ResponseStatus.Success,
-      requestId,
-      serviceMethod,
-      data,
-    });
-  }
-
-  protected captureOnRequestFail(requestId: string, serviceMethod: string, error: any): void {
-    this.logger.warn(`request exec ${serviceMethod} error`, error);
-
-    this.capture({
-      type: MessageType.OnRequestResult,
-      status: ResponseStatus.Fail,
-      requestId,
-      serviceMethod,
-      error,
-    });
-  }
-
-  protected captureOnNotification(serviceMethod: string, args: any[]): void {
-    this.capture({ type: MessageType.OnNotification, serviceMethod, arguments: args });
-  }
-
-  protected captureSendRequest(requestId: string, serviceMethod: string, args: any[]): void {
-    this.capture({ type: MessageType.SendRequest, requestId, serviceMethod, arguments: args });
-  }
-
-  protected captureSendRequestResult(requestId: string, serviceMethod: string, data: any): void {
-    this.capture({
-      type: MessageType.RequestResult,
-      status: ResponseStatus.Success,
-      requestId,
-      serviceMethod,
-      data,
-    });
-  }
-
-  protected captureSendRequestFail(requestId: string, serviceMethod: string, error: any): void {
-    this.capture({
-      type: MessageType.RequestResult,
-      status: ResponseStatus.Fail,
-      requestId,
-      serviceMethod,
-      error,
-    });
-  }
-
-  protected captureSendNotification(serviceMethod: string, args: any[]): void {
-    this.capture({ type: MessageType.SendNotification, serviceMethod, arguments: args });
-  }
-
   listen(connection: T): void {
     this.connection = connection;
-    this.bindMethods(this.runner.getServices());
+
+    if (this.target) {
+      this.listenService(this.target);
+    }
 
     connection.listen();
     this.connectionPromise.resolve();
   }
 
   public listenService(service: IRPCServiceMap) {
-    this.runner.registerService(service);
+    if (this.connection) {
+      this.bindOnRequest(service, (service, prop) => {
+        this.proxyService[prop] = service[prop].bind(service);
+      });
+    } else {
+      if (!this.target) {
+        this.target = {} as any;
+      }
+
+      const methods = getServiceMethods(service);
+      for (const method of methods) {
+        // `getServiceMethods` ensure that method is a function
+        (this.target as any)[method] = service[method]!.bind(service);
+      }
+    }
   }
 
-  abstract getInvokeProxy<T = any>(): T;
-  protected abstract bindMethods(services: string[]): void;
+  abstract getInvokeProxy(): any;
+
+  protected abstract bindOnRequest(service: IRPCServiceMap, cb: (service: IRPCServiceMap, prop: string) => void): void;
 }

package/src/common/proxy/legacy.ts

@@ -1,6 +1,9 @@
+import { uuid } from '@opensumi/ide-core-common';
 import { MessageConnection } from '@opensumi/vscode-jsonrpc';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
+import { IRPCServiceMap } from '../types';
+import { MessageType, ResponseStatus, getServiceMethods } from '../utils';
 
 import { ProxyBase } from './base';
 
@@ -10,104 +13,119 @@ interface IRPCResult {
 }
 
 export class ProxyLegacy extends ProxyBase<MessageConnection> {
-  protected engine = 'legacy' as const;
-
-  protected bindMethods(methods: string[]): void {
-    for (const method of methods) {
-      if (method.startsWith('on')) {
-        this.connection.onNotification(method, async (...args: any[]) => {
-          this.captureOnNotification(method, args);
-          try {
-            await this.runner.run(method, ...this.serializeArguments(args));
-          } catch (e) {
-            this.logger.warn(`notification exec ${method} error`, e);
-          }
-        });
+  engine = 'legacy' as const;
+
+  public getInvokeProxy(): any {
+    return new Proxy(this, this);
+  }
+
+  public get(target: any, p: PropertyKey) {
+    const prop = p.toString();
+    return async (...args: any[]) => {
+      await this.connectionPromise.promise;
+
+      let isSingleArray = false;
+      if (args.length === 1 && Array.isArray(args[0])) {
+        isSingleArray = true;
+      }
+
+      // 调用方法为 on 开头时，作为单项通知
+      if (prop.startsWith('on')) {
+        if (isSingleArray) {
+          this.connection.sendNotification(prop, [...args]);
+        } else {
+          this.connection.sendNotification(prop, ...args);
+        }
+        this.capture({ type: MessageType.SendNotification, serviceMethod: prop, arguments: args });
       } else {
-        this.connection.onRequest(method, async (...args: any[]) => {
-          const requestId = this.nextRequestId();
-          this.captureOnRequest(requestId, method, args);
-
-          try {
-            const result = await this.runner.run(method, ...this.serializeArguments(args));
-
-            this.captureOnRequestResult(requestId, method, result);
-
-            return {
-              error: false,
-              data: result,
-            };
-          } catch (e) {
-            this.captureOnRequestFail(requestId, method, e);
-
-            return {
-              error: true,
-              data: {
-                message: e.message,
-                stack: e.stack,
-              },
-            };
+        let requestResult: Promise<any>;
+        // generate a unique requestId to associate request and requestResult
+        const requestId = uuid();
+
+        if (isSingleArray) {
+          requestResult = this.connection.sendRequest(prop, [...args]) as Promise<any>;
+        } else {
+          requestResult = this.connection.sendRequest(prop, ...args) as Promise<any>;
+        }
+
+        this.capture({ type: MessageType.SendRequest, requestId, serviceMethod: prop, arguments: args });
+
+        const result: IRPCResult = await requestResult;
+
+        if (result.error) {
+          const error = new Error(result.data.message);
+          if (result.data.stack) {
+            error.stack = result.data.stack;
           }
-        });
+          this.capture({
+            type: MessageType.RequestResult,
+            status: ResponseStatus.Fail,
+            requestId,
+            serviceMethod: prop,
+            error: result.data,
+          });
+          throw error;
+        } else {
+          this.capture({
+            type: MessageType.RequestResult,
+            status: ResponseStatus.Success,
+            requestId,
+            serviceMethod: prop,
+            data: result.data,
+          });
+          return result.data;
+        }
       }
-    }
+    };
   }
 
-  public getInvokeProxy<T = any>(): T {
-    return new Proxy(Object.create(null), {
-      get: (target: any, p: PropertyKey) => {
-        const prop = p.toString();
-        if (!target[prop]) {
-          target[prop] = async (...args: any[]) => {
-            await this.connectionPromise.promise;
-
-            let isSingleArray = false;
-            if (args.length === 1 && Array.isArray(args[0])) {
-              isSingleArray = true;
-            }
-
-            // 调用方法为 on 开头时，作为单项通知
-            if (prop.startsWith('on')) {
-              this.captureSendNotification(prop, args);
-              if (isSingleArray) {
-                this.connection.sendNotification(prop, [...args]);
-              } else {
-                this.connection.sendNotification(prop, ...args);
-              }
-            } else {
-              // generate a unique requestId to associate request and requestResult
-              const requestId = this.nextRequestId();
-
-              let requestResult: Promise<any>;
-
-              if (isSingleArray) {
-                requestResult = this.connection.sendRequest(prop, [...args]) as Promise<any>;
-              } else {
-                requestResult = this.connection.sendRequest(prop, ...args) as Promise<any>;
-              }
-
-              this.captureSendRequest(requestId, prop, args);
-
-              const result: IRPCResult = await requestResult;
-
-              if (result.error) {
-                const error = new Error(result.data.message);
-                if (result.data.stack) {
-                  error.stack = result.data.stack;
-                }
-
-                this.captureSendRequestFail(requestId, prop, result.data);
-                throw error;
-              } else {
-                this.captureSendRequestResult(requestId, prop, result.data);
-                return result.data;
-              }
-            }
-          };
+  protected bindOnRequest(service: IRPCServiceMap, cb?: ((service: IRPCServiceMap, prop: string) => void) | undefined) {
+    if (this.connection) {
+      const connection = this.connection;
+
+      const methods = getServiceMethods(service);
+
+      methods.forEach((method) => {
+        if (method.startsWith('on')) {
+          connection.onNotification(method, (...args) => {
+            this.onNotification(method, ...args);
+            this.capture({ type: MessageType.OnNotification, serviceMethod: method, arguments: args });
+          });
+        } else {
+          connection.onRequest(method, (...args) => {
+            const requestId = uuid();
+            const result = this.onRequest(method, ...args);
+            this.capture({ type: MessageType.OnRequest, requestId, serviceMethod: method, arguments: args });
+
+            result
+              .then((result) => {
+                this.capture({
+                  type: MessageType.OnRequestResult,
+                  status: ResponseStatus.Success,
+                  requestId,
+                  serviceMethod: method,
+                  data: result.data,
+                });
+              })
+              .catch((err) => {
+                this.capture({
+                  type: MessageType.OnRequestResult,
+                  status: ResponseStatus.Fail,
+                  requestId,
+                  serviceMethod: method,
+                  error: err.data,
+                });
+              });
+
+            return result;
+          });
         }
-        return target[prop];
-      },
-    });
+
+        if (cb) {
+          cb(service, method);
+        }
+      });
+    }
   }
 
   /**
@@ -132,17 +150,49 @@ export class ProxyLegacy extends ProxyBase<MessageConnection> {
     return args;
   }
 
+  private async onRequest(prop: PropertyKey, ...args: any[]) {
+    try {
+      const result = await this.proxyService[prop](...this.serializeArguments(args));
+
+      return {
+        error: false,
+        data: result,
+      };
+    } catch (e) {
+      return {
+        error: true,
+        data: {
+          message: e.message,
+          stack: e.stack,
+        },
+      };
+    }
+  }
+
+  private onNotification(prop: PropertyKey, ...args: any[]) {
+    try {
+      this.proxyService[prop](...this.serializeArguments(args));
+    } catch (e) {
+      this.logger.warn('notification', e);
+    }
+  }
+
   listen(connection: MessageConnection): void {
     super.listen(connection);
-
     connection.onRequest((method) => {
-      if (!this.runner.has(method)) {
-        const requestId = this.nextRequestId();
-        this.captureOnRequest(requestId, method, []);
+      if (!this.proxyService[method]) {
+        const requestId = uuid();
+        this.capture({ type: MessageType.OnRequest, requestId, serviceMethod: method });
         const result = {
           data: METHOD_NOT_REGISTERED,
         };
-        this.captureOnRequestFail(requestId, method, result.data);
+        this.capture({
+          type: MessageType.OnRequestResult,
+          status: ResponseStatus.Fail,
+          requestId,
+          serviceMethod: method,
+          error: result.data,
+        });
         return result;
       }
     });

package/src/common/rpc-service/center.ts

@@ -2,11 +2,7 @@ import { Deferred } from '@opensumi/ide-core-common';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
 import { ProxyLegacy } from '../proxy';
-import { ServiceRunner } from '../proxy/runner';
-import { ProxySumi } from '../proxy/sumi';
-import { TSumiProtocol } from '../rpc';
-import { ProtocolRepository } from '../rpc/protocol-repository';
-import { IBench, ILogger, RPCServiceMethod, ServiceType } from '../types';
+import { IBench, ILogger, IRPCServiceMap, RPCServiceMethod, ServiceType } from '../types';
 import { getMethodName } from '../utils';
 import { WSChannel } from '../ws-channel';
 
@@ -16,32 +12,19 @@ const defaultReservedWordSet = new Set(['then']);
 
 class Invoker {
   legacyProxy: ProxyLegacy;
-  sumiProxy: ProxySumi;
 
   private legacyInvokeProxy: any;
-  private sumiInvokeProxy: any;
-
-  constructor(protected repo: ProtocolRepository) {}
 
   setLegacyProxy(proxy: ProxyLegacy) {
     this.legacyProxy = proxy;
     this.legacyInvokeProxy = proxy.getInvokeProxy();
   }
 
-  setSumiProxy(proxy: ProxySumi) {
-    this.sumiProxy = proxy;
-    this.sumiInvokeProxy = proxy.getInvokeProxy();
-  }
-
   invoke(name: string, ...args: any[]) {
     if (defaultReservedWordSet.has(name) || typeof name === 'symbol') {
       return Promise.resolve();
     }
 
-    if (this.repo.has(name)) {
-      return this.sumiInvokeProxy[name](...args);
-    }
-
     return this.legacyInvokeProxy[name](...args);
   }
 }
@@ -52,8 +35,7 @@ export class RPCServiceCenter {
   private invokers: Invoker[] = [];
   private connection: Array<WSChannel> = [];
 
-  private protocolRepository = new ProtocolRepository();
-  private serviceRunner = new ServiceRunner();
+  private serviceMethodMap = { client: undefined } as unknown as IRPCServiceMap;
 
   private connectionDeferred = new Deferred<void>();
   private logger: ILogger;
@@ -75,33 +57,20 @@ export class RPCServiceCenter {
     return this.connectionDeferred.promise;
   }
 
-  loadProtocol(protocol: TSumiProtocol) {
-    this.protocolRepository.loadProtocol(protocol, {
-      nameConverter: (name) => getMethodName(protocol.name, name),
-    });
-  }
-
   setChannel(channel: WSChannel) {
-    if (this.connection.length === 0) {
+    if (!this.connection.length) {
       this.connectionDeferred.resolve();
     }
-
     this.connection.push(channel);
     const index = this.connection.length - 1;
 
-    const invoker = new Invoker(this.protocolRepository);
-
-    const legacy = new ProxyLegacy(this.serviceRunner, this.logger);
-    const messageConnection = channel.createMessageConnection();
-    legacy.listen(messageConnection);
+    const rpcProxy = new ProxyLegacy(this.serviceMethodMap, this.logger);
+    const connection = channel.createMessageConnection();
+    rpcProxy.listen(connection);
 
-    const sumi = new ProxySumi(this.serviceRunner, this.logger);
-    const connection = channel.createConnection(this.protocolRepository);
+    const invoker = new Invoker();
 
-    sumi.listen(connection);
-
-    invoker.setLegacyProxy(legacy);
-    invoker.setSumiProxy(sumi);
+    invoker.setLegacyProxy(rpcProxy);
 
     this.invokers.push(invoker);
 
@@ -115,13 +84,14 @@ export class RPCServiceCenter {
   }
 
   onRequest(serviceName: string, _name: string, method: RPCServiceMethod) {
-    this.serviceRunner.register(getMethodName(serviceName, _name), method);
-  }
-
-  onRequestService(serviceName: string, service: any) {
-    this.serviceRunner.registerService(service, {
-      nameConverter: (name) => getMethodName(serviceName, name),
-    });
+    const name = getMethodName(serviceName, _name);
+    if (!this.connection.length) {
+      this.serviceMethodMap[name] = method;
+    } else {
+      this.invokers.forEach((proxy) => {
+        proxy.legacyProxy.listenService({ [name]: method });
+      });
+    }
   }
 
   async broadcast(serviceName: string, _name: string, ...args: any[]): Promise<any> {

package/src/common/rpc-service/stub.ts

@@ -1,4 +1,5 @@
 import { RPCServiceMethod, ServiceType } from '../types';
+import { getServiceMethods } from '../utils';
 
 import { RPCServiceCenter } from './center';
 
@@ -16,7 +17,10 @@ export class RPCServiceStub {
   }
 
   onRequestService(service: any) {
-    this.center.onRequestService(this.serviceName, service);
+    const methods = getServiceMethods(service);
+    for (const method of methods) {
+      this.onRequest(method, service[method].bind(service));
+    }
   }
 
   onRequest(name: string, method: RPCServiceMethod) {

package/src/common/types.ts

@@ -5,7 +5,7 @@ export interface ILogger {
 }
 
 export type RPCServiceMethod = (...args: any[]) => any;
-export type IRPCServiceMap = Record<PropertyKey, RPCServiceMethod>;
+export type IRPCServiceMap = Record<string, RPCServiceMethod>;
 
 export enum ServiceType {
   Service,