@opensumi/ide-connection 3.0.2-next-1715826860.0 → 3.0.2-next-1715852509.0

package/src/common/rpc/connection.ts

@@ -195,185 +195,186 @@ export class SumiConnection implements IDisposable {
   listen() {
     const { reader } = this.io;
 
-    this.disposable.add(
-      this.socket.onMessage((data) => {
-        reader.reset(data);
-        // skip version, currently only have version 1
-        reader.skip(1);
-
-        const opType = reader.uint8() as OperationType;
-        const requestId = reader.uint32();
-
-        if (this._timeoutHandles.has(requestId)) {
-          // Ignore some jest test scenarios where clearTimeout is not defined.
-          if (typeof clearTimeout === 'function') {
-            // @ts-ignore
-            clearTimeout(this._timeoutHandles.get(requestId));
-          }
-          this._timeoutHandles.delete(requestId);
+    const toDispose = this.socket.onMessage((data) => {
+      reader.reset(data);
+      // skip version, currently only have version 1
+      reader.skip(1);
+
+      const opType = reader.uint8() as OperationType;
+      const requestId = reader.uint32();
+
+      if (this._timeoutHandles.has(requestId)) {
+        // Ignore some jest test scenarios where clearTimeout is not defined.
+        if (typeof clearTimeout === 'function') {
+          // @ts-ignore
+          clearTimeout(this._timeoutHandles.get(requestId));
         }
+        this._timeoutHandles.delete(requestId);
+      }
 
-        switch (opType) {
-          case OperationType.Response: {
-            const method = reader.stringOfVarUInt32();
-            const status = reader.uint16();
+      switch (opType) {
+        case OperationType.Response: {
+          const method = reader.stringOfVarUInt32();
+          const status = reader.uint16();
 
-            const runCallback = (headers: IResponseHeaders, error?: any, result?: any) => {
-              const callback = this._callbacks.get(requestId);
-              if (!callback) {
-                this.logger.error(`Cannot find callback for request ${requestId}: ${method}, status: ${status}`);
-                return;
-              }
+          const runCallback = (headers: IResponseHeaders, error?: any, result?: any) => {
+            const callback = this._callbacks.get(requestId);
+            if (!callback) {
+              this.logger.error(`Cannot find callback for request ${requestId}`);
+              return;
+            }
+
+            this._callbacks.delete(requestId);
 
-              this._callbacks.delete(requestId);
+            callback(headers, error, result);
+          };
 
-              callback(headers, error, result);
-            };
+          const headers = this.io.responseHeadersSerializer.read();
+          let err: any;
+          let result: any;
+          if (status === Status.Err) {
+            // todo: move to processor
+            const content = reader.stringOfVarUInt32();
+            err = parseError(content);
+          } else {
+            result = this.io.getProcessor(method).readResponse();
+          }
 
-            const headers = this.io.responseHeadersSerializer.read();
-            let err: any;
-            let result: any;
-            if (status === Status.Err) {
-              // todo: move to processor
-              const content = reader.stringOfVarUInt32();
-              err = parseError(content);
+          if (headers && headers.chunked) {
+            let activeReq: SumiReadableStream<any>;
+            if (this.activeRequestPool.has(requestId)) {
+              activeReq = this.activeRequestPool.get(requestId)!;
             } else {
-              result = this.io.getProcessor(method).readResponse();
+              // new stream request
+              activeReq = new SumiReadableStream();
+              this.activeRequestPool.set(requestId, activeReq);
+              // resolve `activeReq` to caller
+              runCallback(headers, undefined, activeReq);
             }
 
-            if (headers && headers.chunked) {
-              let activeReq: SumiReadableStream<any>;
-              if (this.activeRequestPool.has(requestId)) {
-                activeReq = this.activeRequestPool.get(requestId)!;
-              } else {
-                // new stream request
-                activeReq = new SumiReadableStream();
-                this.activeRequestPool.set(requestId, activeReq);
-                // resolve `activeReq` to caller
-                runCallback(headers, undefined, activeReq);
-              }
-
-              if (result === null) {
-                // when result is null, it means the stream is ended.
-                activeReq.end();
-                this.activeRequestPool.delete(requestId);
-                break;
-              }
-
-              if (err) {
-                activeReq.emitError(err);
-                break;
-              }
+            if (result === null) {
+              // when result is null, it means the stream is ended.
+              activeReq.end();
+              this.activeRequestPool.delete(requestId);
+              break;
+            }
 
-              activeReq.emitData(result);
+            if (err) {
+              activeReq.emitError(err);
               break;
             }
 
-            runCallback(headers, err, result);
+            activeReq.emitData(result);
             break;
           }
-          case OperationType.Notification:
-          // fall through
-          case OperationType.Request: {
-            const method = reader.stringOfVarUInt32();
-            const headers = this.io.requestHeadersSerializer.read() as IRequestHeaders;
-            const args = this.io.getProcessor(method).readRequest();
-
-            if (headers.cancelable) {
-              const tokenSource = new CancellationTokenSource();
-              this._cancellationTokenSources.set(requestId, tokenSource);
-              args.push(tokenSource.token);
-
-              if (this._knownCanceledRequests.has(requestId)) {
-                tokenSource.cancel();
-                this._knownCanceledRequests.delete(requestId);
-              }
-            }
 
-            switch (opType) {
-              case OperationType.Request: {
-                this.capturer.captureOnRequest(requestId, method, args);
+          runCallback(headers, err, result);
+          break;
+        }
+        case OperationType.Notification:
+        // fall through
+        case OperationType.Request: {
+          const method = reader.stringOfVarUInt32();
+          const headers = this.io.requestHeadersSerializer.read() as IRequestHeaders;
+          const args = this.io.getProcessor(method).readRequest();
+
+          if (headers.cancelable) {
+            const tokenSource = new CancellationTokenSource();
+            this._cancellationTokenSources.set(requestId, tokenSource);
+            args.push(tokenSource.token);
+
+            if (this._knownCanceledRequests.has(requestId)) {
+              tokenSource.cancel();
+              this._knownCanceledRequests.delete(requestId);
+            }
+          }
 
-                let promise: Promise<any>;
+          switch (opType) {
+            case OperationType.Request: {
+              this.capturer.captureOnRequest(requestId, method, args);
 
-                try {
-                  let result: any;
+              let promise: Promise<any>;
 
-                  const handler = this._requestHandlers.get(method);
-                  if (handler) {
-                    result = handler(...args);
-                  } else if (this._starRequestHandler) {
-                    result = this._starRequestHandler(method, args);
-                  }
+              try {
+                let result: any;
 
-                  promise = Promise.resolve(result);
-                } catch (err) {
-                  promise = Promise.reject(err);
+                const handler = this._requestHandlers.get(method);
+                if (handler) {
+                  result = handler(...args);
+                } else if (this._starRequestHandler) {
+                  result = this._starRequestHandler(method, args);
                 }
 
-                const onSuccess = (result: any) => {
-                  this.capturer.captureOnRequestResult(requestId, method, result);
-
-                  if (isReadableStream(result)) {
-                    listenReadable(result, {
-                      onData: (data) => {
-                        this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, data));
-                      },
-                      onEnd: () => {
-                        this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, null));
-                      },
-                      onError: (err) => {
-                        this.socket.send(this.io.Error(requestId, method, chunkedResponseHeaders, err));
-                      },
-                    });
-                  } else {
-                    this.socket.send(this.io.Response(requestId, method, nullHeaders, result));
-                  }
-
-                  this._cancellationTokenSources.delete(requestId);
-                };
-
-                const onError = (err: Error) => {
-                  this.traceRequestError(requestId, method, args, err);
-
-                  this.socket.send(this.io.Error(requestId, method, nullHeaders, err));
-                  this._cancellationTokenSources.delete(requestId);
-                };
-
-                promise.then(onSuccess).catch(onError);
-                break;
+                promise = Promise.resolve(result);
+              } catch (err) {
+                promise = Promise.reject(err);
               }
-              case OperationType.Notification: {
-                this.capturer.captureOnNotification(requestId, method, args);
 
-                const handler = this._notificationHandlers.get(method);
-
-                if (handler) {
-                  handler(...args);
-                } else if (this._starNotificationHandler) {
-                  this._starNotificationHandler(method, args);
+              const onSuccess = (result: any) => {
+                this.capturer.captureOnRequestResult(requestId, method, result);
+
+                if (isReadableStream(result)) {
+                  listenReadable(result, {
+                    onData: (data) => {
+                      this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, data));
+                    },
+                    onEnd: () => {
+                      this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, null));
+                    },
+                    onError: (err) => {
+                      this.socket.send(this.io.Error(requestId, method, chunkedResponseHeaders, err));
+                    },
+                  });
+                } else {
+                  this.socket.send(this.io.Response(requestId, method, nullHeaders, result));
                 }
-                break;
-              }
+
+                this._cancellationTokenSources.delete(requestId);
+              };
+
+              const onError = (err: Error) => {
+                this.traceRequestError(requestId, method, args, err);
+
+                this.socket.send(this.io.Error(requestId, method, nullHeaders, err));
+                this._cancellationTokenSources.delete(requestId);
+              };
+
+              promise.then(onSuccess).catch(onError);
+              break;
             }
+            case OperationType.Notification: {
+              this.capturer.captureOnNotification(requestId, method, args);
 
-            break;
-          }
-          case OperationType.Cancel: {
-            const cancellationTokenSource = this._cancellationTokenSources.get(requestId);
-            if (cancellationTokenSource) {
-              cancellationTokenSource.cancel();
-            } else {
-              this._knownCanceledRequests.add(requestId);
+              const handler = this._notificationHandlers.get(method);
+
+              if (handler) {
+                handler(...args);
+              } else if (this._starNotificationHandler) {
+                this._starNotificationHandler(method, args);
+              }
+              break;
             }
-            break;
           }
-          default: {
-            break;
+
+          break;
+        }
+        case OperationType.Cancel: {
+          const cancellationTokenSource = this._cancellationTokenSources.get(requestId);
+          if (cancellationTokenSource) {
+            cancellationTokenSource.cancel();
+          } else {
+            this._knownCanceledRequests.add(requestId);
           }
+          break;
+        }
+        default: {
+          break;
         }
-      }),
-    );
+      }
+    });
+    if (toDispose) {
+      this.disposable.add(toDispose);
+    }
   }
 
   dispose(): void {

package/src/common/server-handler.ts

@@ -1,14 +1,6 @@
 import { IConnectionShape } from './connection/types';
 import { ILogger } from './types';
-import {
-  ChannelMessage,
-  ErrorMessageCode,
-  WSChannel,
-  WSServerChannel,
-  parse,
-  pongMessage,
-  stringify,
-} from './ws-channel';
+import { ChannelMessage, WSChannel, WSServerChannel, parse, pongMessage } from './ws-channel';
 
 export interface IPathHandler {
   dispose: (channel: WSChannel, connectionId: string) => void;
@@ -76,7 +68,7 @@ export class CommonChannelPathHandler {
       });
     });
   }
-  openChannel(path: string, channel: WSChannel, clientId: string) {
+  dispatchChannelOpen(path: string, channel: WSChannel, clientId: string) {
     // 根据 path 拿到注册的 handler
     let handlerArr = this.get(path);
     let params: Record<string, string> | undefined;
@@ -106,38 +98,31 @@ export class CommonChannelPathHandler {
 export const commonChannelPathHandler = new CommonChannelPathHandler();
 
 export abstract class BaseCommonChannelHandler {
-  protected channelMap: Map<string, WSServerChannel> = new Map();
+  protected channelMap: Map<string, WSChannel> = new Map();
 
-  protected heartbeatTimer: NodeJS.Timeout | null = null;
+  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 = global.setTimeout(() => {
-      this.doHeartbeat(connection);
-      this.heartbeat(connection);
-    }, 5000);
+    this.heartbeatTimer = timer;
   }
 
   receiveConnection(connection: IConnectionShape<Uint8Array>) {
     let clientId: string;
     this.heartbeat(connection);
 
-    const getOrCreateChannel = (id: string, clientId: string) => {
-      let channel = this.channelMap.get(id);
-      if (!channel) {
-        channel = new WSServerChannel(connection, { id, clientId, logger: this.logger });
-        this.channelMap.set(id, channel);
-      }
-      return channel;
-    };
-
     connection.onMessage((data: Uint8Array) => {
       let msg: ChannelMessage;
       try {
@@ -148,30 +133,23 @@ export abstract class BaseCommonChannelHandler {
             connection.send(pongMessage);
             break;
           case 'open': {
-            const { id, path, connectionToken } = msg;
+            const { id, path } = msg;
             clientId = msg.clientId;
             this.logger.log(`open a new connection channel ${clientId} with path ${path}`);
-            const channel = getOrCreateChannel(id, clientId);
-            commonChannelPathHandler.openChannel(path, channel, clientId);
-            channel.serverReady(connectionToken);
+
+            const channel = new WSServerChannel(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.dispatch(msg);
             } else {
-              connection.send(
-                stringify({
-                  kind: 'error',
-                  id,
-                  code: ErrorMessageCode.ChannelNotFound,
-                  message: `channel ${id} not found`,
-                }),
-              );
-
               this.logger.warn(`channel ${id} is not found`);
             }
           }
@@ -182,11 +160,10 @@ export abstract class BaseCommonChannelHandler {
     });
 
     connection.onceClose(() => {
-      this.logger.log(`connection ${clientId} is closed, dispose all channels`);
       commonChannelPathHandler.disposeConnectionClientId(connection, clientId);
 
       Array.from(this.channelMap.values())
-        .filter((channel) => channel.clientId === clientId)
+        .filter((channel) => channel.id.toString().indexOf(clientId) !== -1)
         .forEach((channel) => {
           channel.close(1, 'close');
           channel.dispose();