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

package/src/common/rpc/multiplexer.ts

@@ -0,0 +1,105 @@
+import { BaseConnection } from '../connection';
+
+import { ISumiConnectionOptions, SumiConnection } from './connection';
+
+export class ProxyIdentifier<T = any> {
+  public static count = 0;
+
+  public readonly serviceId: string;
+  public readonly countId: number;
+  constructor(serviceId: string) {
+    this.serviceId = serviceId;
+    this.countId = ++ProxyIdentifier.count;
+  }
+
+  static for(serviceId: string) {
+    return new ProxyIdentifier(serviceId);
+  }
+}
+
+export const IRPCProtocol = Symbol('IRPCProtocol');
+export interface IRPCProtocol {
+  getProxy<T>(proxyId: ProxyIdentifier<T>): T;
+  set<T>(identifier: ProxyIdentifier<T>, instance: T): T;
+  get<T>(identifier: ProxyIdentifier<T>): T;
+}
+
+const SEP = '/';
+
+function getRPCName(serviceId: string, methodName: string) {
+  return `${serviceId}${SEP}${methodName}`;
+}
+
+function extractServiceAndMethod(rpcId: string): [string, string] {
+  const idx = rpcId.indexOf(SEP);
+  return [rpcId.substring(0, idx), rpcId.substring(idx + 1)];
+}
+
+export class SumiConnectionMultiplexer extends SumiConnection implements IRPCProtocol {
+  private readonly _locals: Map<string, any>;
+  private readonly _proxies: Map<string, any>;
+
+  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
+    super(socket, options);
+    this._locals = new Map();
+    this._proxies = new Map();
+
+    this.onRequestNotFound((rpcName: string, args: any[]) => {
+      const [rpcId, methodName] = extractServiceAndMethod(rpcName);
+      return this._doInvokeHandler(rpcId, methodName, args);
+    });
+
+    // call `listen` implicitly
+    // compatible behavior with the RPCProtocol
+    this.listen();
+  }
+
+  public set<T>(identifier: ProxyIdentifier<T>, instance: any) {
+    this._locals.set(identifier.serviceId, instance);
+    return instance;
+  }
+
+  public get<T>(identifier: ProxyIdentifier<T>) {
+    return this._locals.get(identifier.serviceId);
+  }
+
+  public getProxy<T>(proxyId: ProxyIdentifier<T>) {
+    if (!this._proxies.has(proxyId.serviceId)) {
+      this._proxies.set(proxyId.serviceId, this._createProxy(proxyId.serviceId));
+    }
+
+    return this._proxies.get(proxyId.serviceId);
+  }
+
+  private _createProxy(rpcId: string) {
+    const handler = {
+      get: (target: any, name: string) => {
+        if (typeof name === 'symbol') {
+          return null;
+        }
+        // charCodeAt(0) === 36 means starts with $
+        if (!target[name] && name.charCodeAt(0) === 36) {
+          const rpcName = getRPCName(rpcId, name);
+          target[name] = (...args: any[]) => this.sendRequest(rpcName, ...args);
+        }
+
+        return target[name];
+      },
+    };
+
+    return new Proxy(Object.create(null), handler);
+  }
+
+  private async _doInvokeHandler(rpcId: string, methodName: string, args: any[]): Promise<any> {
+    const actor = this._locals.get(rpcId);
+    if (!actor) {
+      throw new Error('Unknown actor ' + rpcId);
+    }
+    const method = await actor[methodName];
+    if (typeof method !== 'function') {
+      throw new Error('Unknown method ' + methodName + ' on actor ' + rpcId);
+    }
+
+    return method.apply(actor, args);
+  }
+}

package/src/common/rpc/packet.ts

@@ -0,0 +1,104 @@
+import { Serializer, Type } from '@furyjs/fury';
+import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
+
+import { stringifyError } from '@opensumi/ide-core-common/lib/utils';
+
+import { furyFactory } from '../fury-extends/shared';
+
+const ProtoVersionV1 = 1;
+
+export enum OperationType {
+  Request,
+  Notification,
+  Response,
+  Heartbeat,
+  Cancel,
+}
+
+export enum BodyCodec {
+  /**
+   * Means no body
+   */
+  None,
+  Text,
+  Binary,
+  JSON,
+}
+
+export enum ErrorCode {
+  OK,
+  Err,
+}
+
+const { fury, reader, writer } = furyFactory();
+export { reader };
+
+const requestHeadersProto = Type.object('headers', {
+  cancelable: Type.bool(),
+});
+
+export interface IRequestHeaders {
+  /**
+   * If set to true, the request can be canceled.
+   *
+   * the server will push a `CancellationToken` to the request arguments.
+   */
+  cancelable?: boolean;
+}
+
+export const requestHeadersSerializer = generateSerializer(fury, requestHeadersProto) as Serializer;
+
+export class MessageIO {
+  static Request(requestId: number, rpcType: number, method: string, headers: IRequestHeaders, payload: Uint8Array) {
+    writer.reset();
+
+    writer.uint8(ProtoVersionV1);
+    writer.uint8(rpcType);
+    writer.uint32(requestId);
+    writer.uint8(BodyCodec.Binary);
+    writer.stringOfVarUInt32(method);
+    requestHeadersSerializer.write(headers);
+    writer.varUInt32(payload.length);
+    writer.buffer(payload);
+
+    return writer.dump();
+  }
+
+  static Cancel(requestId: number) {
+    writer.reset();
+
+    writer.uint8(ProtoVersionV1);
+    writer.uint8(OperationType.Cancel);
+    writer.uint32(requestId);
+    writer.uint8(BodyCodec.None);
+
+    return writer.dump();
+  }
+
+  static Response(requestId: number, headers: Record<string, any>, payload: Uint8Array) {
+    writer.reset();
+
+    writer.uint8(ProtoVersionV1);
+    writer.uint8(OperationType.Response);
+    writer.uint32(requestId);
+    writer.uint8(BodyCodec.Binary);
+    writer.uint16(ErrorCode.OK);
+    writer.varUInt32(payload.length);
+    writer.buffer(payload);
+
+    return writer.dump();
+  }
+
+  static Error(requestId: number, status: number, headers: Record<string, any>, error: any) {
+    writer.reset();
+
+    writer.uint8(ProtoVersionV1);
+    writer.uint8(OperationType.Response);
+    writer.uint32(requestId);
+    writer.uint8(BodyCodec.JSON);
+    writer.uint16(status);
+    writer.stringOfVarUInt32(stringifyError(error));
+
+    return writer.dump();
+  }
+}

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

@@ -0,0 +1,180 @@
+import Fury, { Type, TypeDescription } from '@furyjs/fury';
+
+import { anySerializer } from '../fury-extends/any';
+
+import { TSumiProtocol, TSumiProtocolMethod } from './types';
+
+export type TRequestTransferable = ITransferable[];
+
+export interface ITransferable {
+  /**
+   * transfer raw value
+   */
+  r: any;
+
+  /**
+   * value that cannot be transferred, use string instead
+   */
+  $?: string;
+}
+
+type TSerializer = ReturnType<Fury['registerSerializer']>;
+
+interface IProtocolProcessor {
+  serializeRequest(args: any[]): Uint8Array;
+  deserializeRequest(buffer: Uint8Array): any[];
+  serializeResult<T = any>(result: T): Uint8Array;
+  deserializeResult<T = any>(buffer: Uint8Array): T;
+}
+
+const createTransferable = (name: string, type?: TypeDescription) => {
+  const props = {
+    $: Type.string(),
+  } as Record<string, TypeDescription>;
+  if (type) {
+    props.r = type;
+  }
+  return Type.object(name, props);
+};
+
+class SumiProtocolProcessor implements IProtocolProcessor {
+  request: TSerializer;
+  result: TSerializer;
+  requestArgsLength: number;
+
+  constructor(methodProtocol: TSumiProtocolMethod, public fury: Fury) {
+    const methodName = methodProtocol.method;
+
+    const argsTuple = [] as TypeDescription[];
+
+    for (const element of methodProtocol.request) {
+      argsTuple.push(createTransferable(methodName + '^' + element.name, element.type));
+    }
+
+    const requestProto = Type.tuple(argsTuple);
+    const resultProto = createTransferable(methodName + 'v', methodProtocol.response.type);
+
+    this.requestArgsLength = argsTuple.length;
+
+    this.request = this.fury.registerSerializer(requestProto);
+    this.result = this.fury.registerSerializer(resultProto);
+  }
+
+  serializeRequest(args: any[]): Uint8Array {
+    const newArray: TRequestTransferable = new Array(args.length);
+    for (let i = 0; i < args.length; i++) {
+      newArray[i] = ObjectTransfer.replacer(args[i]);
+    }
+
+    return this.request.serialize(newArray);
+  }
+
+  deserializeRequest(buffer: Uint8Array): any[] {
+    const result = new Array(this.requestArgsLength);
+    const argsArray = this.request.deserialize(buffer) as TRequestTransferable;
+    for (let i = 0; i < this.requestArgsLength; i++) {
+      result[i] = ObjectTransfer.reviver(argsArray[i]);
+    }
+    return result;
+  }
+
+  serializeResult<T = any>(result: T): Uint8Array {
+    return this.result.serialize(ObjectTransfer.replacer(result));
+  }
+
+  deserializeResult<T = any>(buffer: Uint8Array): T {
+    const payload = this.result.deserialize(buffer) as ITransferable;
+    return ObjectTransfer.reviver(payload);
+  }
+}
+
+class AnyProtocolProcessor implements IProtocolProcessor {
+  serializeRequest(args: any[]): Uint8Array {
+    return anySerializer.serialize(args);
+  }
+
+  deserializeRequest(buffer: Uint8Array): any[] {
+    return anySerializer.deserialize(buffer);
+  }
+
+  serializeResult<T = any>(result: T): Uint8Array {
+    return anySerializer.serialize(result);
+  }
+
+  deserializeResult<T = any>(buffer: Uint8Array): T {
+    return anySerializer.deserialize(buffer);
+  }
+}
+
+export class ProtocolRepository {
+  fury = new Fury();
+
+  private processorMap = new Map<string, SumiProtocolProcessor>();
+
+  private anyProcessor = new AnyProtocolProcessor();
+
+  has(name: string) {
+    return this.processorMap.has(name);
+  }
+
+  loadProtocol(
+    protocol: TSumiProtocol,
+    options?: {
+      nameConverter?: (str: string) => string;
+    },
+  ) {
+    const { methods } = protocol;
+
+    for (const proto of methods) {
+      let method = proto.method;
+      if (options?.nameConverter) {
+        method = options.nameConverter(method);
+      }
+
+      const copy = {
+        ...proto,
+        method,
+      };
+
+      this.loadProtocolMethod(copy);
+    }
+  }
+
+  loadProtocolMethod(methodProtocol: TSumiProtocolMethod) {
+    this.processorMap.set(methodProtocol.method, new SumiProtocolProcessor(methodProtocol, this.fury));
+  }
+
+  getProcessor(method: string): IProtocolProcessor {
+    const processor = this.processorMap.get(method);
+    if (processor) {
+      return processor;
+    }
+    return this.anyProcessor;
+  }
+}
+
+class ObjectTransfer {
+  static TypeUndefined = '$undefined';
+
+  static replacer(value: any) {
+    const payload = {} as ITransferable;
+
+    if (typeof value === 'undefined') {
+      payload.$ = ObjectTransfer.TypeUndefined;
+    }
+
+    if (!payload.$) {
+      payload.r = value;
+    }
+
+    return payload;
+  }
+
+  static reviver(transferable: ITransferable): any {
+    if (transferable.$ === ObjectTransfer.TypeUndefined) {
+      return undefined;
+    }
+
+    return transferable.r;
+  }
+}

package/src/common/rpc/types.ts

@@ -0,0 +1,23 @@
+import { TypeDescription } from '@furyjs/fury';
+
+import {
+  RPCProtocol as _RPCProtocol,
+  RPCProtocolMethod as _RPCProtocolMethod,
+  Request as _Request,
+  Response as _Response,
+} from '@opensumi/ide-core-common/lib/types/rpc';
+
+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 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>;

package/src/common/rpc/utils.ts

@@ -0,0 +1,5 @@
+export const assert = (condition: any, message: string) => {
+  if (!condition) {
+    throw new Error(message);
+  }
+};

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

@@ -1,43 +1,25 @@
 import { Deferred } from '@opensumi/ide-core-common';
+import { MessageConnection } from '@opensumi/vscode-jsonrpc';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
-import { ProxyLegacy } from '../proxy';
-import { IBench, ILogger, IRPCServiceMap, RPCServiceMethod, ServiceType } from '../types';
+import { TSumiProtocol, ProtocolRepository } from '../rpc';
+import { SumiConnection } from '../rpc/connection';
+import { IBench, ILogger, 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);
+import { ServiceRegistry, Invoker, ProxyLegacy, ProxySumi } from './proxy';
 
-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);
-  }
-}
+const safeProcess: { pid: string } = typeof process === 'undefined' ? { pid: 'unknown' } : (process as any);
 
 export class RPCServiceCenter {
   public uid: string;
 
   private invokers: Invoker[] = [];
-  private connection: Array<WSChannel> = [];
 
-  private serviceMethodMap = { client: undefined } as unknown as IRPCServiceMap;
+  private protocolRepository = new ProtocolRepository();
+  private registry = new ServiceRegistry();
 
-  private connectionDeferred = new Deferred<void>();
+  private deferred = new Deferred<void>();
   private logger: ILogger;
 
   constructor(private bench?: IBench, logger?: ILogger) {
@@ -54,47 +36,75 @@ export class RPCServiceCenter {
   }
 
   ready() {
-    return this.connectionDeferred.promise;
+    return this.deferred.promise;
+  }
+
+  loadProtocol(protocol: TSumiProtocol) {
+    this.protocolRepository.loadProtocol(protocol, {
+      nameConverter: (name) => getMethodName(protocol.name, name),
+    });
   }
 
-  setChannel(channel: WSChannel) {
-    if (!this.connection.length) {
-      this.connectionDeferred.resolve();
+  setSumiConnection(connection: SumiConnection) {
+    if (this.invokers.length === 0) {
+      this.deferred.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 index = this.invokers.length - 1;
 
     const invoker = new Invoker();
 
-    invoker.setLegacyProxy(rpcProxy);
+    const sumiProxy = new ProxySumi(this.registry, this.logger);
+    invoker.attachSumi(sumiProxy);
+    sumiProxy.listen(connection);
 
     this.invokers.push(invoker);
 
     return {
       dispose: () => {
-        this.connection.splice(index, 1);
         this.invokers.splice(index, 1);
-        connection.dispose();
+        invoker.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 });
-      });
+  setConnection(connection: MessageConnection) {
+    if (this.invokers.length === 0) {
+      this.deferred.resolve();
     }
+
+    const index = this.invokers.length - 1;
+
+    const invoker = new Invoker();
+
+    const legacyProxy = new ProxyLegacy(this.registry, this.logger);
+    legacyProxy.listen(connection);
+
+    invoker.attachLegacy(legacyProxy);
+
+    this.invokers.push(invoker);
+
+    return {
+      dispose: () => {
+        this.invokers.splice(index, 1);
+        invoker.dispose();
+      },
+    };
+  }
+
+  onRequest(serviceName: string, _name: string, method: RPCServiceMethod) {
+    this.registry.register(getMethodName(serviceName, _name), method);
+  }
+
+  onRequestService(serviceName: string, service: any) {
+    this.registry.registerService(service, {
+      nameConverter: (name) => getMethodName(serviceName, name),
+    });
   }
 
   async broadcast(serviceName: string, _name: string, ...args: any[]): Promise<any> {
+    await this.ready();
+
     const name = getMethodName(serviceName, _name);
     const broadcastResult = await Promise.all(this.invokers.map((proxy) => proxy.invoke(name, ...args)));
 
@@ -117,8 +127,8 @@ export class RPCServiceCenter {
     }
 
     // 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`.
+    // 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

@@ -1,2 +1,11 @@
 export * from './stub';
 export * from './center';
+
+export abstract class RPCService<T = any> {
+  rpcClient?: T[];
+  rpcRegistered?: boolean;
+  register?(): () => Promise<T>;
+  get client() {
+    return this.rpcClient ? this.rpcClient[0] : undefined;
+  }
+}