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

package/src/common/rpc-service/proxy/{legacy.ts → json.ts}

@@ -9,8 +9,8 @@ interface IRPCResult {
   data: any;
 }
 
-export class ProxyLegacy extends ProxyBase<MessageConnection> {
-  protected engine = 'legacy' as const;
+export class ProxyJson extends ProxyBase<MessageConnection> {
+  protected engine = 'json' as const;
 
   protected bindMethods(methods: string[]): void {
     for (const method of methods) {
@@ -53,68 +53,58 @@ export class ProxyLegacy extends ProxyBase<MessageConnection> {
     }
   }
 
-  public getInvokeProxy<T = any>(): T {
-    return new Proxy(Object.create(null), {
-      get: (target: any, p: PropertyKey) => {
-        if (!target[p]) {
-          target[p] = async (...args: any[]) => {
-            await this.connectionPromise.promise;
-
-            let isSingleArray = false;
-            if (args.length === 1 && Array.isArray(args[0])) {
-              isSingleArray = true;
-            }
-            const prop = p.toString();
-
-            // 调用方法为 on 开头时，作为单项通知
-            if (prop.startsWith('on')) {
-              this.captureSendNotification(prop, args);
-              if (isSingleArray) {
-                this.connection.sendNotification(prop, [...args]);
-              } else {
-                this.connection.sendNotification(prop, ...args);
-              }
-            } else {
-              // generate a unique requestId to associate request and requestResult
-              const requestId = this.nextRequestId();
-
-              let requestResult: Promise<any>;
-
-              if (isSingleArray) {
-                requestResult = this.connection.sendRequest(prop, [...args]) as Promise<any>;
-              } else {
-                requestResult = this.connection.sendRequest(prop, ...args) as Promise<any>;
-              }
-
-              this.captureSendRequest(requestId, prop, args);
-
-              const result: IRPCResult = await requestResult;
-
-              if (result.error) {
-                const error = new Error(result.data.message);
-                if (result.data.stack) {
-                  error.stack = result.data.stack;
-                }
-
-                this.captureSendRequestFail(requestId, prop, result.data);
-                throw error;
-              } else {
-                this.captureSendRequestResult(requestId, prop, result.data);
-                return result.data;
-              }
-            }
-          };
+  async invoke(prop: string, ...args: any[]): Promise<any> {
+    await this.connectionPromise.promise;
+
+    let isSingleArray = false;
+    if (args.length === 1 && Array.isArray(args[0])) {
+      isSingleArray = true;
+    }
+
+    // 调用方法为 on 开头时，作为单项通知
+    if (prop.startsWith('on')) {
+      this.captureSendNotification(prop, args);
+      if (isSingleArray) {
+        this.connection.sendNotification(prop, [...args]);
+      } else {
+        this.connection.sendNotification(prop, ...args);
+      }
+    } else {
+      // generate a unique requestId to associate request and requestResult
+      const requestId = this.nextRequestId();
+
+      let requestResult: Promise<any>;
+
+      if (isSingleArray) {
+        requestResult = this.connection.sendRequest(prop, [...args]) as Promise<any>;
+      } else {
+        requestResult = this.connection.sendRequest(prop, ...args) as Promise<any>;
+      }
+
+      this.captureSendRequest(requestId, prop, args);
+
+      const result: IRPCResult = await requestResult;
+
+      if (result.error) {
+        const error = new Error(result.data.message);
+        if (result.data.stack) {
+          error.stack = result.data.stack;
         }
-        return target[p];
-      },
-    });
+
+        this.captureSendRequestFail(requestId, prop, result.data);
+        throw error;
+      } else {
+        this.captureSendRequestResult(requestId, prop, result.data);
+        return result.data;
+      }
+    }
   }
 
   /**
    * 对于纯数组参数的情况，收到请求/通知后做展开操作
    * 因为在通信层会为每个 rpc 调用添加一个 CancellationToken 参数
    * 如果参数本身是数组, 在方法中如果使用 spread 运算符获取参数(...args)，则会出现 [...args, MutableToken] 这种情况
-   * 所以发送请求时将这类参数统一再用数组包了一层，形如 [[...args]], 参考 {@link ProxyLegacy.get get} 方法
+   * 所以发送请求时将这类参数统一再用数组包了一层，形如 [[...args]], 参考 {@link ProxyJson.get get} 方法
    * 此时接收到的数组类参数固定长度为 2，且最后一项一定是 MutableToken
    * @param args
    * @returns args

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

@@ -35,47 +35,35 @@ export class ProxySumi extends ProxyBase<SumiConnection> {
     }
   }
 
-  public getInvokeProxy<T = any>(): T {
-    return new Proxy(Object.create(null), {
-      get: (target: any, p: PropertyKey) => {
-        if (!target[p]) {
-          target[p] = async (...args: any[]) => {
-            await this.connectionPromise.promise;
-            const prop = p.toString();
+  async invoke(prop: string, ...args: any[]): Promise<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[p];
-      },
-    });
+    // 调用方法为 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;
+      }
+    }
   }
 
   listen(connection: SumiConnection): void {
     super.listen(connection);
     connection.onRequestNotFound((method) => {
-      if (!this.registry.has(method)) {
-        const requestId = this.nextRequestId();
-        this.captureOnRequest(requestId, method, []);
-        this.captureOnRequestFail(requestId, method, METHOD_NOT_REGISTERED);
-        throw METHOD_NOT_REGISTERED;
-      }
+      const requestId = this.nextRequestId();
+      this.captureOnRequest(requestId, method, []);
+      this.captureOnRequestFail(requestId, method, METHOD_NOT_REGISTERED);
+      throw METHOD_NOT_REGISTERED;
     });
   }
 }

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

@@ -0,0 +1,125 @@
+import { Emitter } from '@opensumi/ide-core-common';
+
+import { MessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
+import { RPCServiceMethod } from '../types';
+
+export function getServiceMethods(service: any): 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;
+}
+
+/**
+ * Store all executable services
+ */
+export class ServiceRegistry {
+  protected emitter = new Emitter<string[]>();
+
+  private serviceMethodMap = new Map<PropertyKey, RPCServiceMethod>();
+
+  onServicesUpdate = this.emitter.event;
+
+  register(name: string, methodFn: RPCServiceMethod) {
+    this.serviceMethodMap.set(name, methodFn);
+    this.emitter.fire([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.set(methodName, service[method].bind(service));
+      serviceNames.push(methodName);
+    }
+
+    this.emitter.fire(serviceNames);
+  }
+
+  has(name: PropertyKey) {
+    return this.serviceMethodMap.has(name);
+  }
+
+  invoke(name: PropertyKey, ...args: any[]): any {
+    // here because we have checked the existence of the method
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.serviceMethodMap.get(name)!(...args);
+  }
+
+  methods() {
+    return Array.from(this.serviceMethodMap.keys());
+  }
+}
+
+export class ProtocolRegistry {
+  protected emitter = new Emitter<string[]>();
+
+  private protocolMap = new Map<PropertyKey, TSumiProtocolMethod>();
+
+  onProtocolUpdate = this.emitter.event;
+
+  addProtocol(
+    protocol: TSumiProtocol,
+    options?: {
+      nameConverter?: (str: string) => string;
+    },
+  ) {
+    const serviceNames = [] as string[];
+    const { nameConverter } = options || {};
+    const { methods } = protocol;
+
+    for (const proto of methods) {
+      let method = proto.method;
+      if (nameConverter) {
+        method = nameConverter(method);
+      }
+
+      this.protocolMap.set(method, {
+        ...proto,
+        method,
+      });
+      serviceNames.push(method);
+    }
+
+    this.emitter.fire(serviceNames);
+  }
+
+  applyTo(io: MessageIO) {
+    for (const protocol of this.protocolMap.values()) {
+      io.loadProtocolMethod(protocol);
+    }
+
+    this.onProtocolUpdate((methods) => {
+      for (const method of methods) {
+        const protocol = this.protocolMap.get(method);
+        if (protocol) {
+          io.loadProtocolMethod(protocol);
+        }
+      }
+    });
+  }
+}

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

@@ -27,16 +27,16 @@ export class RPCServiceStub {
     new Proxy<T extends void ? RPCServiceStub : RPCServiceStub & T>(this as any, {
       // 调用方
       get: (target, prop: string) => {
-        if (!target[prop]) {
-          if (typeof prop === 'symbol') {
-            return Promise.resolve();
-          }
+        if (typeof prop === 'symbol') {
+          return Promise.resolve();
+        }
 
+        if (!target[prop]) {
           target[prop] = (...args: any[]) => this.broadcast(prop, ...args);
           return target[prop];
-        } else {
-          return target[prop];
         }
+
+        return target[prop];
       },
     });
 }

package/src/common/{ext-rpc-protocol.ts → rpcProtocol.ts}

@@ -22,7 +22,7 @@ export interface IProxyIdentifier {
   countId: number;
 }
 
-export { ProxyIdentifier, IRPCProtocol } from './rpc/multiplexer';
+export { IRPCProtocol, ProxyIdentifier };
 
 export function createExtHostContextProxyIdentifier<T>(serviceId: string): ProxyIdentifier<T> {
   const identifier = new ProxyIdentifier<T>(serviceId);
@@ -199,7 +199,7 @@ export class RPCProtocol implements IRPCProtocol {
     this._lastMessageId = 0;
     this.logger = logger || console;
     this.logger.error(
-      "You are using the deprecated 'RPCProtocol' class. Please use the new 'SumiConnectionMultiplexer'",
+      "You are using the deprecated class: 'RPCProtocol'. Please use the new one: 'SumiConnectionMultiplexer'",
     );
     this._protocol.onMessage((msg) => this._receiveOneMessage(msg));
   }

package/src/common/server-handler.ts

@@ -0,0 +1,183 @@
+import { IConnectionShape } from './connection/types';
+import { ILogger } from './types';
+import { ChannelMessage, WSChannel, parse, pongMessage } from './ws-channel';
+
+export interface IPathHandler {
+  dispose: (channel: WSChannel, connectionId: string) => void;
+  handler: (channel: WSChannel, connectionId: string, params?: Record<string, string>) => void;
+  reconnect?: (channel: WSChannel, connectionId: string) => void;
+  connection?: any;
+}
+
+export class CommonChannelPathHandler {
+  private handlerMap: Map<string, IPathHandler[]> = new Map();
+  private paramsKey: Map<string, string> = new Map();
+
+  register(channelPath: string, handler: IPathHandler) {
+    const paramsIndex = channelPath.indexOf('/:');
+    const hasParams = paramsIndex >= 0;
+    let channelToken = channelPath;
+    if (hasParams) {
+      channelToken = channelPath.slice(0, paramsIndex);
+      this.paramsKey.set(channelToken, channelPath.slice(paramsIndex + 2));
+    }
+    if (!this.handlerMap.has(channelToken)) {
+      this.handlerMap.set(channelToken, []);
+    }
+    const handlerArr = this.handlerMap.get(channelToken) as IPathHandler[];
+    const handlerFn = handler.handler.bind(handler);
+    const setHandler = (channel: WSChannel, clientId: string, params: any) => {
+      handler.connection = channel;
+      handlerFn(channel, clientId, params);
+    };
+    handler.handler = setHandler;
+    handlerArr.push(handler);
+    this.handlerMap.set(channelToken, handlerArr);
+  }
+  getParams(channelPath: string, value: string): Record<string, string> {
+    const params = {} as Record<string, string>;
+    if (this.paramsKey.has(channelPath)) {
+      const key = this.paramsKey.get(channelPath);
+      if (key) {
+        params[key] = value;
+      }
+    }
+    return params;
+  }
+  removeHandler(channelPath: string, handler: IPathHandler) {
+    const paramsIndex = channelPath.indexOf(':');
+    const hasParams = paramsIndex >= 0;
+    let channelToken = channelPath;
+    if (hasParams) {
+      channelToken = channelPath.slice(0, paramsIndex);
+    }
+    const handlerArr = this.handlerMap.get(channelToken) || [];
+    const removeIndex = handlerArr.indexOf(handler);
+    if (removeIndex !== -1) {
+      handlerArr.splice(removeIndex, 1);
+    }
+    this.handlerMap.set(channelPath, handlerArr);
+  }
+  get(channelPath: string) {
+    return this.handlerMap.get(channelPath);
+  }
+  disposeConnectionClientId(channel: any, clientId: string) {
+    this.handlerMap.forEach((handlerArr: IPathHandler[]) => {
+      handlerArr.forEach((handler: IPathHandler) => {
+        handler.dispose(channel, clientId);
+      });
+    });
+  }
+  dispatchChannelOpen(path: string, channel: WSChannel, clientId: string) {
+    // 根据 path 拿到注册的 handler
+    let handlerArr = this.get(path);
+    let params: Record<string, string> | undefined;
+    // 尝试通过父路径查找处理函数，如server/:id方式注册的handler
+    if (!handlerArr) {
+      const slashIndex = path.indexOf('/');
+      const hasSlash = slashIndex >= 0;
+      if (hasSlash) {
+        handlerArr = this.get(path.slice(0, slashIndex));
+        params = this.getParams(path.slice(0, slashIndex), path.slice(slashIndex + 1));
+      }
+    }
+
+    if (handlerArr) {
+      for (let i = 0, len = handlerArr.length; i < len; i++) {
+        const handler = handlerArr[i];
+        handler.handler(channel, clientId, params);
+      }
+    }
+  }
+
+  getAll() {
+    return Array.from(this.handlerMap.values());
+  }
+}
+
+export const commonChannelPathHandler = new CommonChannelPathHandler();
+
+export abstract class BaseCommonChannelHandler {
+  protected channelMap: Map<string, WSChannel> = new Map();
+
+  heartbeatTimer: NodeJS.Timeout | null = null;
+
+  constructor(public handlerId: string, protected logger: ILogger = console) {}
+
+  abstract doHeartbeat(connection: any): void;
+
+  private heartbeat(connection: any) {
+    const timer = global.setTimeout(() => {
+      this.doHeartbeat(connection);
+      this.heartbeat(connection);
+    }, 5000);
+
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+    }
+
+    this.heartbeatTimer = timer;
+  }
+
+  receiveConnection(connection: IConnectionShape<Uint8Array>) {
+    let clientId: string;
+    this.heartbeat(connection);
+
+    connection.onMessage((data: Uint8Array) => {
+      let msg: ChannelMessage;
+      try {
+        msg = parse(data);
+
+        switch (msg.kind) {
+          case 'ping':
+            connection.send(pongMessage);
+            break;
+          case 'open': {
+            const { id, path } = msg;
+            clientId = msg.clientId;
+            this.logger.log(`open a new connection channel ${clientId} with path ${path}`);
+
+            const channel = new WSChannel(connection, { id, logger: this.logger });
+            this.channelMap.set(id, channel);
+
+            commonChannelPathHandler.dispatchChannelOpen(path, channel, clientId);
+            channel.serverReady();
+            break;
+          }
+          default: {
+            const { id } = msg;
+            const channel = this.channelMap.get(id);
+            if (channel) {
+              channel.dispatchChannelMessage(msg);
+            } else {
+              this.logger.warn(`channel ${id} is not found`);
+            }
+          }
+        }
+      } catch (e) {
+        this.logger.error('handle connection message error', e);
+      }
+    });
+
+    connection.onceClose(() => {
+      commonChannelPathHandler.disposeConnectionClientId(connection, clientId);
+
+      Array.from(this.channelMap.values())
+        .filter((channel) => channel.id.toString().indexOf(clientId) !== -1)
+        .forEach((channel) => {
+          channel.close(1, 'close');
+          channel.dispose();
+          this.channelMap.delete(channel.id);
+          this.logger.log(`Remove connection channel ${channel.id}`);
+        });
+    });
+  }
+
+  dispose() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+    }
+  }
+}
+
+export const RPCServiceChannelPath = 'RPCService';

package/src/common/types.ts

@@ -15,3 +15,16 @@ export enum ServiceType {
 export interface IBench {
   registerService: (service: string) => void;
 }
+
+export interface WSCloseInfo {
+  channelPath: string;
+  closeEvent: { code: number; reason: string };
+  connectInfo: ConnectionInfo;
+}
+
+export interface ConnectionInfo {
+  type: string;
+  downlink: number;
+  uplink: number;
+  rtt: number;
+}

package/src/common/ws-channel.ts

@@ -1,16 +1,12 @@
-import type net from 'net';
-
 import { Type } from '@furyjs/fury';
-import type WebSocket from 'ws';
 
 import { EventEmitter } from '@opensumi/events';
 import { DisposableCollection } from '@opensumi/ide-core-common';
 
-import { NetSocketConnection, WSWebSocketConnection } from './connection';
 import { IConnectionShape } from './connection/types';
-import { oneOf } from './fury-extends/one-of';
+import { oneOf7 } from './fury-extends/one-of';
 import { createWebSocketConnection } from './message';
-import { SumiConnection, ISumiConnectionOptions } from './rpc/connection';
+import { ISumiConnectionOptions, SumiConnection } from './rpc/connection';
 import { ILogger } from './types';
 
 /**
@@ -103,7 +99,6 @@ export class WSChannel {
   }>();
 
   public id: string;
-  public LOG_TAG = '[WSChannel]';
 
   public channelPath: string;
 
@@ -129,16 +124,6 @@ export class WSChannel {
     return channel;
   }
 
-  static forWebSocket(socket: WebSocket, options: IWSChannelCreateOptions) {
-    const wsConnection = new WSWebSocketConnection(socket);
-    return WSChannel.forClient(wsConnection, options);
-  }
-
-  static forNetSocket(socket: net.Socket, options: IWSChannelCreateOptions) {
-    const wsConnection = new NetSocketConnection(socket);
-    return WSChannel.forClient(wsConnection, options);
-  }
-
   constructor(public connection: IConnectionShape<Uint8Array>, options: IWSChannelCreateOptions) {
     const { id, logger } = options;
     this.id = id;
@@ -146,8 +131,6 @@ export class WSChannel {
     if (logger) {
       this.logger = logger;
     }
-
-    this.LOG_TAG = `[WSChannel] [id:${id}]`;
   }
 
   onMessage(cb: (data: string) => any) {
@@ -236,9 +219,9 @@ export class WSChannel {
 
   createConnection() {
     return {
-      onceClose: (cb) => this.onceClose(cb),
-      onMessage: (cb) => this.onBinary(cb),
-      send: (data) => {
+      onceClose: (cb: (code: number, reason: string) => void) => this.onceClose(cb),
+      onMessage: (cb: (data: Uint8Array) => any) => this.onBinary(cb),
+      send: (data: Uint8Array) => {
         this.sendBinary(data);
       },
       dispose() {},
@@ -291,7 +274,7 @@ export const CloseProtocol = Type.object('close', {
   reason: Type.string(),
 });
 
-const serializer = oneOf([
+const serializer = oneOf7([
   PingProtocol,
   PongProtocol,
   OpenProtocol,
@@ -308,3 +291,18 @@ export function stringify(obj: ChannelMessage): Uint8Array {
 export function parse(input: Uint8Array): ChannelMessage {
   return serializer.deserialize(input) as any;
 }
+
+const _pingMessage: PingMessage = {
+  kind: 'ping',
+  id: '',
+  clientId: '',
+};
+
+const _pongMessage: PongMessage = {
+  kind: 'pong',
+  id: '',
+  clientId: '',
+};
+
+export const pingMessage = stringify(_pingMessage);
+export const pongMessage = stringify(_pongMessage);

package/src/electron/channel-handler.ts

@@ -0,0 +1,26 @@
+import net from 'net';
+
+import { ILogger } from '../common';
+import { NetSocketConnection } from '../common/connection';
+import { BaseCommonChannelHandler } from '../common/server-handler';
+
+/**
+ * Channel Handler for electron backend
+ */
+export class ElectronChannelHandler extends BaseCommonChannelHandler {
+  constructor(private server: net.Server, logger: ILogger = console) {
+    super('electron-channel-handler', logger);
+  }
+
+  doHeartbeat(connection: any): void {
+    // do nothing
+  }
+
+  listen() {
+    this.logger.log('init Common Channel Handler');
+    this.server.on('connection', (connection: net.Socket) => {
+      const netConnection = new NetSocketConnection(connection);
+      this.receiveConnection(netConnection);
+    });
+  }
+}

package/src/electron/index.ts

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