@opensumi/ide-connection 2.27.3-rc-1708399099.0 → 2.27.3-rc-1710386185.0

package/src/common/rpc/message-io.ts

@@ -0,0 +1,223 @@
+import Fury, { Serializer, Type, TypeDescription } from '@furyjs/fury';
+import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
+import { BinaryReader, BinaryWriter } from '@furyjs/fury/dist/lib/type';
+
+import { stringifyError } from '@opensumi/ide-core-common/lib/utils';
+
+import { AnySerializer } from '../fury-extends/any';
+import { furyFactory } from '../fury-extends/shared';
+
+import {
+  IProtocolSerializer,
+  IRequestHeaders,
+  IResponseHeaders,
+  ITransferable,
+  TSerializer,
+  TSumiProtocol,
+  TSumiProtocolMethod,
+} from './types';
+
+const ProtoVersionV1 = 1;
+
+export enum OperationType {
+  Request,
+  Notification,
+  Response,
+  Cancel,
+}
+
+export enum Status {
+  OK,
+  Err,
+}
+
+export const HeadersProto = {
+  Request: Type.object('req-headers', {
+    cancelable: Type.bool(),
+  }),
+  Response: Type.object('resp-headers', {
+    chunked: Type.bool(),
+  }),
+} as const;
+
+class SumiProtocolSerializer implements IProtocolSerializer {
+  request: TSerializer;
+  result: TSerializer;
+
+  constructor(methodProtocol: TSumiProtocolMethod, public fury: Fury) {
+    const argsTuple = [] as TypeDescription[];
+
+    for (const element of methodProtocol.request) {
+      argsTuple.push(element.type);
+    }
+
+    const requestProto = Type.tuple(argsTuple);
+    const resultProto = methodProtocol.response.type || Type.any();
+
+    this.request = this.fury.registerSerializer(requestProto);
+    this.result = this.fury.registerSerializer(resultProto);
+  }
+
+  writeRequest(args: any[]): void {
+    return this.request.serializer.write(args);
+  }
+  readRequest(): any[] {
+    return this.request.serializer.read();
+  }
+  writeResponse<T = ITransferable>(result: T): void {
+    return this.result.serializer.write(result);
+  }
+  readResponse<T = ITransferable>(): T {
+    return this.result.serializer.read();
+  }
+}
+
+class AnyProtocolSerializer implements IProtocolSerializer {
+  anySerializer: AnySerializer;
+
+  constructor(public writer: BinaryWriter, public reader: BinaryReader) {
+    this.anySerializer = new AnySerializer(this.writer, this.reader);
+  }
+
+  writeRequest(args: any[]): void {
+    this.anySerializer.write(args);
+  }
+  readRequest(): any[] {
+    return this.anySerializer.read();
+  }
+  writeResponse<T = any>(result: T): void {
+    this.anySerializer.write(result);
+  }
+  readResponse<T = any>(): T {
+    return this.anySerializer.read();
+  }
+}
+
+export class MessageIO {
+  fury: Fury;
+  reader: BinaryReader;
+  writer: BinaryWriter;
+
+  private serializerMap = new Map<string, SumiProtocolSerializer>();
+
+  private anySerializer: AnyProtocolSerializer;
+
+  requestHeadersSerializer: Serializer<IRequestHeaders, IRequestHeaders>;
+  responseHeadersSerializer: Serializer<IResponseHeaders, IRequestHeaders>;
+
+  constructor() {
+    const fury = furyFactory();
+    this.fury = fury.fury;
+    this.reader = fury.reader;
+    this.writer = fury.writer;
+
+    this.requestHeadersSerializer = generateSerializer(this.fury, HeadersProto.Request);
+    this.responseHeadersSerializer = generateSerializer(this.fury, HeadersProto.Response);
+
+    this.anySerializer = new AnyProtocolSerializer(this.writer, this.reader);
+  }
+
+  has(name: string) {
+    return this.serializerMap.has(name);
+  }
+
+  loadProtocol(
+    protocol: TSumiProtocol,
+    options?: {
+      nameConverter?: (str: string) => string;
+    },
+  ) {
+    const { methods } = protocol;
+
+    for (const proto of methods) {
+      this.loadProtocolMethod(proto, options);
+    }
+  }
+
+  loadProtocolMethod(
+    methodProtocol: TSumiProtocolMethod,
+    options?: {
+      nameConverter?: (str: string) => string;
+    },
+  ) {
+    let method = methodProtocol.method;
+    if (options?.nameConverter) {
+      method = options.nameConverter(method);
+    }
+    this.serializerMap.set(method, new SumiProtocolSerializer(methodProtocol, this.fury));
+  }
+
+  getProcessor(method: string): IProtocolSerializer {
+    const processor = this.serializerMap.get(method);
+    if (processor) {
+      return processor;
+    }
+    return this.anySerializer;
+  }
+
+  Notification(requestId: number, method: string, headers: IRequestHeaders, args: any[]) {
+    const { writer } = this;
+    writer.reset();
+
+    writer.uint16((OperationType.Notification << 8) | ProtoVersionV1);
+    writer.uint32(requestId);
+
+    writer.stringOfVarUInt32(method);
+    this.requestHeadersSerializer.write(headers);
+    this.getProcessor(method).writeRequest(args);
+
+    return writer.dump();
+  }
+
+  Request(requestId: number, method: string, headers: IRequestHeaders, args: any[]) {
+    const { writer } = this;
+    writer.reset();
+
+    writer.uint16((OperationType.Request << 8) | ProtoVersionV1);
+    writer.uint32(requestId);
+
+    writer.stringOfVarUInt32(method);
+    this.requestHeadersSerializer.write(headers);
+    this.getProcessor(method).writeRequest(args);
+
+    return writer.dump();
+  }
+
+  Cancel(requestId: number) {
+    const { writer } = this;
+    writer.reset();
+
+    writer.uint16((OperationType.Cancel << 8) | ProtoVersionV1);
+    writer.uint32(requestId);
+
+    return writer.dump();
+  }
+
+  Response(requestId: number, method: string, headers: Record<string, any>, result: any) {
+    const { writer } = this;
+    writer.reset();
+
+    writer.uint16((OperationType.Response << 8) | ProtoVersionV1);
+    writer.uint32(requestId);
+    writer.stringOfVarUInt32(method);
+    writer.uint16(Status.OK);
+    this.responseHeadersSerializer.write(headers);
+    this.getProcessor(method).writeResponse(result);
+
+    return writer.dump();
+  }
+
+  Error(requestId: number, method: string, headers: Record<string, any>, error: any) {
+    const { writer } = this;
+    writer.reset();
+
+    writer.uint16((OperationType.Response << 8) | ProtoVersionV1);
+    writer.uint32(requestId);
+    writer.stringOfVarUInt32(method);
+    writer.uint16(Status.Err);
+    this.responseHeadersSerializer.write(headers);
+    writer.stringOfVarUInt32(stringifyError(error));
+
+    return writer.dump();
+  }
+}

package/src/common/rpc/multiplexer.ts

@@ -35,6 +35,9 @@ function extractServiceAndMethod(rpcId: string): [string, string] {
   return [rpcId.substring(0, idx), rpcId.substring(idx + 1)];
 }
 
+/**
+ * A connection multiplexer that allows to register multiple local RPC services and to create proxies for them.
+ */
 export class SumiConnectionMultiplexer extends SumiConnection implements IRPCProtocol {
   private readonly _locals: Map<string, any>;
   private readonly _proxies: Map<string, any>;

package/src/common/rpc/types.ts

@@ -1,23 +1,48 @@
-import { TypeDescription } from '@furyjs/fury';
-
 import {
+  Headers,
   RPCProtocol as _RPCProtocol,
   RPCProtocolMethod as _RPCProtocolMethod,
   Request as _Request,
   Response as _Response,
 } from '@opensumi/ide-core-common/lib/types/rpc';
 
+import type Fury from '@furyjs/fury';
+import type { Serializer, TypeDescription } from '@furyjs/fury';
+
 export type TSumiProtocol = _RPCProtocol<TypeDescription>;
 export type TSumiProtocolMethod = _RPCProtocolMethod<TypeDescription>;
 export type TSumiRequest = _Request<TypeDescription>;
 export type TSumiResponse = _Response<TypeDescription>;
 
-export type TRequestCallback = (headers: Record<string, any>, error?: any, payload?: Uint8Array | string | any) => void;
+export type TRequestCallback = (headers: Record<string, any>, error?: any, payload?: any) => void;
 
 export type THandlerResult<R> = R | Promise<R>;
 
 export type TGenericNotificationHandler = (...args: any[]) => void | Promise<void>;
 export type TGenericRequestHandler<R> = (...args: any[]) => THandlerResult<R>;
 
-export type TOnRequestNotFoundHandler = (method: string, args: any[]) => THandlerResult<any>;
-export type TOnNotificationNotFoundHandler = (method: string, args: any[]) => THandlerResult<void>;
+export type TRequestNotFoundHandler = (method: string, args: any[]) => THandlerResult<any>;
+export type TNotificationNotFoundHandler = (method: string, args: any[]) => THandlerResult<void>;
+
+export type TSerializer = { serializer: Serializer } & Omit<ReturnType<Fury['registerSerializer']>, 'serializer'>;
+
+export interface IRequestHeaders extends Headers {
+  /**
+   * If set to true, the request can be canceled.
+   *
+   * the server will push a `CancellationToken` to the request arguments.
+   */
+  cancelable?: boolean;
+}
+
+export type IResponseHeaders = Headers;
+
+export type ITransferable = any;
+export type TRequestTransferable = ITransferable[];
+
+export interface IProtocolSerializer {
+  writeRequest(args: any[]): void;
+  readRequest(): any[];
+  writeResponse<T = any>(result: T): void;
+  readResponse<T = any>(): T;
+}

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

@@ -2,22 +2,23 @@ import { Deferred } from '@opensumi/ide-core-common';
 import { MessageConnection } from '@opensumi/vscode-jsonrpc';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
-import { TSumiProtocol, ProtocolRepository } from '../rpc';
+import { TSumiProtocol } from '../rpc';
 import { SumiConnection } from '../rpc/connection';
 import { IBench, ILogger, RPCServiceMethod, ServiceType } from '../types';
-import { getMethodName } from '../utils';
 
-import { ServiceRegistry, Invoker, ProxyLegacy, ProxySumi } from './proxy';
+import { ProxyJson, ProxySumi } from './proxy';
+import { ProxyBase } from './proxy/base';
+import { ProtocolRegistry, ServiceRegistry } from './registry';
 
 const safeProcess: { pid: string } = typeof process === 'undefined' ? { pid: 'unknown' } : (process as any);
 
 export class RPCServiceCenter {
   public uid: string;
 
-  private invokers: Invoker[] = [];
+  private proxies: ProxyBase<any>[] = [];
 
-  private protocolRepository = new ProtocolRepository();
-  private registry = new ServiceRegistry();
+  private serviceRegistry = new ServiceRegistry();
+  private protocolRegistry = new ProtocolRegistry();
 
   private deferred = new Deferred<void>();
   private logger: ILogger;
@@ -40,64 +41,58 @@ export class RPCServiceCenter {
   }
 
   loadProtocol(protocol: TSumiProtocol) {
-    this.protocolRepository.loadProtocol(protocol, {
+    this.protocolRegistry.addProtocol(protocol, {
       nameConverter: (name) => getMethodName(protocol.name, name),
     });
   }
 
   setSumiConnection(connection: SumiConnection) {
-    if (this.invokers.length === 0) {
+    if (this.proxies.length === 0) {
       this.deferred.resolve();
     }
 
-    const index = this.invokers.length - 1;
+    this.protocolRegistry.applyTo(connection.io);
 
-    const invoker = new Invoker();
+    const index = this.proxies.length - 1;
+    const proxy = new ProxySumi(this.serviceRegistry, this.logger);
+    proxy.listen(connection);
 
-    const sumiProxy = new ProxySumi(this.registry, this.logger);
-    invoker.attachSumi(sumiProxy);
-    sumiProxy.listen(connection);
-
-    this.invokers.push(invoker);
+    this.proxies.push(proxy);
 
     return {
       dispose: () => {
-        this.invokers.splice(index, 1);
-        invoker.dispose();
+        this.proxies.splice(index, 1);
+        proxy.dispose();
       },
     };
   }
 
   setConnection(connection: MessageConnection) {
-    if (this.invokers.length === 0) {
+    if (this.proxies.length === 0) {
       this.deferred.resolve();
     }
 
-    const index = this.invokers.length - 1;
-
-    const invoker = new Invoker();
+    const index = this.proxies.length - 1;
 
-    const legacyProxy = new ProxyLegacy(this.registry, this.logger);
-    legacyProxy.listen(connection);
+    const proxy = new ProxyJson(this.serviceRegistry, this.logger);
+    proxy.listen(connection);
 
-    invoker.attachLegacy(legacyProxy);
-
-    this.invokers.push(invoker);
+    this.proxies.push(proxy);
 
     return {
       dispose: () => {
-        this.invokers.splice(index, 1);
-        invoker.dispose();
+        this.proxies.splice(index, 1);
+        proxy.dispose();
       },
     };
   }
 
   onRequest(serviceName: string, _name: string, method: RPCServiceMethod) {
-    this.registry.register(getMethodName(serviceName, _name), method);
+    this.serviceRegistry.register(getMethodName(serviceName, _name), method);
   }
 
   onRequestService(serviceName: string, service: any) {
-    this.registry.registerService(service, {
+    this.serviceRegistry.registerService(service, {
       nameConverter: (name) => getMethodName(serviceName, name),
     });
   }
@@ -106,7 +101,7 @@ export class RPCServiceCenter {
     await this.ready();
 
     const name = getMethodName(serviceName, _name);
-    const broadcastResult = await Promise.all(this.invokers.map((proxy) => proxy.invoke(name, ...args)));
+    const broadcastResult = await Promise.all(this.proxies.map((proxy) => proxy.invoke(name, ...args)));
 
     const doubtfulResult = [] as any[];
     const result = [] as any[];
@@ -132,3 +127,14 @@ export class RPCServiceCenter {
     return result.length === 1 ? result[0] : result;
   }
 }
+
+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);
+}

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

@@ -1,15 +1,17 @@
-import { Deferred, isDefined } from '@opensumi/ide-core-common';
+import { Deferred } from '@opensumi/ide-core-common';
 
+import { ICapturedMessage, MessageType, ResponseStatus, getCapturer } from '../../capturer';
 import { ILogger, IRPCServiceMap } from '../../types';
-import { ICapturedMessage, MessageType, ResponseStatus, getCapturer } from '../../utils';
 
-import type { ServiceRegistry } from './registry';
+import type { ServiceRegistry } from '../registry';
 
 interface IBaseConnection {
   listen(): void;
   dispose(): void;
 }
 
+const defaultReservedWordSet = new Set(['then', 'finally']);
+
 let requestId = 0;
 
 export abstract class ProxyBase<T extends IBaseConnection> {
@@ -18,11 +20,14 @@ export abstract class ProxyBase<T extends IBaseConnection> {
 
   protected connectionPromise: Deferred<void> = new Deferred<void>();
 
-  protected abstract engine: 'legacy' | 'sumi';
+  protected abstract engine: 'json' | 'sumi';
+  capturer: (data: any) => void;
 
   constructor(public registry: ServiceRegistry, logger?: ILogger) {
     this.logger = logger || console;
 
+    this.capturer = getCapturer();
+
     this.registry.onServicesUpdate((services) => {
       if (this.connection) {
         this.bindMethods(services);
@@ -32,13 +37,10 @@ export abstract class ProxyBase<T extends IBaseConnection> {
 
   // capture messages for opensumi devtools
   private capture(message: ICapturedMessage): void {
-    const capturer = getCapturer();
-    if (isDefined(capturer)) {
-      capturer({
-        ...message,
-        engine: this.engine,
-      });
-    }
+    this.capturer({
+      ...message,
+      engine: this.engine,
+    });
   }
 
   protected nextRequestId() {
@@ -46,10 +48,16 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   protected captureOnRequest(requestId: string, serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
     this.capture({ type: MessageType.OnRequest, requestId, serviceMethod, arguments: args });
   }
 
   protected captureOnRequestResult(requestId: string, serviceMethod: string, data: any): void {
+    if (!this.capturer) {
+      return;
+    }
     this.capture({
       type: MessageType.OnRequestResult,
       status: ResponseStatus.Success,
@@ -60,6 +68,10 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   protected captureOnRequestFail(requestId: string, serviceMethod: string, error: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
     this.logger.warn(`request exec ${serviceMethod} error`, error);
 
     this.capture({
@@ -72,14 +84,24 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   protected captureOnNotification(serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
     this.capture({ type: MessageType.OnNotification, serviceMethod, arguments: args });
   }
 
   protected captureSendRequest(requestId: string, serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
     this.capture({ type: MessageType.SendRequest, requestId, serviceMethod, arguments: args });
   }
 
   protected captureSendRequestResult(requestId: string, serviceMethod: string, data: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
     this.capture({
       type: MessageType.RequestResult,
       status: ResponseStatus.Success,
@@ -90,6 +112,10 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   protected captureSendRequestFail(requestId: string, serviceMethod: string, error: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
     this.capture({
       type: MessageType.RequestResult,
       status: ResponseStatus.Fail,
@@ -100,6 +126,9 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   protected captureSendNotification(serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
     this.capture({ type: MessageType.SendNotification, serviceMethod, arguments: args });
   }
 
@@ -121,6 +150,24 @@ export abstract class ProxyBase<T extends IBaseConnection> {
     }
   }
 
-  abstract getInvokeProxy<T = any>(): T;
+  public abstract invoke(prop: string, ...args: any[]): Promise<any>;
   protected abstract bindMethods(services: PropertyKey[]): void;
+
+  public getInvokeProxy<T = any>(): T {
+    return new Proxy(Object.create(null), {
+      get: (target: any, p: PropertyKey) => {
+        if (typeof p !== 'string') {
+          return null;
+        }
+        if (defaultReservedWordSet.has(p)) {
+          return Promise.resolve();
+        }
+
+        if (!target[p]) {
+          target[p] = (...args: any[]) => this.invoke(p, ...args);
+        }
+        return target[p];
+      },
+    });
+  }
 }

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

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