@opensumi/ide-connection 2.21.13 → 2.22.0

package/src/common/connect.ts

@@ -0,0 +1,199 @@
+import { MessageConnection } from '@opensumi/vscode-jsonrpc/lib/common/connection';
+
+import { RPCProxy, NOTREGISTERMETHOD } from './proxy';
+
+export type RPCServiceMethod = (...args: any[]) => any;
+export type ServiceProxy = any;
+
+export enum ServiceType {
+  Service,
+  Stub,
+}
+
+export class RPCServiceStub {
+  constructor(private serviceName: string, private center, private type: ServiceType) {
+    if (this.type === ServiceType.Service) {
+      this.center.registerService(serviceName, this.type);
+    }
+  }
+
+  async ready() {
+    return this.center.when();
+  }
+  getNotificationName(name: string) {
+    return `on:${this.serviceName}:${name}`;
+  }
+  getRequestName(name: string) {
+    return `${this.serviceName}:${name}`;
+  }
+  // 服务方
+  on(name: string, method: RPCServiceMethod) {
+    this.onRequest(name, method);
+  }
+  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;
+  }
+  onRequestService(service: any) {
+    const methods = this.getServiceMethod(service);
+    for (const method of methods) {
+      this.onRequest(method, service[method].bind(service));
+    }
+  }
+
+  onRequest(name: string, method: RPCServiceMethod) {
+    this.center.onRequest(this.getMethodName(name), method);
+  }
+  broadcast(name: string, ...args) {
+    return this.center.broadcast(this.getMethodName(name), ...args);
+  }
+
+  getMethodName(name: string) {
+    return name.startsWith('on') ? this.getNotificationName(name) : this.getRequestName(name);
+  }
+  getProxy = <T>() =>
+    new Proxy<RPCServiceStub & T>(this as any, {
+      // 调用方
+      get: (target, prop: string) => {
+        if (!target[prop]) {
+          if (typeof prop === 'symbol') {
+            return Promise.resolve();
+          } else {
+            return (...args) =>
+              this.ready().then(() => {
+                const name = this.getMethodName(prop);
+                return Promise.all(this.center.serviceProxy.map((proxy) => proxy[name](...args)))
+                  .then((result) => result.filter((res) => res !== NOTREGISTERMETHOD))
+                  .then((result) => (result.length === 1 ? result[0] : result));
+              });
+          }
+        } else {
+          return target[prop];
+        }
+      },
+    });
+}
+
+export function initRPCService<T = void>(center: RPCServiceCenter) {
+  return {
+    createRPCService: (name: string, service?: any) => {
+      const proxy = new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
+      if (service) {
+        proxy.onRequestService(service);
+      }
+
+      return proxy;
+    },
+    getRPCService: (name: string) => new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>(),
+  };
+}
+
+interface IBench {
+  registerService: (service: string) => void;
+}
+
+export interface RPCMessageConnection extends MessageConnection {
+  uid?: string;
+  writer?: any;
+  reader?: any;
+}
+
+export function createRPCService<T = void>(name: string, center: RPCServiceCenter): any {
+  return new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
+}
+
+export function getRPCService<T = void>(name: string, center: RPCServiceCenter): any {
+  return new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>();
+}
+
+export class RPCServiceCenter {
+  public uid: string;
+  public rpcProxy: RPCProxy[] = [];
+  public serviceProxy: ServiceProxy[] = [];
+  private connection: Array<MessageConnection> = [];
+  private serviceMethodMap = { client: undefined };
+
+  private createService: string[] = [];
+  private getService: string[] = [];
+
+  private connectionPromise: Promise<void>;
+  private connectionPromiseResolve: () => void;
+  private logger;
+
+  constructor(private bench?: IBench, logger?: any) {
+    this.uid = 'RPCServiceCenter:' + process.pid;
+    this.connectionPromise = new Promise((resolve) => {
+      this.connectionPromiseResolve = resolve;
+    });
+    this.logger = logger || console;
+  }
+
+  registerService(serviceName: string, type: ServiceType): void {
+    if (type === ServiceType.Service) {
+      this.createService.push(serviceName);
+      if (this.bench) {
+        this.bench.registerService(serviceName);
+      }
+    } else if (type === ServiceType.Stub) {
+      this.getService.push(serviceName);
+    }
+  }
+
+  when() {
+    return this.connectionPromise;
+  }
+
+  setConnection(connection: MessageConnection) {
+    if (!this.connection.length) {
+      this.connectionPromiseResolve();
+    }
+    this.connection.push(connection);
+
+    const rpcProxy = new RPCProxy(this.serviceMethodMap, this.logger);
+    rpcProxy.listen(connection);
+    this.rpcProxy.push(rpcProxy);
+
+    const serviceProxy = rpcProxy.createProxy();
+    this.serviceProxy.push(serviceProxy);
+  }
+
+  removeConnection(connection: MessageConnection) {
+    const removeIndex = this.connection.indexOf(connection);
+    if (removeIndex !== -1) {
+      this.connection.splice(removeIndex, 1);
+      this.rpcProxy.splice(removeIndex, 1);
+      this.serviceProxy.splice(removeIndex, 1);
+    }
+
+    return removeIndex !== -1;
+  }
+  onRequest(name, method: RPCServiceMethod) {
+    if (!this.connection.length) {
+      this.serviceMethodMap[name] = method;
+    } else {
+      this.rpcProxy.forEach((proxy) => {
+        proxy.listenService({ [name]: method });
+      });
+    }
+  }
+  broadcast(name, ...args): Promise<any> {
+    return Promise.all(this.serviceProxy.map((proxy) => proxy[name](...args)) as Promise<any>[])
+      .then((result) => result.filter((res) => res !== NOTREGISTERMETHOD))
+      .then((result) => (result.length === 1 ? result[0] : result));
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,6 @@
+export * from './message';
+export * from './proxy';
+export * from './rpcProtocol';
+export * from './utils';
+export * from './ws-channel';
+export * from './connect';

package/src/common/message.ts

@@ -0,0 +1,93 @@
+import {
+  AbstractMessageReader,
+  AbstractMessageWriter,
+  createMessageConnection,
+} from '@opensumi/vscode-jsonrpc/lib/common/api';
+import { Disposable } from '@opensumi/vscode-jsonrpc/lib/common/disposable';
+import { MessageReader, DataCallback } from '@opensumi/vscode-jsonrpc/lib/common/messageReader';
+import { MessageWriter } from '@opensumi/vscode-jsonrpc/lib/common/messageWriter';
+/**
+ * FIXME: 由于 `createMessageConnection` 方法隐式依赖了 `@opensumi/vscode-jsonrpc/lib/browser/main` 或 `@opensumi/vscode-jsonrpc/lib/node/main`
+ * 的 `RIL.install()` 初始化代码，而 `browser/main` 中仅支持浏览器使用，
+ * 故需要保证提前引入或执行一次 `@opensumi/vscode-jsonrpc/lib/node/main` 代码才能保证逻辑正常执行
+ */
+import '@opensumi/vscode-jsonrpc/lib/node/main';
+
+export class WebSocketMessageReader extends AbstractMessageReader implements MessageReader {
+  protected state: 'initial' | 'listening' | 'closed' = 'initial';
+  protected callback: DataCallback | undefined;
+  protected events: { message?: any; error?: any }[] = [];
+
+  constructor(protected readonly socket) {
+    super();
+    if (this.socket.onMessage) {
+      this.socket.onMessage((message) => {
+        this.readMessage(message);
+      });
+    } else if (this.socket.onmessage) {
+      this.socket.onmessage = (message) => {
+        this.readMessage(message);
+      };
+    } else if (this.socket.on) {
+      this.socket.on('message', (message) => {
+        this.readMessage(message);
+      });
+    }
+  }
+
+  public listen(callback: DataCallback): Disposable {
+    if (this.state === 'initial') {
+      this.state = 'listening';
+      this.callback = callback;
+    }
+
+    while (this.events.length !== 0) {
+      const event = this.events.pop()!;
+      if (event.message) {
+        this.readMessage(event.message);
+      }
+    }
+
+    return Disposable.create(() => {
+      this.state = 'closed';
+      this.callback = undefined;
+      this.events = [];
+    });
+  }
+
+  protected readMessage(message) {
+    if (this.state === 'initial') {
+      this.events.splice(0, 0, { message });
+    } else if (this.state === 'listening') {
+      const data = JSON.parse(message);
+      this.callback!(data);
+    }
+  }
+}
+
+export class WebSocketMessageWriter extends AbstractMessageWriter implements MessageWriter {
+  constructor(protected readonly socket) {
+    super();
+  }
+
+  write(msg): Promise<void> {
+    try {
+      const content = JSON.stringify(msg);
+      this.socket.send(content);
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  public end(): void {}
+}
+
+/**
+ * 给服务端的 WebSocket 及 Browser 端的 WebSocket 实例共用的方法
+ * @param socket
+ * @returns
+ */
+export function createWebSocketConnection(socket: any) {
+  return createMessageConnection(new WebSocketMessageReader(socket), new WebSocketMessageWriter(socket));
+}

package/src/common/proxy.ts

@@ -0,0 +1,303 @@
+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);
+    }
+  }
+}