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

package/src/common/proxy/legacy.ts

@@ -0,0 +1,200 @@
+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';
+
+interface IRPCResult {
+  error: boolean;
+  data: any;
+}
+
+export class ProxyLegacy extends ProxyBase<MessageConnection> {
+  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 {
+        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;
+        }
+      }
+    };
+  }
+
+  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;
+          });
+        }
+
+        if (cb) {
+          cb(service, method);
+        }
+      });
+    }
+  }
+
+  /**
+   * 对于纯数组参数的情况，收到请求/通知后做展开操作
+   * 因为在通信层会为每个 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;
+  }
+
+  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.proxyService[method]) {
+        const requestId = uuid();
+        this.capture({ type: MessageType.OnRequest, requestId, serviceMethod: method });
+        const result = {
+          data: METHOD_NOT_REGISTERED,
+        };
+        this.capture({
+          type: MessageType.OnRequestResult,
+          status: ResponseStatus.Fail,
+          requestId,
+          serviceMethod: method,
+          error: result.data,
+        });
+        return result;
+      }
+    });
+  }
+}

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

@@ -0,0 +1,124 @@
+import { Deferred } from '@opensumi/ide-core-common';
+
+import { METHOD_NOT_REGISTERED } from '../constants';
+import { ProxyLegacy } from '../proxy';
+import { IBench, ILogger, IRPCServiceMap, RPCServiceMethod, ServiceType } from '../types';
+import { getMethodName } from '../utils';
+import { WSChannel } from '../ws-channel';
+
+const safeProcess: { pid: string } = typeof process === 'undefined' ? { pid: 'mock' } : (process as any);
+
+const defaultReservedWordSet = new Set(['then']);
+
+class Invoker {
+  legacyProxy: ProxyLegacy;
+
+  private legacyInvokeProxy: any;
+
+  setLegacyProxy(proxy: ProxyLegacy) {
+    this.legacyProxy = proxy;
+    this.legacyInvokeProxy = proxy.getInvokeProxy();
+  }
+
+  invoke(name: string, ...args: any[]) {
+    if (defaultReservedWordSet.has(name) || typeof name === 'symbol') {
+      return Promise.resolve();
+    }
+
+    return this.legacyInvokeProxy[name](...args);
+  }
+}
+
+export class RPCServiceCenter {
+  public uid: string;
+
+  private invokers: Invoker[] = [];
+  private connection: Array<WSChannel> = [];
+
+  private serviceMethodMap = { client: undefined } as unknown as IRPCServiceMap;
+
+  private connectionDeferred = new Deferred<void>();
+  private logger: ILogger;
+
+  constructor(private bench?: IBench, logger?: ILogger) {
+    this.uid = 'RPCServiceCenter:' + safeProcess.pid;
+    this.logger = logger || console;
+  }
+
+  registerService(serviceName: string, type: ServiceType): void {
+    if (type === ServiceType.Service) {
+      if (this.bench) {
+        this.bench.registerService(serviceName);
+      }
+    }
+  }
+
+  ready() {
+    return this.connectionDeferred.promise;
+  }
+
+  setChannel(channel: WSChannel) {
+    if (!this.connection.length) {
+      this.connectionDeferred.resolve();
+    }
+    this.connection.push(channel);
+    const index = this.connection.length - 1;
+
+    const rpcProxy = new ProxyLegacy(this.serviceMethodMap, this.logger);
+    const connection = channel.createMessageConnection();
+    rpcProxy.listen(connection);
+
+    const invoker = new Invoker();
+
+    invoker.setLegacyProxy(rpcProxy);
+
+    this.invokers.push(invoker);
+
+    return {
+      dispose: () => {
+        this.connection.splice(index, 1);
+        this.invokers.splice(index, 1);
+        connection.dispose();
+      },
+    };
+  }
+
+  onRequest(serviceName: string, _name: string, method: RPCServiceMethod) {
+    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> {
+    const name = getMethodName(serviceName, _name);
+    const broadcastResult = await Promise.all(this.invokers.map((proxy) => proxy.invoke(name, ...args)));
+
+    const doubtfulResult = [] as any[];
+    const result = [] as any[];
+    for (const i of broadcastResult) {
+      if (i === METHOD_NOT_REGISTERED) {
+        doubtfulResult.push(i);
+      } else {
+        result.push(i);
+      }
+    }
+
+    if (doubtfulResult.length > 0) {
+      this.logger.warn(`broadcast rpc \`${name}\` getting doubtful responses: ${doubtfulResult.join(',')}`);
+    }
+
+    if (result.length === 0) {
+      throw new Error(`broadcast rpc \`${name}\` error: no remote service can handle this call`);
+    }
+
+    // FIXME: this is an unreasonable design, if remote service only returned doubtful result, we will return an empty array.
+    //        but actually we should throw an error to tell user that no remote service can handle this call.
+    //        or just return `undefined`.
+    return result.length === 1 ? result[0] : result;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './stub';
+export * from './center';

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

@@ -0,0 +1,49 @@
+import { RPCServiceMethod, ServiceType } from '../types';
+import { getServiceMethods } from '../utils';
+
+import { RPCServiceCenter } from './center';
+
+export class RPCServiceStub {
+  constructor(private serviceName: string, private center: RPCServiceCenter, private type: ServiceType) {
+    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));
+    }
+  }
+
+  onRequest(name: string, method: RPCServiceMethod) {
+    this.center.onRequest(this.serviceName, name, method);
+  }
+
+  broadcast(name: string, ...args: any[]): Promise<any> {
+    return this.center.broadcast(this.serviceName, name, ...args);
+  }
+
+  getProxy = <T>() =>
+    new Proxy<T extends void ? RPCServiceStub : RPCServiceStub & T>(this as any, {
+      // 调用方
+      get: (target, prop: string) => {
+        if (!target[prop]) {
+          if (typeof prop === 'symbol') {
+            return Promise.resolve();
+          } else {
+            return (...args: any[]) => this.ready().then(() => this.broadcast(prop, ...args));
+          }
+        } else {
+          return target[prop];
+        }
+      },
+    });
+}

package/src/common/types.ts

@@ -0,0 +1,17 @@
+export interface ILogger {
+  log(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+}
+
+export type RPCServiceMethod = (...args: any[]) => any;
+export type IRPCServiceMap = Record<string, RPCServiceMethod>;
+
+export enum ServiceType {
+  Service,
+  Stub,
+}
+
+export interface IBench {
+  registerService: (service: string) => void;
+}

package/src/common/utils.ts

@@ -41,17 +41,40 @@ export interface WSCloseInfo {
   connectInfo: ConnectionInfo;
 }
 
-export function stringify(obj: any): string {
-  return JSON.stringify(obj);
-}
-
-export function parse(input: string, reviver?: (this: any, key: string, value: any) => any): any {
-  return JSON.parse(input, reviver);
-}
-
 export function getCapturer() {
   if (typeof window !== 'undefined' && window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__?.captureRPC) {
     return window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__.captureRPC;
   }
   return;
 }
+
+export function getServiceMethods(service: any): string[] {
+  let props: any[] = [];
+
+  if (/^\s*class/.test(service.constructor.toString())) {
+    let obj = service;
+    do {
+      props = props.concat(Object.getOwnPropertyNames(obj));
+    } while ((obj = Object.getPrototypeOf(obj)));
+    props = props.sort().filter((e, i, arr) => e !== arr[i + 1] && typeof service[e] === 'function');
+  } else {
+    for (const prop in service) {
+      if (service[prop] && typeof service[prop] === 'function') {
+        props.push(prop);
+      }
+    }
+  }
+
+  return props;
+}
+
+export function getNotificationName(serviceName: string, name: string) {
+  return `on:${serviceName}:${name}`;
+}
+export function getRequestName(serviceName: string, name: string) {
+  return `${serviceName}:${name}`;
+}
+
+export function getMethodName(serviceName: string, name: string) {
+  return name.startsWith('on') ? getNotificationName(serviceName, name) : getRequestName(serviceName, name);
+}