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

package/src/common/proxy/runner.ts

@@ -1,58 +0,0 @@
-import { EventEmitter } from '@opensumi/events';
-
-import { IRPCServiceMap, RPCServiceMethod } from '../types';
-import { getServiceMethods } from '../utils';
-
-/**
- * Store all executable services
- */
-export class ServiceRunner {
-  protected emitter = new EventEmitter<{
-    servicesUpdate: [services: string[]];
-  }>();
-
-  private serviceMethodMap = {} as unknown as IRPCServiceMap;
-
-  register(name: string, methodFn: RPCServiceMethod) {
-    this.serviceMethodMap[name] = methodFn;
-    this.emitter.emit('servicesUpdate', [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[methodName] = service[method].bind(service);
-      serviceNames.push(methodName);
-    }
-
-    this.emitter.emit('servicesUpdate', serviceNames);
-  }
-
-  has(name: PropertyKey) {
-    return !!this.serviceMethodMap[name];
-  }
-
-  run(name: PropertyKey, ...args: any[]): any {
-    return this.serviceMethodMap[name](...args);
-  }
-
-  getServices() {
-    return Object.keys(this.serviceMethodMap);
-  }
-
-  onServicesUpdate(cb: (services: string[]) => void) {
-    this.emitter.on('servicesUpdate', cb);
-  }
-}

package/src/common/proxy/sumi.ts

@@ -1,81 +0,0 @@
-import { METHOD_NOT_REGISTERED } from '../constants';
-import { Connection } from '../rpc/connection';
-
-import { ProxyBase } from './base';
-
-export class ProxySumi extends ProxyBase<Connection> {
-  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.runner.run(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.runner.run(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) => {
-        const prop = p.toString();
-        if (!target[prop]) {
-          target[prop] = async (...args: any[]) => {
-            await this.connectionPromise.promise;
-
-            // 调用方法为 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[prop];
-      },
-    });
-  }
-
-  listen(connection: Connection): void {
-    super.listen(connection);
-    connection.onRequestNotFound((method) => {
-      if (!this.runner.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/connection.ts

@@ -1,247 +0,0 @@
-import { EventEmitter } from '@opensumi/events';
-import { DisposableCollection, IDisposable, Disposable, parseError } from '@opensumi/ide-utils';
-
-import { BaseConnection } from '../connection';
-import { METHOD_NOT_REGISTERED } from '../constants';
-
-import {
-  CODEC,
-  ERROR_STATUS,
-  RPC_TYPE,
-  createErrorResponsePacket,
-  createRequestPacket,
-  createResponsePacket,
-  reader,
-} from './packet';
-import { ProtocolRepository } from './protocol-repository';
-import {
-  TGenericNotificationHandler,
-  TGenericRequestHandler,
-  TOnNotificationNotFoundHandler,
-  TOnRequestNotFoundHandler,
-  TRequestCallback,
-} from './types';
-
-function isPromise<T = any>(obj: any): obj is Promise<T> {
-  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
-}
-
-const assert = (condition: any, message: string) => {
-  if (!condition) {
-    throw new Error(message);
-  }
-};
-
-const innerEvents = {
-  onRequestNotFound: '##onRequestNotFound',
-  onNotificationNotFound: '##onNotificationNotFound',
-} as const;
-
-export class Connection implements IDisposable {
-  protected disposable = new DisposableCollection();
-
-  private _binaryEmitter = new EventEmitter<{
-    [key: string]: [requestId: number, headers: Record<string, any>, args: any[]];
-  }>();
-  private _notificationEmitter = new EventEmitter<{
-    [key: string]: [headers: Record<string, any>, args: any[]];
-  }>();
-
-  private _innerEventEmitter = new EventEmitter<{
-    [innerEvents.onNotificationNotFound]: [method: string, headers: Record<string, any>, args: any[]];
-    [innerEvents.onRequestNotFound]: [requestId: number, method: string, headers: Record<string, any>, args: any[]];
-  }>();
-
-  private _requestId = 0;
-  private _callbacks = new Map<number, TRequestCallback>();
-
-  private protocolRepository: ProtocolRepository;
-
-  constructor(private socket: BaseConnection<Uint8Array>) {}
-
-  sendNotification(method: string, ...args: any[]) {
-    if (!this.protocolRepository.has(method)) {
-      throw new MethodProtocolNotFoundError(method);
-    }
-
-    const payload = this.protocolRepository.serializeRequest(method, args);
-    this.socket.send(createRequestPacket(this._requestId++, RPC_TYPE.Notification, method, {}, payload));
-  }
-
-  sendRequest(method: string, ...args: any[]) {
-    return new Promise<any>((resolve, reject) => {
-      this._callbacks.set(this._requestId, (headers, error, buffer) => {
-        if (error) {
-          if (error === METHOD_NOT_REGISTERED) {
-            resolve(error);
-            return;
-          }
-
-          reject(error);
-          return;
-        }
-
-        const result = this.protocolRepository.deserializeResult(method, buffer);
-        resolve(result);
-      });
-
-      if (!this.protocolRepository.has(method)) {
-        throw new MethodProtocolNotFoundError(method);
-      }
-      const payload = this.protocolRepository.serializeRequest(method, args);
-      this.socket.send(createRequestPacket(this._requestId++, RPC_TYPE.Request, method, {}, payload));
-    });
-  }
-
-  onNotification(method: string, handler: TGenericNotificationHandler): IDisposable {
-    const handlerWrapper = (headers: Record<string, any>, args: any[]) => {
-      handler(...args);
-    };
-    return Disposable.create(this._notificationEmitter.on(method, handlerWrapper));
-  }
-
-  onNotificationNotFound(handler: TOnNotificationNotFoundHandler): IDisposable {
-    const handlerWrapper = (method: string, headers: Record<string, any>, args: any[]) => {
-      handler(method, args);
-    };
-    return Disposable.create(this._innerEventEmitter.on(innerEvents.onNotificationNotFound, handlerWrapper));
-  }
-
-  private runRequestHandler<T extends (...args: any[]) => any>(
-    method: string,
-    handler: T,
-    requestId: number,
-    headers: Record<string, any>,
-    args: any[],
-  ) {
-    let result: any;
-    let error: Error | undefined;
-
-    try {
-      result = handler(...args);
-    } catch (err) {
-      error = err;
-    }
-
-    if (error) {
-      this.socket.send(createErrorResponsePacket(requestId, ERROR_STATUS.EXEC_ERROR, {}, error));
-    } else if (isPromise(result)) {
-      result
-        .then((result) => {
-          const payload = this.protocolRepository.serializeResult(method, result);
-          this.socket.send(createResponsePacket(requestId, {}, payload));
-        })
-        .catch((err) => {
-          this.socket.send(createErrorResponsePacket(requestId, ERROR_STATUS.EXEC_ERROR, {}, err));
-        });
-    } else {
-      const payload = this.protocolRepository.serializeResult(method, result);
-      this.socket.send(createResponsePacket(requestId, {}, payload));
-    }
-  }
-
-  onRequest<T = any>(method: string, handler: TGenericRequestHandler<T>): IDisposable {
-    const handlerWrapper = (requestId: number, headers: Record<string, any>, args: any[]) => {
-      this.runRequestHandler(method, handler, requestId, headers, args);
-    };
-    return Disposable.create(this._binaryEmitter.on(method, handlerWrapper));
-  }
-
-  onRequestNotFound(handler: TOnRequestNotFoundHandler): IDisposable {
-    const handlerWrapper = (requestId: number, method: string, headers: Record<string, any>, args: any[]) => {
-      this.runRequestHandler(method, handler, requestId, headers, args);
-    };
-
-    return Disposable.create(this._innerEventEmitter.on(innerEvents.onRequestNotFound, handlerWrapper));
-  }
-
-  setProtocolRepository(protocolRepository: ProtocolRepository) {
-    this.protocolRepository = protocolRepository;
-  }
-
-  listen() {
-    const toDispose = this.socket.onMessage((data) => {
-      reader.reset(data);
-      reader.skip(1);
-
-      const rpcType = reader.uint8();
-      const requestId = reader.uint32();
-      const codec = reader.uint8();
-
-      if (rpcType === RPC_TYPE.Response) {
-        const callback = this._callbacks.get(requestId);
-        if (!callback) {
-          throw new Error(`No callback for request id: ${requestId}`);
-        }
-
-        const status = reader.uint16();
-        const headers = readHeaders();
-
-        // if error code is not 0, it's an error
-        if (status !== ERROR_STATUS.OK) {
-          // 错误信息用 JSON 格式，方便且兼容性好，可恢复成 Error
-          assert(codec === CODEC.JSON, 'Error response should be JSON encoded');
-          const content = reader.stringOfVarUInt32();
-          const error = parseError(content);
-          callback(headers, error);
-          return;
-        }
-
-        if (codec === CODEC.Binary) {
-          const contentLen = reader.varUInt32();
-          const buffer = reader.buffer(contentLen);
-          callback(headers, undefined, buffer);
-          return;
-        }
-
-        const content = reader.stringOfVarUInt32();
-        if (codec === CODEC.JSON) {
-          callback(headers, undefined, JSON.parse(content));
-        } else {
-          callback(headers, undefined, content);
-        }
-      } else if (rpcType === RPC_TYPE.Notification || rpcType === RPC_TYPE.Request) {
-        const method = reader.stringOfVarUInt32();
-        const headers = readHeaders();
-
-        const contentLen = reader.varUInt32();
-        const content = reader.buffer(contentLen);
-        const argsArray = this.protocolRepository.deserializeRequest(method, content);
-
-        if (rpcType === RPC_TYPE.Request) {
-          if (this._binaryEmitter.hasListener(method)) {
-            this._binaryEmitter.emit(method, requestId, headers, argsArray);
-          } else {
-            this._innerEventEmitter.emit(innerEvents.onRequestNotFound, requestId, method, headers, argsArray);
-          }
-        } else {
-          if (this._notificationEmitter.hasListener(method)) {
-            this._notificationEmitter.emit(method, headers, argsArray);
-          } else {
-            this._innerEventEmitter.emit(innerEvents.onNotificationNotFound, method, headers, argsArray);
-          }
-        }
-      } else {
-        throw new Error(`Unknown rpc type: ${rpcType}`);
-      }
-
-      function readHeaders() {
-        const header = reader.stringOfVarUInt32();
-        return JSON.parse(header);
-      }
-    });
-    if (toDispose) {
-      this.disposable.push(toDispose);
-    }
-  }
-
-  dispose(): void {
-    this.disposable.dispose();
-  }
-}
-
-export class MethodProtocolNotFoundError extends Error {
-  constructor(method: string) {
-    super(`method ${method} not found`);
-  }
-}

package/src/common/rpc/index.ts

@@ -1 +0,0 @@
-export * from './types';

package/src/common/rpc/packet.ts

@@ -1,85 +0,0 @@
-import { BinaryReader } from '@furyjs/fury/dist/lib/reader';
-import { BinaryWriter } from '@furyjs/fury/dist/lib/writer';
-
-import { stringifyError } from '@opensumi/ide-core-common/lib/utils';
-
-const PROTO_VERSION = 1;
-
-export enum RPC_TYPE {
-  Handshake,
-  Request,
-  Notification,
-  Response,
-  Heartbeat,
-}
-
-export enum CODEC {
-  Text,
-  Binary,
-  JSON,
-}
-
-export enum ERROR_STATUS {
-  OK,
-  EXEC_ERROR,
-  PARSE_ERROR,
-  SERVER_ERROR,
-}
-
-export const reader = BinaryReader({});
-const writer = BinaryWriter({});
-
-export const createRequestPacket = (
-  requestId: number,
-  rpcType: number,
-  method: string,
-  headers: Record<string, any>,
-  payload: Uint8Array,
-) => {
-  writer.reset();
-
-  writer.uint8(PROTO_VERSION);
-  writer.uint8(rpcType);
-  writer.uint32(requestId);
-  writer.uint8(CODEC.Binary);
-  writer.stringOfVarUInt32(method);
-  writer.stringOfVarUInt32(JSON.stringify(headers));
-  writer.varUInt32(payload.length);
-  writer.buffer(payload);
-
-  return writer.dump();
-};
-
-export const createResponsePacket = (requestId: number, headers: Record<string, any>, payload: Uint8Array) => {
-  writer.reset();
-
-  writer.uint8(PROTO_VERSION);
-  writer.uint8(RPC_TYPE.Response);
-  writer.uint32(requestId);
-  writer.uint8(CODEC.Binary);
-  writer.uint16(ERROR_STATUS.OK);
-  writer.stringOfVarUInt32(JSON.stringify(headers));
-  writer.varUInt32(payload.length);
-  writer.buffer(payload);
-
-  return writer.dump();
-};
-
-export const createErrorResponsePacket = (
-  requestId: number,
-  status: number,
-  headers: Record<string, any>,
-  error: any,
-) => {
-  writer.reset();
-
-  writer.uint8(PROTO_VERSION);
-  writer.uint8(RPC_TYPE.Response);
-  writer.uint32(requestId);
-  writer.uint8(CODEC.JSON);
-  writer.uint16(status);
-  writer.stringOfVarUInt32(JSON.stringify(headers));
-  writer.stringOfVarUInt32(stringifyError(error));
-
-  return writer.dump();
-};

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

@@ -1,148 +0,0 @@
-import Fury, { Type, TypeDescription } from '@furyjs/fury';
-
-import { TSumiProtocol, TSumiProtocolMethod } from './types';
-
-export interface ISerializableRequest {
-  /**
-   * Arguments
-   */
-  a: any[];
-}
-
-export interface ISerializableResult {
-  /**
-   * function execute result
-   */
-  r: any;
-
-  /**
-   * Function Return void or other type that protocol not defined
-   */
-  $?: string;
-}
-
-const createResultProto = (name: string, type?: TypeDescription) => {
-  const props = {
-    $: Type.string(),
-  } as Record<string, TypeDescription>;
-  if (type) {
-    props.r = type;
-  }
-  return Type.object(name, props);
-};
-
-export class ProtocolRepository {
-  fury = new Fury();
-
-  private serializerMap = {} as Record<
-    string,
-    {
-      request: ReturnType<Fury['registerSerializer']>;
-      result: ReturnType<Fury['registerSerializer']>;
-    }
-  >;
-
-  has(name: string) {
-    return !!this.serializerMap[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) {
-    const methodName = methodProtocol.method;
-    const argsTuple = [] as TypeDescription[];
-
-    for (const element of methodProtocol.request) {
-      argsTuple.push(element.type);
-    }
-
-    const requestProto = Type.object(methodName + '^', {
-      a: Type.tuple(argsTuple),
-    });
-
-    const resultProto = createResultProto(methodName + 'v', methodProtocol.response.type);
-
-    this.serializerMap[methodName] = {
-      request: this.fury.registerSerializer(requestProto),
-      result: this.fury.registerSerializer(resultProto),
-    };
-  }
-
-  serializeRequest(name: string, args: any[]): Uint8Array {
-    const newArray = new Array(args.length);
-    for (let i = 0; i < args.length; i++) {
-      newArray[i] = args[i];
-    }
-
-    const payload: ISerializableRequest = {
-      a: newArray,
-    };
-
-    return this.serializerMap[name].request.serialize(payload);
-  }
-
-  deserializeRequest(name: string, buffer: Uint8Array): any[] {
-    const { a: argsArray } = this.serializerMap[name].request.deserialize(buffer) as ISerializableRequest;
-    return argsArray;
-  }
-
-  serializeResult<T = any>(name: string, result: T): Uint8Array {
-    const payload = {
-      r: result,
-    } as ISerializableResult;
-
-    payload.$ = ReturnValueTransfer.replacer(result);
-
-    return this.serializerMap[name].result.serialize(payload);
-  }
-
-  deserializeResult<T = any>(name: string, buffer: Uint8Array): T {
-    const payload = this.serializerMap[name].result.deserialize(buffer) as ISerializableResult;
-
-    if (payload.$) {
-      return ReturnValueTransfer.reviver(payload.$);
-    }
-
-    return payload.r;
-  }
-}
-
-class ReturnValueTransfer {
-  static TypeUndefined = '$undefined';
-
-  static replacer(value: any) {
-    if (typeof value === 'undefined') {
-      return ReturnValueTransfer.TypeUndefined;
-    }
-    return undefined;
-  }
-
-  static reviver(value: any): any {
-    if (value === ReturnValueTransfer.TypeUndefined) {
-      return undefined;
-    }
-
-    throw new Error('Not implemented');
-  }
-}

package/src/common/rpc/types.ts

@@ -1,23 +0,0 @@
-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>;