@opensumi/ide-connection 2.21.8-rc-1670567192.0 → 2.21.8

package/src/common/proxy.ts

@@ -1,303 +0,0 @@
-import { ApplicationError, uuid } from '@opensumi/ide-core-common';
-import type { MessageConnection } from '@opensumi/vscode-jsonrpc/lib/common/connection';
-
-import { MessageType, ResponseStatus, ICapturedMessage, getCapturer } from './utils';
-
-export abstract class RPCService<T = any> {
-  rpcClient?: T[];
-  rpcRegistered?: boolean;
-  register?(): () => Promise<T>;
-  get client() {
-    return this.rpcClient ? this.rpcClient[0] : undefined;
-  }
-}
-
-export const NOTREGISTERMETHOD = '$$NOTREGISTERMETHOD';
-
-export class ProxyClient {
-  public proxy: any;
-  public reservedWords: string[];
-
-  constructor(proxy: any, reservedWords = ['then']) {
-    this.proxy = proxy;
-    this.reservedWords = reservedWords;
-  }
-  public getClient() {
-    return new Proxy(
-      {},
-      {
-        get: (target, prop: string | symbol) => {
-          if (this.reservedWords.includes(prop as string) || typeof prop === 'symbol') {
-            return Promise.resolve();
-          } else {
-            return this.proxy[prop];
-          }
-        },
-      },
-    );
-  }
-}
-
-interface IRPCResult {
-  error?: ApplicationError<number, any>;
-  data: any;
-}
-export class RPCProxy {
-  private connectionPromise: Promise<MessageConnection>;
-  private connectionPromiseResolve: (connection: MessageConnection) => void;
-  private connection: MessageConnection;
-  private proxyService: any = {};
-  private logger: any;
-  // capture messages for opensumi devtools
-  private capture(message: ICapturedMessage): void {
-    const capturer = getCapturer();
-    if (capturer !== undefined) {
-      capturer(message);
-    }
-  }
-
-  constructor(public target?: RPCService, logger?: any) {
-    this.waitForConnection();
-    this.logger = logger || console;
-  }
-  public listenService(service) {
-    if (this.connection) {
-      const proxyService = this.proxyService;
-      this.bindOnRequest(service, (service, prop) => {
-        proxyService[prop] = service[prop].bind(service);
-      });
-    } else {
-      const target = this.target || {};
-      const methods = this.getServiceMethod(service);
-      methods.forEach((method) => {
-        target[method] = service[method].bind(service);
-      });
-    }
-  }
-
-  public listen(connection: MessageConnection) {
-    this.connection = connection;
-
-    if (this.target) {
-      this.listenService(this.target);
-    }
-    this.connectionPromiseResolve(connection);
-    connection.listen();
-  }
-
-  public createProxy(): any {
-    const proxy = new Proxy(this, this);
-
-    const proxyClient = new ProxyClient(proxy);
-    return proxyClient.getClient();
-  }
-  public get(target: any, p: PropertyKey) {
-    const prop = p.toString();
-
-    return (...args: any[]) =>
-      this.connectionPromise.then((connection) => {
-        connection = this.connection || connection;
-        return new Promise((resolve, reject) => {
-          try {
-            let isSingleArray = false;
-            if (args.length === 1 && Array.isArray(args[0])) {
-              isSingleArray = true;
-            }
-            // 调用方法为 on 开头时，作为单项通知
-            if (prop.startsWith('on')) {
-              if (isSingleArray) {
-                connection.sendNotification(prop, [...args]);
-                this.capture({ type: MessageType.SendNotification, serviceMethod: prop, arguments: args });
-              } else {
-                connection.sendNotification(prop, ...args);
-                this.capture({ type: MessageType.SendNotification, serviceMethod: prop, arguments: args });
-              }
-
-              resolve(null);
-            } else {
-              let requestResult: Promise<any>;
-              // generate a unique requestId to associate request and requestResult
-              const requestId = uuid();
-
-              if (isSingleArray) {
-                requestResult = connection.sendRequest(prop, [...args]) as Promise<any>;
-                this.capture({ type: MessageType.SendRequest, requestId, serviceMethod: prop, arguments: args });
-              } else {
-                requestResult = connection.sendRequest(prop, ...args) as Promise<any>;
-                this.capture({ type: MessageType.SendRequest, requestId, serviceMethod: prop, arguments: args });
-              }
-
-              requestResult
-                .catch((err) => {
-                  reject(err);
-                })
-                .then((result: IRPCResult) => {
-                  if (result.error) {
-                    const error = new Error(result.data.message);
-                    if (result.data.stack) {
-                      error.stack = result.data.stack;
-                    }
-                    if (result.error.code && result.error.data) {
-                      // 经过通信，applicationError 实例的构造类信息丢失了，使用 fromJson 恢复
-                      const applicationError = ApplicationError.fromJson(result.error.code, result.error.data);
-                      error.cause = applicationError;
-                    }
-                    this.capture({
-                      type: MessageType.RequestResult,
-                      status: ResponseStatus.Fail,
-                      requestId,
-                      serviceMethod: prop,
-                      error: result.data,
-                    });
-                    reject(error);
-                  } else {
-                    this.capture({
-                      type: MessageType.RequestResult,
-                      status: ResponseStatus.Success,
-                      requestId,
-                      serviceMethod: prop,
-                      data: result.data,
-                    });
-                    resolve(result.data);
-                  }
-                });
-            }
-          } catch (e) {}
-        });
-      });
-  }
-  private getServiceMethod(service): 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;
-  }
-  private bindOnRequest(service, cb?) {
-    if (this.connection) {
-      const connection = this.connection;
-
-      const methods = this.getServiceMethod(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);
-        }
-      });
-
-      connection.onRequest((method) => {
-        if (!this.proxyService[method]) {
-          const requestId = uuid();
-          this.capture({ type: MessageType.OnRequest, requestId, serviceMethod: method });
-          const result = {
-            data: NOTREGISTERMETHOD,
-          };
-          this.capture({
-            type: MessageType.OnRequestResult,
-            status: ResponseStatus.Fail,
-            requestId,
-            serviceMethod: method,
-            error: result.data,
-          });
-          return result;
-        }
-      });
-    }
-  }
-
-  private waitForConnection() {
-    this.connectionPromise = new Promise((resolve) => {
-      this.connectionPromiseResolve = resolve;
-    });
-  }
-
-  /**
-   * 对于纯数组参数的情况，收到请求/通知后做展开操作
-   * 因为在通信层会为每个 rpc 调用添加一个 CancellationToken 参数
-   * 如果参数本身是数组, 在方法中如果使用 spread 运算符获取参数(...args)，则会出现 [...args, MutableToken] 这种情况
-   * 所以发送请求时将这类参数统一再用数组包了一层，形如 [[...args]], 参考 {@link RPCProxy.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]) && maybeCancellationToken.hasOwnProperty('_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 {
-        data: result,
-      };
-    } catch (e) {
-      return {
-        error: e,
-        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);
-    }
-  }
-}

package/src/common/rpcProtocol.ts

@@ -1,377 +0,0 @@
-import { CancellationToken, CancellationTokenSource, Deferred, Event, Uri } from '@opensumi/ide-core-common';
-// Uri: vscode 中的 uri
-// URI: 在 vscode 中的 uri 基础上包装了一些基础方法
-
-export enum RPCProtocolEnv {
-  MAIN,
-  EXT,
-}
-
-export interface SerializedError {
-  readonly $isError: true;
-  readonly name: string;
-  readonly message: string;
-  readonly stack: string;
-}
-
-export function transformErrorForSerialization(error: Error): SerializedError;
-export function transformErrorForSerialization(error: any): any;
-export function transformErrorForSerialization(error: any): any {
-  if (error instanceof Error) {
-    const { name, message } = error;
-    const stack: string = (error as any).stacktrace || (error as any).stack;
-    return {
-      $isError: true,
-      name,
-      message,
-      stack,
-    };
-  }
-
-  return error;
-}
-
-export interface IProxyIdentifier {
-  serviceId: string;
-  countId: number;
-}
-
-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;
-  }
-}
-
-export function createExtHostContextProxyIdentifier<T>(serviceId: string): ProxyIdentifier<T> {
-  const identifier = new ProxyIdentifier<T>(serviceId);
-  return identifier;
-}
-export function createMainContextProxyIdentifier<T>(identifier: string): ProxyIdentifier<T> {
-  const result = new ProxyIdentifier<T>(identifier);
-  return result;
-}
-export interface IMessagePassingProtocol {
-  send(msg): void;
-  onMessage: Event<string>;
-}
-
-const enum MessageType {
-  Request = 1,
-  Reply = 2,
-  ReplyErr = 3,
-  Cancel = 4,
-}
-
-interface RequestMessage {
-  type: MessageType.Request;
-  id: string;
-  proxyId: string;
-  method: string;
-  args: any[];
-}
-interface CancelMessage {
-  type: MessageType.Cancel;
-  id: string;
-}
-
-interface ReplyMessage {
-  type: MessageType.Reply;
-  id: string;
-  res: any;
-}
-
-interface ErrorMessage {
-  type: MessageType.Cancel;
-  id: string;
-  res: SerializedError;
-}
-
-export namespace ObjectTransfer {
-  export function replacer(key: string | undefined, value: any) {
-    if (value) {
-      if (value.$mid === 1) {
-        const uri = Uri.revive(value);
-        return {
-          $type: 'VSCODE_URI',
-          data: uri.toString(),
-        };
-      } else if (value instanceof Uint8Array || value instanceof Uint32Array || value instanceof Uint16Array) {
-        return {
-          $type: 'Buffer',
-          data: Array.from(value),
-        };
-      } else if (value instanceof ArrayBuffer) {
-        return {
-          $type: 'Buffer',
-          data: Array.from(new Uint8Array(value)),
-        };
-      }
-    }
-
-    return value;
-  }
-  export function reviver(key: string | undefined, value: any) {
-    if (value && value.$type !== undefined && value.data !== undefined) {
-      if (value.$type === 'VSCODE_URI') {
-        return Uri.parse(value.data);
-      }
-      if (value.$type === 'Buffer') {
-        return Uint8Array.from(value.data);
-      }
-    }
-    return value;
-  }
-}
-
-export class MessageIO {
-  public static cancel(req: string, messageToSendHostId?: string): string {
-    return `{"type":${MessageType.Cancel},"id":"${req}"}`;
-  }
-
-  public static serializeRequest(callId: string, rpcId: string, method: string, args: any[]): string {
-    args = args.map((arg) => {
-      if (arg instanceof Error) {
-        // 处理 Error 类型的参数
-        // eslint-disable-next-line prefer-rest-params
-        const array = Array.prototype.slice.call(arguments) as any[];
-        array[0] = arg.stack;
-        return array.join('\n');
-      }
-      return arg;
-    });
-
-    return `{"type": ${
-      MessageType.Request
-    }, "id": "${callId}", "proxyId": "${rpcId}", "method": "${method}", "args": ${JSON.stringify(
-      args,
-      ObjectTransfer.replacer,
-    )}}`;
-  }
-  public static serializeReplyOK(callId: string, res: any, logger?: any): string {
-    if (typeof res === 'undefined') {
-      return `{"type": ${MessageType.Reply}, "id": "${callId}"}`;
-    } else {
-      try {
-        return `{"type": ${MessageType.Reply}, "id": "${callId}", "res": ${JSON.stringify(
-          res,
-          ObjectTransfer.replacer,
-        )}}`;
-      } catch (e) {
-        if (logger) {
-          logger.warn('res', res);
-        }
-        return `{"type": ${MessageType.Reply}, "id": "${callId}", "res": {}}`;
-      }
-    }
-  }
-  public static serializeReplyError(callId: string, error: Error, logger?: any): string {
-    try {
-      return `{"type": ${MessageType.ReplyErr}, "id": "${callId}", "res": ${JSON.stringify(
-        transformErrorForSerialization(error),
-        ObjectTransfer.replacer,
-      )}}`;
-    } catch (e) {
-      if (logger) {
-        logger.error('error', error);
-      }
-      return `{"type": ${MessageType.ReplyErr}, "id": "${callId}", "res": {}}`;
-    }
-  }
-}
-
-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;
-}
-
-function canceled(): Error {
-  const error = new Error('Canceled');
-  error.name = error.message;
-  return error;
-}
-
-export class RPCProtocol implements IRPCProtocol {
-  private readonly _protocol: IMessagePassingProtocol;
-  private readonly _locals: Map<string, any>;
-  private readonly _proxies: Map<string, any>;
-  private readonly _cancellationTokenSources: Map<string, CancellationTokenSource>;
-  private _lastMessageId: number;
-  private _pendingRPCReplies: Map<string, Deferred<any>>;
-  private logger;
-
-  constructor(connection: IMessagePassingProtocol, logger?: any) {
-    this._protocol = connection;
-    this._locals = new Map();
-    this._proxies = new Map();
-    this._pendingRPCReplies = new Map();
-    this._cancellationTokenSources = new Map();
-
-    this._lastMessageId = 0;
-    this.logger = logger || console;
-    this._protocol.onMessage((msg) => this._receiveOneMessage(msg));
-  }
-
-  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;
-        }
-        if (!target[name] && name.charCodeAt(0) === 36) {
-          target[name] = (...myArgs: any[]) => this._remoteCall(rpcId, name, myArgs);
-        }
-
-        return target[name];
-      },
-    };
-
-    return new Proxy(Object.create(null), handler);
-  }
-
-  private _remoteCall(rpcId: string, methodName: string, args: any[]): Promise<any> {
-    const cancellationToken: CancellationToken | undefined =
-      args.length && CancellationToken.isCancellationToken(args[args.length - 1]) ? args.pop() : undefined;
-    if (cancellationToken && cancellationToken.isCancellationRequested) {
-      return Promise.reject(canceled());
-    }
-
-    const callId = String(++this._lastMessageId);
-    const result = new Deferred();
-
-    if (cancellationToken) {
-      args.push('add.cancellation.token');
-      cancellationToken.onCancellationRequested(() => this._protocol.send(MessageIO.cancel(callId)));
-    }
-    this._pendingRPCReplies.set(callId, result);
-    const msg = MessageIO.serializeRequest(callId, rpcId, methodName, args);
-
-    this._protocol.send(msg);
-    return result.promise;
-  }
-
-  private _receiveOneMessage(rawmsg: string): void {
-    const msg = JSON.parse(rawmsg, ObjectTransfer.reviver);
-    switch (msg.type) {
-      case MessageType.Request:
-        this._receiveRequest(msg);
-        break;
-      case MessageType.Reply:
-        this._receiveReply(msg);
-        break;
-      case MessageType.Cancel:
-        this._receiveCancel(msg);
-        break;
-      case MessageType.ReplyErr:
-        this._receiveError(msg);
-        break;
-    }
-  }
-  private _receiveCancel(msg: CancelMessage) {
-    const cancellationTokenSource = this._cancellationTokenSources.get(msg.id);
-    if (cancellationTokenSource) {
-      cancellationTokenSource.cancel();
-    }
-  }
-
-  private _receiveError(msg: ErrorMessage) {
-    const callId = msg.id;
-    if (!this._pendingRPCReplies.has(callId)) {
-      return;
-    }
-
-    const pendingReply = this._pendingRPCReplies.get(callId) as Deferred<any>;
-    this._pendingRPCReplies.delete(callId);
-
-    let err: any;
-    if (msg.res) {
-      if (msg.res.$isError) {
-        err = new Error();
-        err.name = msg.res.name;
-        err.message = msg.res.message;
-        err.stack = msg.res.stack;
-      } else {
-        err = msg.res;
-      }
-    }
-    pendingReply.reject(err);
-  }
-
-  private _receiveRequest(msg: RequestMessage): void {
-    const callId = msg.id;
-    const rpcId = msg.proxyId;
-    const method = msg.method;
-    const args = msg.args.map((arg) => (arg === null ? undefined : arg));
-
-    const addToken = args.length && args[args.length - 1] === 'add.cancellation.token' ? args.pop() : false;
-    if (addToken) {
-      const tokenSource = new CancellationTokenSource();
-      this._cancellationTokenSources.set(callId, tokenSource);
-      args.push(tokenSource.token);
-    }
-
-    const promise = this._invokeHandler(rpcId, method, args);
-    promise
-      .then((r) => {
-        this._protocol.send(MessageIO.serializeReplyOK(callId, r));
-        this._cancellationTokenSources.delete(callId);
-      })
-      .catch((err) => {
-        this._protocol.send(MessageIO.serializeReplyError(callId, err));
-        this._cancellationTokenSources.delete(callId);
-      });
-  }
-  private _invokeHandler(rpcId: string, methodName: string, args: any[]) {
-    try {
-      return this._doInvokeHandler(rpcId, methodName, args);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-  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);
-  }
-  private _receiveReply(msg: ReplyMessage) {
-    const callId = msg.id;
-    if (!this._pendingRPCReplies.has(callId)) {
-      return;
-    }
-
-    const pendingReply = this._pendingRPCReplies.get(callId) as Deferred<any>;
-    this._pendingRPCReplies.delete(callId);
-
-    pendingReply.resolve(msg.res);
-  }
-}