@opensumi/ide-connection 2.27.3-rc-1706687185.0 → 2.27.3-rc-1708222409.0

package/src/common/rpc-service/proxy/base.ts

@@ -0,0 +1,126 @@
+import { Deferred, isDefined } from '@opensumi/ide-core-common';
+
+import { ILogger, IRPCServiceMap } from '../../types';
+import { ICapturedMessage, MessageType, ResponseStatus, getCapturer } from '../../utils';
+
+import type { ServiceRegistry } from './registry';
+
+interface IBaseConnection {
+  listen(): void;
+  dispose(): void;
+}
+
+let requestId = 0;
+
+export abstract class ProxyBase<T extends IBaseConnection> {
+  protected logger: ILogger;
+  protected connection: T;
+
+  protected connectionPromise: Deferred<void> = new Deferred<void>();
+
+  protected abstract engine: 'legacy' | 'sumi';
+
+  constructor(public registry: ServiceRegistry, logger?: ILogger) {
+    this.logger = logger || console;
+
+    this.registry.onServicesUpdate((services) => {
+      if (this.connection) {
+        this.bindMethods(services);
+      }
+    });
+  }
+
+  // capture messages for opensumi devtools
+  private capture(message: ICapturedMessage): void {
+    const capturer = getCapturer();
+    if (isDefined(capturer)) {
+      capturer({
+        ...message,
+        engine: this.engine,
+      });
+    }
+  }
+
+  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.registry.methods());
+
+    connection.listen();
+    this.connectionPromise.resolve();
+  }
+
+  public listenService(service: IRPCServiceMap) {
+    this.registry.registerService(service);
+  }
+
+  dispose(): void {
+    if (this.connection) {
+      this.connection.dispose();
+    }
+  }
+
+  abstract getInvokeProxy<T = any>(): T;
+  protected abstract bindMethods(services: PropertyKey[]): void;
+}

package/src/common/rpc-service/proxy/index.ts

@@ -0,0 +1,4 @@
+export * from './legacy';
+export * from './sumi';
+export * from './registry';
+export * from './invoker';

package/src/common/rpc-service/proxy/invoker.ts

@@ -0,0 +1,45 @@
+import { ProxyLegacy } from './legacy';
+import { ProxySumi } from './sumi';
+
+const defaultReservedWordSet = new Set(['then', 'finally']);
+
+export class Invoker {
+  legacyProxy: ProxyLegacy;
+  sumiProxy: ProxySumi;
+
+  private legacyInvokeProxy: any;
+  private sumiInvokeProxy: any;
+
+  constructor() {}
+
+  attachLegacy(legacyProxy: ProxyLegacy) {
+    this.legacyProxy = legacyProxy;
+    this.legacyInvokeProxy = this.legacyProxy.getInvokeProxy();
+  }
+
+  attachSumi(sumiProxy: ProxySumi) {
+    this.sumiProxy = sumiProxy;
+    this.sumiInvokeProxy = this.sumiProxy.getInvokeProxy();
+  }
+
+  invoke(name: string, ...args: any[]) {
+    if (defaultReservedWordSet.has(name)) {
+      return Promise.resolve();
+    }
+
+    if (this.sumiInvokeProxy) {
+      return this.sumiInvokeProxy[name](...args);
+    }
+
+    return this.legacyInvokeProxy[name](...args);
+  }
+
+  dispose() {
+    if (this.legacyProxy) {
+      this.legacyProxy.dispose();
+    }
+    if (this.sumiProxy) {
+      this.sumiProxy.dispose();
+    }
+  }
+}

package/src/common/rpc-service/proxy/legacy.ts

@@ -0,0 +1,150 @@
+import { MessageConnection } from '@opensumi/vscode-jsonrpc';
+
+import { METHOD_NOT_REGISTERED } from '../../constants';
+
+import { ProxyBase } from './base';
+
+interface IRPCResult {
+  error: boolean;
+  data: any;
+}
+
+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.registry.invoke(method, ...this.serializeArguments(args));
+          } catch (e) {
+            this.logger.warn(`notification exec ${method} error`, e);
+          }
+        });
+      } else {
+        this.connection.onRequest(method, async (...args: any[]) => {
+          const requestId = this.nextRequestId();
+          this.captureOnRequest(requestId, method, args);
+
+          try {
+            const result = await this.registry.invoke(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,
+              },
+            };
+          }
+        });
+      }
+    }
+  }
+
+  public getInvokeProxy<T = any>(): T {
+    return new Proxy(Object.create(null), {
+      get: (target: any, p: PropertyKey) => {
+        if (!target[p]) {
+          target[p] = async (...args: any[]) => {
+            await this.connectionPromise.promise;
+
+            let isSingleArray = false;
+            if (args.length === 1 && Array.isArray(args[0])) {
+              isSingleArray = true;
+            }
+            const prop = p.toString();
+
+            // 调用方法为 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;
+              }
+            }
+          };
+        }
+        return target[p];
+      },
+    });
+  }
+
+  /**
+   * 对于纯数组参数的情况，收到请求/通知后做展开操作
+   * 因为在通信层会为每个 rpc 调用添加一个 CancellationToken 参数
+   * 如果参数本身是数组, 在方法中如果使用 spread 运算符获取参数(...args)，则会出现 [...args, MutableToken] 这种情况
+   * 所以发送请求时将这类参数统一再用数组包了一层，形如 [[...args]], 参考 {@link ProxyLegacy.get get} 方法
+   * 此时接收到的数组类参数固定长度为 2，且最后一项一定是 MutableToken
+   * @param args
+   * @returns args
+   */
+  private serializeArguments(args: any[]): any[] {
+    const maybeCancellationToken = args[args.length - 1];
+    if (
+      args.length === 2 &&
+      Array.isArray(args[0]) &&
+      Object.prototype.hasOwnProperty.call(maybeCancellationToken, '_isCancelled')
+    ) {
+      return [...args[0], maybeCancellationToken];
+    }
+
+    return args;
+  }
+
+  listen(connection: MessageConnection): void {
+    super.listen(connection);
+
+    connection.onRequest((method) => {
+      if (!this.registry.has(method)) {
+        const requestId = this.nextRequestId();
+        this.captureOnRequest(requestId, method, []);
+        const result = {
+          data: METHOD_NOT_REGISTERED,
+        };
+        this.captureOnRequestFail(requestId, method, result.data);
+        return result;
+      }
+    });
+  }
+}

package/src/common/rpc-service/proxy/registry.ts

@@ -0,0 +1,56 @@
+import { Emitter } from '@opensumi/ide-core-common';
+
+import { RPCServiceMethod } from '../../types';
+import { getServiceMethods } from '../../utils';
+
+/**
+ * Store all executable services
+ */
+export class ServiceRegistry {
+  protected emitter = new Emitter<string[]>();
+
+  private serviceMethodMap = new Map<PropertyKey, RPCServiceMethod>();
+
+  onServicesUpdate = this.emitter.event;
+
+  register(name: string, methodFn: RPCServiceMethod) {
+    this.serviceMethodMap.set(name, methodFn);
+    this.emitter.fire([name]);
+  }
+
+  registerService(
+    service: any,
+    options?: {
+      nameConverter?: (str: string) => string;
+    },
+  ) {
+    const serviceNames = [] as string[];
+    const { nameConverter } = options || {};
+    const methods = getServiceMethods(service);
+    for (const method of methods) {
+      let methodName = method;
+      if (nameConverter) {
+        methodName = nameConverter(method);
+      }
+
+      this.serviceMethodMap.set(methodName, service[method].bind(service));
+      serviceNames.push(methodName);
+    }
+
+    this.emitter.fire(serviceNames);
+  }
+
+  has(name: PropertyKey) {
+    return this.serviceMethodMap.has(name);
+  }
+
+  invoke(name: PropertyKey, ...args: any[]): any {
+    // here because we have checked the existence of the method
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.serviceMethodMap.get(name)!(...args);
+  }
+
+  methods() {
+    return Array.from(this.serviceMethodMap.keys());
+  }
+}

package/src/common/rpc-service/proxy/sumi.ts

@@ -0,0 +1,81 @@
+import { METHOD_NOT_REGISTERED } from '../../constants';
+import { SumiConnection } from '../../rpc/connection';
+
+import { ProxyBase } from './base';
+
+export class ProxySumi extends ProxyBase<SumiConnection> {
+  protected engine = 'sumi' 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.registry.invoke(method, ...args);
+          } catch (e) {
+            this.logger.warn(`notification exec ${method} error`, e);
+          }
+        });
+      } else {
+        this.connection.onRequest(method, async (...args: any[]) => {
+          const requestId = this.nextRequestId();
+          this.captureOnRequest(requestId, method, args);
+
+          try {
+            const result = await this.registry.invoke(method, ...args);
+            this.captureOnRequestResult(requestId, method, result);
+            return result;
+          } catch (e) {
+            this.captureOnRequestFail(requestId, method, e);
+            throw e;
+          }
+        });
+      }
+    }
+  }
+
+  public getInvokeProxy<T = any>(): T {
+    return new Proxy(Object.create(null), {
+      get: (target: any, p: PropertyKey) => {
+        if (!target[p]) {
+          target[p] = async (...args: any[]) => {
+            await this.connectionPromise.promise;
+            const prop = p.toString();
+
+            // 调用方法为 on 开头时，作为单项通知
+            if (prop.startsWith('on')) {
+              this.captureSendNotification(prop, args);
+              this.connection.sendNotification(prop, ...args);
+            } else {
+              // generate a unique requestId to associate request and requestResult
+              const requestId = this.nextRequestId();
+              this.captureSendRequest(requestId, prop, args);
+              try {
+                const result = await this.connection.sendRequest(prop, ...args);
+                this.captureSendRequestResult(requestId, prop, result);
+                return result;
+              } catch (error) {
+                this.captureSendRequestFail(requestId, prop, error);
+                throw error;
+              }
+            }
+          };
+        }
+        return target[p];
+      },
+    });
+  }
+
+  listen(connection: SumiConnection): void {
+    super.listen(connection);
+    connection.onRequestNotFound((method) => {
+      if (!this.registry.has(method)) {
+        const requestId = this.nextRequestId();
+        this.captureOnRequest(requestId, method, []);
+        this.captureOnRequestFail(requestId, method, METHOD_NOT_REGISTERED);
+        throw METHOD_NOT_REGISTERED;
+      }
+    });
+  }
+}

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

@@ -1,5 +1,4 @@
 import { RPCServiceMethod, ServiceType } from '../types';
-import { getServiceMethods } from '../utils';
 
 import { RPCServiceCenter } from './center';
 
@@ -8,19 +7,12 @@ export class RPCServiceStub {
     this.center.registerService(serviceName, this.type);
   }
 
-  async ready() {
-    return this.center.ready();
-  }
-
   on(name: string, method: RPCServiceMethod) {
     this.onRequest(name, method);
   }
 
   onRequestService(service: any) {
-    const methods = getServiceMethods(service);
-    for (const method of methods) {
-      this.onRequest(method, service[method].bind(service));
-    }
+    this.center.onRequestService(this.serviceName, service);
   }
 
   onRequest(name: string, method: RPCServiceMethod) {
@@ -38,9 +30,10 @@ export class RPCServiceStub {
         if (!target[prop]) {
           if (typeof prop === 'symbol') {
             return Promise.resolve();
-          } else {
-            return (...args: any[]) => this.ready().then(() => this.broadcast(prop, ...args));
           }
+
+          target[prop] = (...args: any[]) => this.broadcast(prop, ...args);
+          return target[prop];
         } else {
           return target[prop];
         }

package/src/common/types.ts

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