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

package/src/common/ws-channel.ts

@@ -1,105 +1,188 @@
-import { stringify } from './utils';
+import type net from 'net';
+
+import Fury, { 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 { createWebSocketConnection } from './message';
+import { ILogger } from './types';
 
 export interface IWebSocket {
   send(content: string): void;
-  close(...args): void;
+  close(...args: any[]): void;
   onMessage(cb: (data: any) => void): void;
   onError(cb: (reason: any) => void): void;
   onClose(cb: (code: number, reason: string) => void): void;
 }
 
-export interface ClientMessage {
-  kind: 'client';
+/**
+ * `ping` and `pong` are used to detect whether the connection is alive.
+ */
+export interface PingMessage {
+  kind: 'ping';
+  id: string;
   clientId: string;
 }
-export interface HeartbeatMessage {
-  kind: 'heartbeat';
+
+/**
+ * when server receive a `ping` message, it should reply a `pong` message, vice versa.
+ */
+export interface PongMessage {
+  kind: 'pong';
+  id: string;
   clientId: string;
 }
+
+/**
+ * `open` message is used to open a new channel.
+ * `path` is used to identify which handler should be used to handle the channel.
+ * `clientId` is used to identify the client.
+ */
 export interface OpenMessage {
   kind: 'open';
-  id: number;
+  id: string;
   path: string;
+  clientId: string;
 }
-export interface ReadyMessage {
-  kind: 'ready';
-  id: number;
+
+/**
+ * when server receive a `open` message, it should reply a `server-ready` message.
+ * this is indicate that the channel is ready to use.
+ */
+export interface ServerReadyMessage {
+  kind: 'server-ready';
+  id: string;
 }
+
+/**
+ * `data` message indicate that the channel has received some data.
+ * the `content` field is the data, it should be a string.
+ */
 export interface DataMessage {
   kind: 'data';
-  id: number;
+  id: string;
   content: string;
 }
+
 export interface CloseMessage {
   kind: 'close';
-  id: number;
+  id: string;
   code: number;
   reason: string;
 }
-export type ChannelMessage = HeartbeatMessage | ClientMessage | OpenMessage | ReadyMessage | DataMessage | CloseMessage;
+
+export type ChannelMessage = PingMessage | PongMessage | OpenMessage | ServerReadyMessage | DataMessage | CloseMessage;
+
+export interface IWSChannelCreateOptions {
+  /**
+   * every channel's unique id, it only used in client to server architecture.
+   * server will store this id and use it to identify which channel should be used.
+   */
+  id: string;
+  logger?: ILogger;
+}
 
 export class WSChannel implements IWebSocket {
-  public id: number | string;
+  protected emitter = new EventEmitter<{
+    message: [data: string];
+    open: [id: string];
+    reopen: [];
+    close: [code?: number, reason?: string];
+  }>();
+
+  public id: string;
+  public LOG_TAG = '[WSChannel]';
+
   public channelPath: string;
 
-  private connectionSend: (content: string) => void;
-  private fireMessage: (data: any) => void;
-  private fireOpen: (id: number) => void;
-  public fireReOpen: () => void;
-  private fireClose: (code: number, reason: string) => void;
+  logger: ILogger = console;
 
-  public messageConnection: any;
+  static forClient(connection: IConnectionShape<Uint8Array>, options: IWSChannelCreateOptions) {
+    const disposable = new DisposableCollection();
+    const channel = new WSChannel(connection, options);
 
-  constructor(connectionSend: (content: string) => void, id?: number | string) {
-    this.connectionSend = connectionSend;
-    if (id) {
-      this.id = id;
-    }
+    disposable.push(
+      connection.onMessage((data) => {
+        channel.handleMessage(parse(data));
+      }),
+    );
+    disposable.push(channel);
+
+    disposable.push(
+      connection.onceClose(() => {
+        disposable.dispose();
+      }),
+    );
+
+    return channel;
   }
 
-  public setConnectionSend(connectionSend: (content: string) => void) {
-    this.connectionSend = connectionSend;
+  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;
+
+    if (logger) {
+      this.logger = logger;
+    }
+
+    this.LOG_TAG = `[WSChannel] [id:${id}]`;
   }
 
   // server
-  onMessage(cb: (data: any) => any) {
-    this.fireMessage = cb;
+  onMessage(cb: (data: string) => any) {
+    return this.emitter.on('message', cb);
   }
-  onOpen(cb: (id: number) => void) {
-    this.fireOpen = cb;
+  onOpen(cb: (id: string) => void) {
+    return this.emitter.on('open', cb);
   }
-  onReOpen(cb: () => void) {
-    this.fireReOpen = cb;
+  onReopen(cb: () => void) {
+    return this.emitter.on('reopen', cb);
   }
-  ready() {
-    this.connectionSend(
+  serverReady() {
+    this.connection.send(
       stringify({
-        kind: 'ready',
+        kind: 'server-ready',
         id: this.id,
       }),
     );
   }
+
   handleMessage(msg: ChannelMessage) {
-    if (msg.kind === 'ready' && this.fireOpen) {
-      this.fireOpen(msg.id);
-    } else if (msg.kind === 'data' && this.fireMessage) {
-      this.fireMessage(msg.content);
+    if (msg.kind === 'server-ready') {
+      this.emitter.emit('open', msg.id);
+    } else if (msg.kind === 'data') {
+      this.emitter.emit('message', msg.content);
     }
   }
 
   // client
-  open(path: string) {
+  open(path: string, clientId: string) {
     this.channelPath = path;
-    this.connectionSend(
+    this.connection.send(
       stringify({
         kind: 'open',
         id: this.id,
         path,
+        clientId,
       }),
     );
   }
   send(content: string) {
-    this.connectionSend(
+    this.connection.send(
       stringify({
         kind: 'data',
         id: this.id,
@@ -107,14 +190,36 @@ export class WSChannel implements IWebSocket {
       }),
     );
   }
+  hasMessageListener() {
+    return this.emitter.hasListener('message');
+  }
   onError() {}
-  close(code: number, reason: string) {
-    if (this.fireClose) {
-      this.fireClose(code, reason);
-    }
+  close(code?: number, reason?: string) {
+    this.emitter.emit('close', code, reason);
+  }
+  fireReopen() {
+    this.emitter.emit('reopen');
   }
   onClose(cb: (code: number, reason: string) => void) {
-    this.fireClose = cb;
+    return this.emitter.on('close', cb);
+  }
+  createMessageConnection() {
+    return createWebSocketConnection(this);
+  }
+  dispose() {
+    this.emitter.dispose();
+  }
+
+  listen(channel: WSChannel) {
+    channel.onMessage((data) => {
+      this.send(data);
+    });
+    channel.onClose((code, reason) => {
+      this.close(code, reason);
+    });
+    channel.onReopen(() => {
+      this.fireReopen();
+    });
   }
 }
 
@@ -142,3 +247,25 @@ export class ChildConnectPath {
     };
   }
 }
+
+const fury = new Fury({});
+
+export const wsChannelProtocol = Type.object('ws-channel-protocol', {
+  kind: Type.string(),
+  clientId: Type.string(),
+  id: Type.string(),
+  path: Type.string(),
+  content: Type.string(),
+  code: Type.uint32(),
+  reason: Type.string(),
+});
+
+const wsChannelProtocolSerializer = fury.registerSerializer(wsChannelProtocol);
+
+export function stringify(obj: ChannelMessage): Uint8Array {
+  return wsChannelProtocolSerializer.serialize(obj);
+}
+
+export function parse(input: Uint8Array): ChannelMessage {
+  return wsChannelProtocolSerializer.deserialize(input) as any;
+}

package/src/node/common-channel-handler.ts

@@ -1,23 +1,24 @@
-import pathMatch from 'path-match';
-import ws from 'ws';
+import { MatchFunction, match } from 'path-to-regexp';
+import WebSocket from 'ws';
 
-import { stringify, parse } from '../common/utils';
-import { WSChannel, ChannelMessage } from '../common/ws-channel';
+import { ILogger } from '../common';
+import { WSWebSocketConnection } from '../common/connection';
+import { WSChannel, ChannelMessage, stringify, parse } from '../common/ws-channel';
 
 import { WebSocketHandler, CommonChannelHandlerOptions } from './ws';
 
-export interface IPathHander {
+export interface IPathHandler {
   dispose: (connection: any, connectionId: string) => void;
-  handler: (connection: any, connectionId: string, params?: any) => void;
+  handler: (connection: any, connectionId: string, params?: Record<string, string>) => void;
   reconnect?: (connection: any, connectionId: string) => void;
   connection?: any;
 }
 
 export class CommonChannelPathHandler {
-  private handlerMap: Map<string, IPathHander[]> = new Map();
+  private handlerMap: Map<string, IPathHandler[]> = new Map();
   private paramsKey: Map<string, string> = new Map();
 
-  register(channelPath: string, handler: IPathHander) {
+  register(channelPath: string, handler: IPathHandler) {
     const paramsIndex = channelPath.indexOf('/:');
     const hasParams = paramsIndex >= 0;
     let channelToken = channelPath;
@@ -28,18 +29,18 @@ export class CommonChannelPathHandler {
     if (!this.handlerMap.has(channelToken)) {
       this.handlerMap.set(channelToken, []);
     }
-    const handlerArr = this.handlerMap.get(channelToken) as IPathHander[];
+    const handlerArr = this.handlerMap.get(channelToken) as IPathHandler[];
     const handlerFn = handler.handler.bind(handler);
-    const setHandler = (connection, clientId, params) => {
-      handler.connection = connection;
-      handlerFn(connection, clientId, params);
+    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) {
-    const params = {};
+  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) {
@@ -48,7 +49,7 @@ export class CommonChannelPathHandler {
     }
     return params;
   }
-  removeHandler(channelPath: string, handler: IPathHander) {
+  removeHandler(channelPath: string, handler: IPathHandler) {
     const paramsIndex = channelPath.indexOf(':');
     const hasParams = paramsIndex >= 0;
     let channelToken = channelPath;
@@ -65,9 +66,9 @@ export class CommonChannelPathHandler {
   get(channelPath: string) {
     return this.handlerMap.get(channelPath);
   }
-  disposeConnectionClientId(connection: ws, clientId: string) {
-    this.handlerMap.forEach((handlerArr: IPathHander[]) => {
-      handlerArr.forEach((handler: IPathHander) => {
+  disposeConnectionClientId(connection: WebSocket, clientId: string) {
+    this.handlerMap.forEach((handlerArr: IPathHandler[]) => {
+      handlerArr.forEach((handler: IPathHandler) => {
         handler.dispose(connection, clientId);
       });
     });
@@ -79,28 +80,26 @@ export class CommonChannelPathHandler {
 
 export const commonChannelPathHandler = new CommonChannelPathHandler();
 
-// 后台 Web 链接处理类
+/**
+ * Channel Handler for nodejs
+ */
 export class CommonChannelHandler extends WebSocketHandler {
-  static channelId = 0;
-
   public handlerId = 'common-channel';
-  private wsServer: ws.Server;
-  protected handlerRoute: (wsPathname: string) => any;
-  private channelMap: Map<string | number, WSChannel> = new Map();
-  private connectionMap: Map<string, ws> = new Map();
+  private wsServer: WebSocket.Server;
+  protected handlerRoute: MatchFunction;
+  private channelMap: Map<string, WSChannel> = new Map();
   private heartbeatMap: Map<string, NodeJS.Timeout> = new Map();
 
-  constructor(routePath: string, private logger: any = console, private options: CommonChannelHandlerOptions = {}) {
+  constructor(routePath: string, private logger: ILogger = console, private options: CommonChannelHandlerOptions = {}) {
     super();
-    const route = pathMatch(options.pathMatchOptions);
-    this.handlerRoute = route(`${routePath}`);
+    this.handlerRoute = match(routePath, options.pathMatchOptions);
     this.initWSServer();
   }
-  private hearbeat(connectionId: string, connection: ws) {
+
+  private heartbeat(connectionId: string, connection: WebSocket) {
     const timer = global.setTimeout(() => {
       connection.ping();
-      // console.log(`connectionId ${connectionId} ping`);
-      this.hearbeat(connectionId, connection);
+      this.heartbeat(connectionId, connection);
     }, 5000);
 
     this.heartbeatMap.set(connectionId, timer);
@@ -108,40 +107,38 @@ export class CommonChannelHandler extends WebSocketHandler {
 
   private initWSServer() {
     this.logger.log('init Common Channel Handler');
-    this.wsServer = new ws.Server({
+    this.wsServer = new WebSocket.Server({
       noServer: true,
       ...this.options.wsServerOptions,
     });
-    this.wsServer.on('connection', (connection: ws) => {
-      let connectionId;
-      connection.on('message', (msg: string) => {
+    this.wsServer.on('connection', (connection: WebSocket) => {
+      let clientId: string;
+
+      connection.on('message', (msg: Uint8Array) => {
         let msgObj: ChannelMessage;
         try {
           msgObj = parse(msg);
 
-          // 心跳消息
-          if (msgObj.kind === 'heartbeat') {
-            connection.send(stringify(`heartbeat ${msgObj.clientId}`));
-          } else if (msgObj.kind === 'client') {
-            const clientId = msgObj.clientId;
-            this.logger.log(`New connection with id ${clientId}`);
-            connectionId = clientId;
-            this.connectionMap.set(clientId, connection);
-            this.hearbeat(connectionId, connection);
-            // channel 消息处理
+          if (msgObj.kind === 'ping') {
+            connection.send(
+              stringify({
+                kind: 'pong',
+                id: msgObj.id,
+                clientId,
+              }),
+            );
           } else if (msgObj.kind === 'open') {
-            const channelId = msgObj.id; // CommonChannelHandler.channelId ++;
-            const { path } = msgObj;
-            this.logger.log(`Open a new connection channel ${channelId} with path ${path}`);
+            const { id, path } = msgObj;
+            clientId = msgObj.clientId;
+            this.logger.log(`open a new connection channel ${clientId} with path ${path}`);
+            this.heartbeat(id, connection);
 
-            // 生成 channel 对象
-            const connectionSend = this.channelConnectionSend(connection);
-            const channel = new WSChannel(connectionSend, channelId);
-            this.channelMap.set(channelId, channel);
+            const channel = new WSChannel(new WSWebSocketConnection(connection), { id });
+            this.channelMap.set(id, channel);
 
             // 根据 path 拿到注册的 handler
             let handlerArr = commonChannelPathHandler.get(path);
-            let params;
+            let params: Record<string, string> | undefined;
             // 尝试通过父路径查找处理函数，如server/:id方式注册的handler
             if (!handlerArr) {
               const slashIndex = path.indexOf('/');
@@ -155,11 +152,11 @@ export class CommonChannelHandler extends WebSocketHandler {
             if (handlerArr) {
               for (let i = 0, len = handlerArr.length; i < len; i++) {
                 const handler = handlerArr[i];
-                handler.handler(channel, connectionId, params);
+                handler.handler(channel, clientId, params);
               }
             }
 
-            channel.ready();
+            channel.serverReady();
           } else {
             const { id } = msgObj;
             const channel = this.channelMap.get(id);
@@ -170,51 +167,42 @@ export class CommonChannelHandler extends WebSocketHandler {
             }
           }
         } catch (e) {
-          this.logger.warn(e);
+          this.logger.error('handle connection message error', e);
         }
       });
 
-      connection.on('close', () => {
-        commonChannelPathHandler.disposeConnectionClientId(connection, connectionId as string);
+      connection.once('close', () => {
+        commonChannelPathHandler.disposeConnectionClientId(connection, clientId);
 
-        if (this.heartbeatMap.has(connectionId)) {
-          clearTimeout(this.heartbeatMap.get(connectionId) as NodeJS.Timeout);
-          this.heartbeatMap.delete(connectionId);
+        if (this.heartbeatMap.has(clientId)) {
+          clearTimeout(this.heartbeatMap.get(clientId) as NodeJS.Timeout);
+          this.heartbeatMap.delete(clientId);
 
-          this.logger.verbose(`Clear heartbeat from channel ${connectionId}`);
+          this.logger.log(`Clear heartbeat from channel ${clientId}`);
         }
 
         Array.from(this.channelMap.values())
-          .filter((channel) => channel.id.toString().indexOf(connectionId) !== -1)
+          .filter((channel) => channel.id.toString().indexOf(clientId) !== -1)
           .forEach((channel) => {
             channel.close(1, 'close');
+            channel.dispose();
             this.channelMap.delete(channel.id);
-            this.logger.verbose(`Remove connection channel ${channel.id}`);
+            this.logger.log(`Remove connection channel ${channel.id}`);
           });
       });
     });
   }
 
-  private channelConnectionSend = (connection: ws) => (content: string) => {
-    if (connection.readyState === connection.OPEN) {
-      connection.send(content, (err: any) => {
-        if (err) {
-          this.logger.log(err);
-        }
-      });
-    }
-  };
-  public handleUpgrade(wsPathname: string, request: any, socket: any, head: any): boolean {
-    const routeResult = this.handlerRoute(wsPathname);
+  public handleUpgrade(pathname: string, request: any, socket: any, head: any): boolean {
+    const routeResult = this.handlerRoute(pathname);
 
     if (routeResult) {
-      const wsServer = this.wsServer;
-      wsServer.handleUpgrade(request, socket, head, (connection: any) => {
-        connection.routeParam = {
-          pathname: wsPathname,
+      this.wsServer.handleUpgrade(request, socket, head, (connection) => {
+        (connection as any).routeParam = {
+          pathname,
         };
 
-        wsServer.emit('connection', connection);
+        this.wsServer.emit('connection', connection);
       });
       return true;
     }

package/src/node/index.ts

@@ -1,7 +1,2 @@
-import { SocketMessageReader, SocketMessageWriter } from '@opensumi/vscode-jsonrpc/lib/node/main';
-
 export * from './ws';
 export * from './common-channel-handler';
-export * from './connect';
-
-export { SocketMessageReader, SocketMessageWriter };

package/src/node/ws.ts

@@ -1,3 +1,4 @@
+import assert from 'assert';
 import http from 'http';
 import url from 'url';
 
@@ -5,7 +6,7 @@ import ws from 'ws';
 
 export abstract class WebSocketHandler {
   abstract handlerId: string;
-  abstract handleUpgrade(wsPathname: string, request: any, socket: any, head: any): boolean;
+  abstract handleUpgrade(pathname: string, request: any, socket: any, head: any): boolean;
   init?(): void;
 }
 
@@ -88,6 +89,7 @@ export class WebSocketServerRoute {
     const wsServerHandlerArr = this.wsServerHandlerArr;
 
     server.on('upgrade', (request, socket, head) => {
+      assert(request.url, 'cannot parse url from http request');
       const wsPathname: string = url.parse(request.url).pathname as string;
 
       let wsHandlerIndex = 0;

package/lib/common/proxy.d.ts

@@ -1,47 +0,0 @@
-import type { MessageConnection } from '@opensumi/vscode-jsonrpc/lib/common/connection';
-export interface ILogger {
-    warn(...args: any[]): void;
-}
-export declare abstract class RPCService<T = any> {
-    rpcClient?: T[];
-    rpcRegistered?: boolean;
-    register?(): () => Promise<T>;
-    get client(): T | undefined;
-}
-export declare const NOTREGISTERMETHOD = "$$NOTREGISTERMETHOD";
-export declare class ProxyClient {
-    proxy: any;
-    reservedWords: string[];
-    constructor(proxy: any, reservedWords?: string[]);
-    getClient(): {};
-}
-export declare class RPCProxy {
-    target?: RPCService<any> | undefined;
-    private connectionPromise;
-    private connectionPromiseResolve;
-    private connection;
-    private proxyService;
-    private logger;
-    private capture;
-    constructor(target?: RPCService<any> | undefined, logger?: ILogger);
-    listenService(service: any): void;
-    listen(connection: MessageConnection): void;
-    createProxy(): any;
-    get(target: any, p: PropertyKey): (...args: any[]) => Promise<unknown>;
-    private getServiceMethod;
-    private bindOnRequest;
-    private waitForConnection;
-    /**
-     * 对于纯数组参数的情况，收到请求/通知后做展开操作
-     * 因为在通信层会为每个 rpc 调用添加一个 CancellationToken 参数
-     * 如果参数本身是数组, 在方法中如果使用 spread 运算符获取参数(...args)，则会出现 [...args, MutableToken] 这种情况
-     * 所以发送请求时将这类参数统一再用数组包了一层，形如 [[...args]], 参考 {@link RPCProxy.get get} 方法
-     * 此时接收到的数组类参数固定长度为 2，且最后一项一定是 MutableToken
-     * @param args
-     * @returns args
-     */
-    private serializeArguments;
-    private onRequest;
-    private onNotification;
-}
-//# sourceMappingURL=proxy.d.ts.map

package/lib/common/proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/common/proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AAIxF,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC5B;AAED,8BAAsB,UAAU,CAAC,CAAC,GAAG,GAAG;IACtC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC;IAC7B,IAAI,MAAM,kBAET;CACF;AAED,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AAEvD,qBAAa,WAAW;IACf,KAAK,EAAE,GAAG,CAAC;IACX,aAAa,EAAE,MAAM,EAAE,CAAC;gBAEnB,KAAK,EAAE,GAAG,EAAE,aAAa,WAAW;IAIzC,SAAS;CAcjB;AAMD,qBAAa,QAAQ;IAcA,MAAM,CAAC;IAb1B,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,wBAAwB,CAA0C;IAC1E,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,MAAM,CAAU;IAExB,OAAO,CAAC,OAAO;gBAOI,MAAM,CAAC,6BAAY,EAAE,MAAM,CAAC,EAAE,OAAO;IAIjD,aAAa,CAAC,OAAO,KAAA;IAerB,MAAM,CAAC,UAAU,EAAE,iBAAiB;IAUpC,WAAW,IAAI,GAAG;IAMlB,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,WAAW,aAGnB,GAAG,EAAE;IAmExB,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,aAAa;IAkErB,OAAO,CAAC,iBAAiB;IAMzB;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;YASZ,SAAS;IAmBvB,OAAO,CAAC,cAAc;CAOvB"}