@opensumi/ide-connection 3.0.4-next-1716970216.0 → 3.0.4-next-1717045696.0

package/src/browser/ws-channel-handler.ts

@@ -1,17 +1,9 @@
 import { EventEmitter } from '@opensumi/events';
 import { Barrier, Deferred, DisposableStore, IReporterService, MultiMap, REPORT_NAME } from '@opensumi/ide-core-common';
 
-import { ChannelMessage } from '../common/channel/types';
 import { IRuntimeSocketConnection } from '../common/connection';
-import { IConnectionShape } from '../common/connection/types';
-import { ISerializer, furySerializer, wrapSerializer } from '../common/serializer';
-import { ConnectionInfo, ILogger, WSCloseInfo } from '../common/types';
-import { WSChannel } from '../common/ws-channel';
-
-export interface WSChannelHandlerOptions {
-  logger?: ILogger;
-  channelSerializer?: ISerializer<ChannelMessage, any>;
-}
+import { ConnectionInfo, WSCloseInfo } from '../common/types';
+import { ErrorMessageCode, WSChannel, parse, pingMessage } from '../common/ws-channel';
 
 /**
  * Channel Handler in browser
@@ -20,15 +12,13 @@ export class WSChannelHandler {
   private _disposables = new DisposableStore();
 
   private _onChannelCreatedEmitter = this._disposables.add(new EventEmitter<Record<string, [WSChannel]>>());
-
-  wrappedConnection: IConnectionShape<ChannelMessage>;
   public onChannelCreated(path: string, listener: (channel: WSChannel) => void) {
     return this._onChannelCreatedEmitter.on(path, listener);
   }
 
   private channelMap: Map<string, WSChannel> = new Map();
   private channelCloseEventMap = new MultiMap<string, WSCloseInfo>();
-  private logger: ILogger = console;
+  private logger = console;
   public clientId: string;
   private heartbeatMessageTimer: NodeJS.Timeout | null;
   private reporterService: IReporterService;
@@ -40,16 +30,10 @@ export class WSChannelHandler {
 
   LOG_TAG: string;
 
-  constructor(
-    public connection: IRuntimeSocketConnection<Uint8Array>,
-    clientId: string,
-    options: WSChannelHandlerOptions = {},
-  ) {
-    this.logger = options.logger || this.logger;
+  constructor(public connection: IRuntimeSocketConnection<Uint8Array>, logger: any, clientId: string) {
+    this.logger = logger || this.logger;
     this.clientId = clientId;
     this.LOG_TAG = `[WSChannelHandler] [client-id:${this.clientId}]`;
-    const serializer = options.channelSerializer || furySerializer;
-    this.wrappedConnection = wrapSerializer(this.connection, serializer);
   }
   // 为解决建立连接之后，替换成可落盘的 logger
   replaceLogger(logger: any) {
@@ -65,24 +49,37 @@ export class WSChannelHandler {
       clearTimeout(this.heartbeatMessageTimer);
     }
     this.heartbeatMessageTimer = global.setTimeout(() => {
-      this.channelMap.forEach((channel) => {
-        channel.ping();
-      });
-
+      this.connection.send(pingMessage);
       this.heartbeatMessage();
     }, 10 * 1000);
   }
 
   public async initHandler() {
-    this.wrappedConnection.onMessage((msg) => {
+    this.connection.onMessage((message) => {
       // 一个心跳周期内如果有收到消息，则不需要再发送心跳
       this.heartbeatMessage();
 
+      const msg = parse(message);
+
       switch (msg.kind) {
         case 'pong':
-          // pong 不需要分发, 不处理
+          // pong 没有 msg.id, 且不需要分发, 不处理
+          break;
+        case 'error':
+          this.logger.error(this.LOG_TAG, `receive error: id: ${msg.id}, code: ${msg.code}, error: ${msg.message}`);
+          switch (msg.code) {
+            case ErrorMessageCode.ChannelNotFound:
+              if (this.channelMap.has(msg.id)) {
+                // 如果远程报错 channel 不存在但是本机存在，则重新打开
+                const channel = this.channelMap.get(msg.id)!;
+                if (channel.channelPath) {
+                  channel.pause();
+                  channel.open(channel.channelPath, this.clientId);
+                }
+              }
+              break;
+          }
           break;
-
         default: {
           const channel = this.channelMap.get(msg.id);
           if (channel) {
@@ -141,7 +138,7 @@ export class WSChannelHandler {
       this.logger.log(this.LOG_TAG, `channel ${key} already exists, dispose it`);
     }
 
-    const channel = new WSChannel(this.wrappedConnection, {
+    const channel = new WSChannel(this.connection, {
       id: key,
       logger: this.logger,
       ensureServerReady: true,

package/src/common/connection/drivers/simple.ts

@@ -2,19 +2,19 @@ import { IDisposable } from '@opensumi/ide-core-common';
 
 import { BaseConnection } from './base';
 
-export class SimpleConnection<T = Uint8Array> extends BaseConnection<T> {
+export class SimpleConnection extends BaseConnection<Uint8Array> {
   constructor(
     public options: {
-      send?: (data: T) => void;
-      onMessage?: (cb: (data: T) => void) => IDisposable;
+      send?: (data: Uint8Array) => void;
+      onMessage?: (cb: (data: Uint8Array) => void) => IDisposable;
     } = {},
   ) {
     super();
   }
-  send(data: T): void {
+  send(data: Uint8Array): void {
     this.options.send?.(data);
   }
-  onMessage(cb: (data: T) => void): IDisposable {
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
     if (this.options.onMessage) {
       return this.options.onMessage(cb);
     }

package/src/common/index.ts

@@ -1,11 +1,7 @@
 export * from './rpc-service/proxy';
-export * from './rpc-service';
 export * from './rpc/multiplexer';
 export * from './rpcProtocol';
 export * from './capturer';
 export * from './ws-channel';
 export * from './connect';
 export * from './types';
-export * from './connection';
-export * from './serializer';
-export * from './channel';

package/src/common/rpc/connection.ts

@@ -5,6 +5,7 @@ import {
   DisposableStore,
   IDisposable,
   canceled,
+  parseError,
 } from '@opensumi/ide-utils';
 import { SumiReadableStream, isReadableStream, listenReadable } from '@opensumi/ide-utils/lib/stream';
 
@@ -14,8 +15,9 @@ import { METHOD_NOT_REGISTERED } from '../constants';
 import { ILogger } from '../types';
 
 import { MethodTimeoutError } from './errors';
-import { BaseMessageIO, MessageIO, OperationType, RPCErrorMessage, RPCResponseMessage } from './message-io';
+import { MessageIO, OperationType, Status } from './message-io';
 import {
+  IRequestHeaders,
   IResponseHeaders,
   TGenericNotificationHandler,
   TGenericRequestHandler,
@@ -36,8 +38,6 @@ export interface ISumiConnectionOptions {
    * The name of the connection, used for debugging(and can see in opensumi-devtools).
    */
   name?: string;
-
-  io?: BaseMessageIO;
 }
 
 const chunkedResponseHeaders: IResponseHeaders = {
@@ -61,7 +61,7 @@ export class SumiConnection implements IDisposable {
 
   protected activeRequestPool = new Map<number, SumiReadableStream<any>>();
 
-  public io: BaseMessageIO;
+  public io = new MessageIO();
   protected logger: ILogger;
 
   protected capturer: Capturer;
@@ -73,8 +73,6 @@ export class SumiConnection implements IDisposable {
       this.logger = getDebugLogger();
     }
 
-    this.io = options.io || new MessageIO();
-
     this.capturer = new Capturer(options.name || 'sumi');
     this.disposable.add(this.capturer);
   }
@@ -195,28 +193,35 @@ export class SumiConnection implements IDisposable {
   }
 
   listen() {
+    const { reader } = this.io;
+
     this.disposable.add(
       this.socket.onMessage((data) => {
-        const message = this.io.readMessage(data);
-        const opType = message.kind;
-        const requestId = message.requestId;
+        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)) {
-          clearTimeout(this._timeoutHandles.get(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.Error:
           case OperationType.Response: {
-            const { headers, method } = message;
-            const err = (message as RPCErrorMessage).error;
-            const result = (message as RPCResponseMessage).result;
+            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}`);
+                this.logger.error(`Cannot find callback for request ${requestId}: ${method}, status: ${status}`);
                 return;
               }
 
@@ -225,6 +230,17 @@ export class SumiConnection implements IDisposable {
               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();
+            }
+
             if (headers && headers.chunked) {
               let activeReq: SumiReadableStream<any>;
               if (this.activeRequestPool.has(requestId)) {
@@ -259,7 +275,9 @@ export class SumiConnection implements IDisposable {
           case OperationType.Notification:
           // fall through
           case OperationType.Request: {
-            const { method, headers, args } = message;
+            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();
@@ -303,17 +321,16 @@ export class SumiConnection implements IDisposable {
                       },
                       onEnd: () => {
                         this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, null));
-                        this._cancellationTokenSources.delete(requestId);
                       },
                       onError: (err) => {
                         this.socket.send(this.io.Error(requestId, method, chunkedResponseHeaders, err));
-                        this._cancellationTokenSources.delete(requestId);
                       },
                     });
                   } else {
                     this.socket.send(this.io.Response(requestId, method, nullHeaders, result));
-                    this._cancellationTokenSources.delete(requestId);
                   }
+
+                  this._cancellationTokenSources.delete(requestId);
                 };
 
                 const onError = (err: Error) => {

package/src/common/rpc/message-io.ts

@@ -1,9 +1,8 @@
 import Fury, { Serializer, Type, TypeDescription } from '@furyjs/fury';
 import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
-import { PlatformBuffer } from '@furyjs/fury/dist/lib/platformBuffer';
 import { BinaryReader, BinaryWriter } from '@furyjs/fury/dist/lib/type';
 
-import { parseError, stringifyError } from '@opensumi/ide-core-common/lib/utils';
+import { stringifyError } from '@opensumi/ide-core-common/lib/utils';
 
 import { AnySerializer, IObjectTransfer } from '../fury-extends/any';
 import { furyFactory } from '../fury-extends/shared';
@@ -25,7 +24,11 @@ export enum OperationType {
   Notification,
   Response,
   Cancel,
-  Error,
+}
+
+export enum Status {
+  OK,
+  Err,
 }
 
 export const HeadersProto = {
@@ -42,7 +45,6 @@ const PacketPrefix = {
   Notification: (OperationType.Notification << 8) | ProtoVersionV1,
   Response: (OperationType.Response << 8) | ProtoVersionV1,
   Cancel: (OperationType.Cancel << 8) | ProtoVersionV1,
-  Error: (OperationType.Error << 8) | ProtoVersionV1,
 } as const;
 
 class SumiProtocolSerializer implements IProtocolSerializer {
@@ -103,66 +105,7 @@ export class AnyProtocolSerializer implements IProtocolSerializer {
   }
 }
 
-export interface RPCRequestMessage {
-  kind: OperationType.Request;
-  requestId: number;
-  method: string;
-  headers: IRequestHeaders;
-  args: any[];
-}
-
-export interface RPCNotificationMessage {
-  kind: OperationType.Notification;
-  requestId: number;
-  method: string;
-  headers: IRequestHeaders;
-  args: any[];
-}
-
-export interface RPCResponseMessage {
-  kind: OperationType.Response;
-  requestId: number;
-  method: string;
-  headers: Record<string, any>;
-  result: any;
-}
-
-export interface RPCErrorMessage {
-  kind: OperationType.Error;
-  requestId: number;
-  method: string;
-  headers: Record<string, any>;
-  error: any;
-}
-
-export interface RPCCancelMessage {
-  kind: OperationType.Cancel;
-  requestId: number;
-}
-
-export type RPCMessage =
-  | RPCRequestMessage
-  | RPCNotificationMessage
-  | RPCResponseMessage
-  | RPCErrorMessage
-  | RPCCancelMessage;
-
-export abstract class BaseMessageIO<T = any> {
-  abstract loadProtocolMethod?(
-    methodProtocol: TSumiProtocolMethod,
-    options?: { nameConverter?: (str: string) => string },
-  ): void;
-
-  abstract Request(requestId: number, method: string, headers: IRequestHeaders, args: any[]): T;
-  abstract Notification(requestId: number, method: string, headers: IRequestHeaders, args: any[]): T;
-  abstract Cancel(requestId: number): T;
-  abstract Response(requestId: number, method: string, headers: Record<string, any>, result: any): T;
-  abstract Error(requestId: number, method: string, headers: Record<string, any>, error: any): T;
-
-  abstract readMessage(data: T): RPCMessage;
-}
-
-export class MessageIO extends BaseMessageIO<PlatformBuffer> {
+export class MessageIO {
   fury: Fury;
   reader: BinaryReader;
   writer: BinaryWriter;
@@ -175,7 +118,6 @@ export class MessageIO extends BaseMessageIO<PlatformBuffer> {
   responseHeadersSerializer: Serializer<IResponseHeaders, IRequestHeaders>;
 
   constructor() {
-    super();
     const fury = furyFactory();
     this.fury = fury.fury;
     this.reader = fury.reader;
@@ -274,6 +216,7 @@ export class MessageIO extends BaseMessageIO<PlatformBuffer> {
     writer.uint16(PacketPrefix.Response);
     writer.uint32(requestId);
     writer.stringOfVarUInt32(method);
+    writer.uint16(Status.OK);
     this.responseHeadersSerializer.write(headers);
     this.getProcessor(method).writeResponse(result);
 
@@ -284,69 +227,13 @@ export class MessageIO extends BaseMessageIO<PlatformBuffer> {
     const { writer } = this;
     writer.reset();
 
-    writer.uint16(PacketPrefix.Error);
+    writer.uint16(PacketPrefix.Response);
     writer.uint32(requestId);
     writer.stringOfVarUInt32(method);
+    writer.uint16(Status.Err);
     this.responseHeadersSerializer.write(headers);
     writer.stringOfVarUInt32(stringifyError(error));
 
     return writer.dump();
   }
-
-  readMessage(data: PlatformBuffer): RPCMessage {
-    const { reader } = this;
-    reader.reset(data);
-
-    // skip version, currently only have version 1
-    reader.skip(1);
-    const opType = reader.uint8() as OperationType;
-    const requestId = reader.uint32();
-
-    switch (opType) {
-      case OperationType.Request:
-      case OperationType.Notification: {
-        const method = reader.stringOfVarUInt32();
-        const headers = this.requestHeadersSerializer.read() as IRequestHeaders;
-        const args = this.getProcessor(method).readRequest();
-        return {
-          kind: opType,
-          requestId,
-          method,
-          headers,
-          args,
-        };
-      }
-      case OperationType.Error: {
-        const method = reader.stringOfVarUInt32();
-        const headers = this.responseHeadersSerializer.read() as IResponseHeaders;
-        const error = parseError(reader.stringOfVarUInt32());
-        return {
-          kind: OperationType.Error,
-          requestId,
-          method,
-          headers,
-          error,
-        };
-      }
-      case OperationType.Response: {
-        const method = reader.stringOfVarUInt32();
-        const headers = this.responseHeadersSerializer.read() as IResponseHeaders;
-        const result = this.getProcessor(method).readResponse();
-        return {
-          kind: OperationType.Response,
-          requestId,
-          method,
-          headers,
-          result,
-        };
-      }
-      case OperationType.Cancel:
-        return {
-          kind: OperationType.Cancel,
-          requestId,
-        };
-      default:
-        throw new Error(`Unknown message type: ${opType}`);
-    }
-  }
 }

package/src/common/rpc/multiplexer.ts

@@ -2,7 +2,7 @@ import { BaseConnection } from '../connection';
 import { ExtObjectTransfer } from '../fury-extends/any';
 
 import { ISumiConnectionOptions, SumiConnection } from './connection';
-import { AnyProtocolSerializer, MessageIO } from './message-io';
+import { AnyProtocolSerializer } from './message-io';
 import { TSumiProtocol } from './types';
 
 export class ProxyIdentifier<T = any> {
@@ -34,12 +34,6 @@ export interface IRPCProtocol {
   get<T>(identifier: ProxyIdentifier<T>): T;
 }
 
-function createExtMessageIO() {
-  const io = new MessageIO();
-  io.setAnySerializer(new AnyProtocolSerializer(io.writer, io.reader, ExtObjectTransfer));
-  return io;
-}
-
 /**
  * A connection multiplexer that allows to register multiple local RPC services and to create proxies for them.
  */
@@ -63,16 +57,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>;
-  io: MessageIO;
 
   constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiMultiplexerConnectionOptions = {}) {
-    super(socket, {
-      ...options,
-      io: createExtMessageIO(),
-    });
+    super(socket, options);
     this._locals = new Map();
     this._proxies = new Map();
     this._knownProtocols = options.knownProtocols || {};
+    this.io.setAnySerializer(new AnyProtocolSerializer(this.io.writer, this.io.reader, ExtObjectTransfer));
 
     this.onRequestNotFound((rpcName: string, args: any[]) => this.invoke(rpcName, args));
 

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

@@ -1,6 +1,5 @@
 export * from './stub';
 export * from './center';
-export * from './registry';
 
 export abstract class RPCService<T = any> {
   rpcClient?: T[];

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

@@ -1,6 +1,6 @@
 import { DisposableStore, Emitter, IDisposable } from '@opensumi/ide-core-common';
 
-import { BaseMessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
+import { MessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
 import { RPCServiceMethod } from '../types';
 
 const skipMethods = new Set(['constructor']);
@@ -119,21 +119,13 @@ export class ProtocolRegistry {
     this.emitter.fire(serviceNames);
   }
 
-  applyTo(io: BaseMessageIO) {
-    if (!io.loadProtocolMethod) {
-      return;
-    }
-
+  applyTo(io: MessageIO) {
     for (const protocol of this.protocolMap.values()) {
       io.loadProtocolMethod(protocol);
     }
 
     this._disposables.add(
       this.onProtocolUpdate((methods) => {
-        if (!io.loadProtocolMethod) {
-          return;
-        }
-
         for (const method of methods) {
           const protocol = this.protocolMap.get(method);
           if (protocol) {

package/src/common/server-handler.ts

@@ -1,9 +1,14 @@
-import { ChannelMessage, ErrorMessageCode } from './channel/types';
 import { IConnectionShape } from './connection/types';
-import { furySerializer, wrapSerializer } from './serializer';
-import { ISerializer } from './serializer/types';
 import { ILogger } from './types';
-import { WSChannel, WSServerChannel } from './ws-channel';
+import {
+  ChannelMessage,
+  ErrorMessageCode,
+  WSChannel,
+  WSServerChannel,
+  parse,
+  pongMessage,
+  stringify,
+} from './ws-channel';
 
 export interface IPathHandler {
   dispose: (channel: WSChannel, connectionId: string) => void;
@@ -100,21 +105,12 @@ export class CommonChannelPathHandler {
 
 export const commonChannelPathHandler = new CommonChannelPathHandler();
 
-export interface ChannelHandlerOptions {
-  serializer?: ISerializer<ChannelMessage, any>;
-}
-
 export abstract class BaseCommonChannelHandler {
   protected channelMap: Map<string, WSServerChannel> = new Map();
 
   protected heartbeatTimer: NodeJS.Timeout | null = null;
 
-  serializer: ISerializer<ChannelMessage, any> = furySerializer;
-  constructor(public handlerId: string, protected logger: ILogger = console, options: ChannelHandlerOptions = {}) {
-    if (options.serializer) {
-      this.serializer = options.serializer;
-    }
-  }
+  constructor(public handlerId: string, protected logger: ILogger = console) {}
 
   abstract doHeartbeat(connection: any): void;
 
@@ -133,20 +129,24 @@ export abstract class BaseCommonChannelHandler {
     let clientId: string;
     this.heartbeat(connection);
 
-    const wrappedConnection = wrapSerializer(connection, this.serializer);
-
     const getOrCreateChannel = (id: string, clientId: string) => {
       let channel = this.channelMap.get(id);
       if (!channel) {
-        channel = new WSServerChannel(wrappedConnection, { id, clientId, logger: this.logger });
+        channel = new WSServerChannel(connection, { id, clientId, logger: this.logger });
         this.channelMap.set(id, channel);
       }
       return channel;
     };
 
-    wrappedConnection.onMessage((msg: ChannelMessage) => {
+    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, connectionToken } = msg;
             clientId = msg.clientId;
@@ -163,12 +163,14 @@ export abstract class BaseCommonChannelHandler {
             if (channel) {
               channel.dispatch(msg);
             } else {
-              wrappedConnection.send({
-                kind: 'error',
-                id,
-                code: ErrorMessageCode.ChannelNotFound,
-                message: `channel ${id} not found`,
-              });
+              connection.send(
+                stringify({
+                  kind: 'error',
+                  id,
+                  code: ErrorMessageCode.ChannelNotFound,
+                  message: `channel ${id} not found`,
+                }),
+              );
 
               this.logger.warn(`channel ${id} is not found`);
             }