@opensumi/ide-connection 2.27.3-rc-1714367598.0 → 2.27.3-rc-1715052394.0

package/src/common/rpc/multiplexer.ts

@@ -1,6 +1,7 @@
 import { BaseConnection } from '../connection';
 
 import { ISumiConnectionOptions, SumiConnection } from './connection';
+import { TSumiProtocol } from './types';
 
 export class ProxyIdentifier<T = any> {
   public static count = 0;
@@ -17,6 +18,13 @@ export class ProxyIdentifier<T = any> {
   }
 }
 
+export interface ISumiMultiplexerConnectionOptions extends ISumiConnectionOptions {
+  /**
+   * Known protocols that will be loaded automatically when a proxy is created.
+   */
+  knownProtocols?: Record<string, TSumiProtocol>;
+}
+
 export const IRPCProtocol = Symbol('IRPCProtocol');
 export interface IRPCProtocol {
   getProxy<T>(proxyId: ProxyIdentifier<T>): T;
@@ -46,11 +54,13 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
 
   protected readonly _locals: Map<string, any>;
   protected readonly _proxies: Map<string, any>;
+  protected _knownProtocols: Record<string, TSumiProtocol>;
 
-  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
+  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiMultiplexerConnectionOptions = {}) {
     super(socket, options);
     this._locals = new Map();
     this._proxies = new Map();
+    this._knownProtocols = options.knownProtocols || {};
 
     this.onRequestNotFound((rpcName: string, args: any[]) => this._doInvokeHandler(rpcName, args));
 
@@ -60,7 +70,13 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
   }
 
   public set<T>(identifier: ProxyIdentifier<T>, instance: any) {
-    this._locals.set(SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId), instance);
+    const id = SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId);
+    this._locals.set(id, instance);
+    const protocol = this._knownProtocols[identifier.serviceId];
+    if (protocol) {
+      this.loadProtocol(id, protocol);
+    }
+
     return instance;
   }
 
@@ -68,10 +84,21 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
     return this._locals.get(SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId));
   }
 
+  protected loadProtocol(rpcId: string, protocol: TSumiProtocol) {
+    this.io.loadProtocol(protocol, {
+      nameConverter: (str: string) => SumiConnectionMultiplexer.getRPCName(rpcId, str),
+    });
+  }
+
   public getProxy<T>(proxyId: ProxyIdentifier<T>) {
     const serviceId = SumiConnectionMultiplexer.normalizeServiceId(proxyId.serviceId);
 
     if (!this._proxies.has(serviceId)) {
+      const protocol = this._knownProtocols[proxyId.serviceId];
+      if (protocol) {
+        this.loadProtocol(serviceId, protocol);
+      }
+
       this._proxies.set(serviceId, this._createProxy(serviceId));
     }
 
@@ -111,4 +138,8 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
 
     return method.apply(actor, args);
   }
+
+  getSocket() {
+    return this.socket;
+  }
 }

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

@@ -1,4 +1,5 @@
 import { Deferred } from '@opensumi/ide-core-common';
+import { addElement } from '@opensumi/ide-utils/lib/arrays';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
 import { TSumiProtocol } from '../rpc';
@@ -54,15 +55,14 @@ export class RPCServiceCenter {
 
     this.protocolRegistry.applyTo(connection.io);
 
-    const index = this.proxies.length - 1;
     const proxy = new ProxySumi(this.serviceRegistry, this.logger);
     proxy.listen(connection);
 
-    this.proxies.push(proxy);
+    const remove = addElement(this.proxies, proxy);
 
     return {
       dispose: () => {
-        this.proxies.splice(index, 1);
+        remove.dispose();
         proxy.dispose();
       },
     };
@@ -73,16 +73,14 @@ export class RPCServiceCenter {
       this.deferred.resolve();
     }
 
-    const index = this.proxies.length - 1;
-
     const proxy = new ProxyJson(this.serviceRegistry, this.logger);
     proxy.listen(connection);
 
-    this.proxies.push(proxy);
+    const remove = addElement(this.proxies, proxy);
 
     return {
       dispose: () => {
-        this.proxies.splice(index, 1);
+        remove.dispose();
         proxy.dispose();
       },
     };

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

@@ -9,6 +9,12 @@ import { CommonChannelHandlerOptions, WebSocketHandler } from './ws';
 
 export { commonChannelPathHandler };
 
+export interface WebSocketConnection extends WebSocket {
+  routeParam: {
+    pathname: string;
+  };
+}
+
 /**
  * Channel Handler for nodejs
  */
@@ -27,7 +33,7 @@ export class CommonChannelHandler extends BaseCommonChannelHandler implements We
   }
 
   private initWSServer() {
-    this.logger.log('init Common Channel Handler');
+    this.logger.log('init common channel handler');
     this.wsServer = new WebSocket.Server({
       noServer: true,
       ...this.options.wsServerOptions,
@@ -43,7 +49,7 @@ export class CommonChannelHandler extends BaseCommonChannelHandler implements We
 
     if (routeResult) {
       this.wsServer.handleUpgrade(request, socket, head, (connection) => {
-        (connection as any).routeParam = {
+        (connection as WebSocketConnection).routeParam = {
           pathname,
         };
 

package/src/node/ws.ts

@@ -1,6 +1,5 @@
 import assert from 'assert';
 import http from 'http';
-import url from 'url';
 
 import ws from 'ws';
 
@@ -90,7 +89,10 @@ export class WebSocketServerRoute {
 
     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;
+
+      // request.url: `/path?query=a#hash`
+      const url = new URL(request.url, 'wss://base');
+      const wsPathname: string = url.pathname;
 
       let wsHandlerIndex = 0;
       const wsHandlerLength = wsServerHandlerArr.length;