@opensumi/ide-connection 3.0.4 → 3.0.5-next-1717466130.0

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

@@ -1,6 +1,6 @@
 import { DisposableStore, Emitter, IDisposable } from '@opensumi/ide-core-common';
 
-import { MessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
+import { IMessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
 import { RPCServiceMethod } from '../types';
 
 const skipMethods = new Set(['constructor']);
@@ -119,13 +119,21 @@ export class ProtocolRegistry {
     this.emitter.fire(serviceNames);
   }
 
-  applyTo(io: MessageIO) {
+  applyTo(io: IMessageIO) {
+    if (!io.loadProtocolMethod) {
+      return;
+    }
+
     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/serializer/fury.ts

@@ -0,0 +1,61 @@
+import { Type } from '@furyjs/fury';
+
+import { ChannelMessage } from '../channel/types';
+import { oneOf } from '../fury-extends/one-of';
+
+import { ISerializer } from './types';
+
+export const PingProtocol = Type.object('ping', {
+  id: Type.string(),
+});
+
+export const PongProtocol = Type.object('pong', {
+  id: Type.string(),
+});
+
+export const OpenProtocol = Type.object('open', {
+  clientId: Type.string(),
+  id: Type.string(),
+  path: Type.string(),
+  connectionToken: Type.string(),
+});
+
+export const ServerReadyProtocol = Type.object('server-ready', {
+  id: Type.string(),
+  token: Type.string(),
+});
+
+export const ErrorProtocol = Type.object('error', {
+  id: Type.string(),
+  code: Type.uint16(),
+  message: Type.string(),
+});
+
+export const DataProtocol = Type.object('data', {
+  id: Type.string(),
+  content: Type.string(),
+});
+
+export const BinaryProtocol = Type.object('binary', {
+  id: Type.string(),
+  binary: Type.binary(),
+});
+
+export const CloseProtocol = Type.object('close', {
+  id: Type.string(),
+  code: Type.uint32(),
+  reason: Type.string(),
+});
+
+const serializer = oneOf([
+  PingProtocol,
+  PongProtocol,
+  OpenProtocol,
+  ServerReadyProtocol,
+  DataProtocol,
+  BinaryProtocol,
+  CloseProtocol,
+  ErrorProtocol,
+]);
+
+export const furySerializer: ISerializer<ChannelMessage, Uint8Array> = serializer;

package/src/common/serializer/index.ts

@@ -0,0 +1,24 @@
+import { IConnectionShape } from '../connection/types';
+
+import { ISerializer } from './types';
+
+export * from './fury';
+export * from './raw';
+export * from './types';
+
+export const wrapSerializer = <FROM, TO>(
+  connection: IConnectionShape<TO>,
+  serializer: ISerializer<FROM, TO>,
+): IConnectionShape<FROM> => ({
+  onceClose(cb) {
+    return connection.onceClose(cb);
+  },
+  onMessage(cb) {
+    return connection.onMessage((data) => {
+      cb(serializer.deserialize(data));
+    });
+  },
+  send(data) {
+    connection.send(serializer.serialize(data));
+  },
+});

package/src/common/serializer/raw.ts

@@ -0,0 +1,8 @@
+import { ChannelMessage } from '../channel';
+
+import { ISerializer } from './types';
+
+export const rawSerializer: ISerializer<ChannelMessage, ChannelMessage> = {
+  serialize: (message) => message,
+  deserialize: (message) => message,
+};

package/src/common/serializer/types.ts

@@ -0,0 +1,4 @@
+export interface ISerializer<FROM, TO> {
+  serialize(data: FROM): TO;
+  deserialize(data: TO): FROM;
+}

package/src/common/server-handler.ts

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

package/src/common/ws-channel.ts

@@ -1,60 +1,11 @@
-import { Type } from '@furyjs/fury';
-
 import { EventEmitter } from '@opensumi/events';
-import {
-  DisposableCollection,
-  DisposableStore,
-  EventQueue,
-  StateTracer,
-  randomString,
-} from '@opensumi/ide-core-common';
+import { DisposableStore, EventQueue, StateTracer, randomString } from '@opensumi/ide-core-common';
 
+import { ChannelMessage, ErrorMessageCode } from './channel/types';
 import { IConnectionShape } from './connection/types';
-import { oneOf } from './fury-extends/one-of';
 import { ISumiConnectionOptions, SumiConnection } from './rpc/connection';
 import { ILogger } from './types';
 
-/**
- * `ping` and `pong` are used to detect whether the connection is alive.
- */
-export interface PingMessage {
-  kind: 'ping';
-  id: string;
-  clientId: string;
-}
-
-/**
- * when server receive a `ping` message, it should reply a `pong` message, vice versa.
- */
-export interface PongMessage {
-  kind: 'pong';
-  id: string;
-  clientId: 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: string;
-  content: string;
-}
-
-export interface BinaryMessage {
-  kind: 'binary';
-  id: string;
-  binary: Uint8Array;
-}
-
-export interface CloseMessage {
-  kind: 'close';
-  id: string;
-  code: number;
-  reason: string;
-}
-
 export interface IWSChannelCreateOptions {
   /**
    * every channel's unique id, it only used in client to server architecture.
@@ -80,37 +31,23 @@ export class WSChannel {
 
   protected onBinaryQueue = this._disposables.add(new EventQueue<Uint8Array>());
 
-  protected sendQueue: Uint8Array[] = [];
+  protected sendQueue: ChannelMessage[] = [];
   protected _isServerReady = false;
   protected _ensureServerReady: boolean | undefined;
 
   public id: string;
 
   public channelPath: string;
+  public clientId: string;
 
-  logger: ILogger = console;
-
-  static forClient(connection: IConnectionShape<Uint8Array>, options: IWSChannelCreateOptions) {
-    const disposable = new DisposableCollection();
-    const channel = new WSChannel(connection, options);
-
-    disposable.push(
-      connection.onMessage((data) => {
-        channel.dispatch(parse(data));
-      }),
-    );
+  protected LOG_TAG = '[WSChannel]';
 
-    connection.onceClose(() => {
-      disposable.dispose();
-    });
-
-    return channel;
-  }
+  logger: ILogger = console;
 
-  constructor(public connection: IConnectionShape<Uint8Array>, options: IWSChannelCreateOptions) {
+  constructor(public connection: IConnectionShape<ChannelMessage>, options: IWSChannelCreateOptions) {
     const { id, logger, ensureServerReady } = options;
     this.id = id;
-
+    this.LOG_TAG = `[WSChannel id:${this.id}]`;
     if (logger) {
       this.logger = logger;
     }
@@ -120,7 +57,7 @@ export class WSChannel {
     this._disposables.add(this.emitter.on('binary', (data) => this.onBinaryQueue.push(data)));
   }
 
-  protected inqueue(data: Uint8Array) {
+  protected inqueue(data: ChannelMessage) {
     if (this._ensureServerReady && !this._isServerReady) {
       if (!this.sendQueue) {
         this.sendQueue = [];
@@ -182,6 +119,20 @@ export class WSChannel {
       case 'binary':
         this.emitter.emit('binary', msg.binary);
         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:
+            // 有 channelPath 说明该 channel 曾经被打开过
+            // 重新打开 channel
+            if (this.channelPath) {
+              // 暂停消息发送, 直到收到 server-ready
+              this.pause();
+              this.open(this.channelPath, this.clientId);
+            }
+            break;
+        }
+        break;
     }
   }
 
@@ -192,6 +143,9 @@ export class WSChannel {
    */
   open(path: string, clientId: string, connectionToken = randomString(16)) {
     this.channelPath = path;
+    this.clientId = clientId;
+
+    this.LOG_TAG = `[WSChannel id=${this.id} path=${path}]`;
 
     if (this.stateTracer.has(connectionToken)) {
       this.logger.warn(
@@ -202,15 +156,13 @@ export class WSChannel {
 
     this.stateTracer.record(connectionToken);
 
-    this.connection.send(
-      stringify({
-        kind: 'open',
-        id: this.id,
-        path,
-        clientId,
-        connectionToken,
-      }),
-    );
+    this.connection.send({
+      kind: 'open',
+      id: this.id,
+      path,
+      clientId,
+      connectionToken,
+    });
 
     if (this._ensureServerReady) {
       this.ensureOpenSend(path, clientId, connectionToken);
@@ -237,23 +189,19 @@ export class WSChannel {
   }
 
   send(content: string) {
-    this.inqueue(
-      stringify({
-        kind: 'data',
-        id: this.id,
-        content,
-      }),
-    );
+    this.inqueue({
+      kind: 'data',
+      id: this.id,
+      content,
+    });
   }
 
   sendBinary(data: Uint8Array) {
-    this.inqueue(
-      stringify({
-        kind: 'binary',
-        id: this.id,
-        binary: data,
-      }),
-    );
+    this.inqueue({
+      kind: 'binary',
+      id: this.id,
+      binary: data,
+    });
   }
   onError() {}
   close(code?: number, reason?: string) {
@@ -293,6 +241,13 @@ export class WSChannel {
     this.sendQueue = [];
     this._disposables.dispose();
   }
+
+  ping() {
+    this.connection.send({
+      kind: 'ping',
+      id: this.id,
+    });
+  }
 }
 
 interface IWSServerChannelCreateOptions extends IWSChannelCreateOptions {
@@ -306,18 +261,17 @@ export class WSServerChannel extends WSChannel {
   messageQueue: ChannelMessage[] = [];
 
   clientId: string;
-  constructor(public connection: IConnectionShape<Uint8Array>, options: IWSServerChannelCreateOptions) {
+  constructor(public connection: IConnectionShape<ChannelMessage>, options: IWSServerChannelCreateOptions) {
     super(connection, options);
     this.clientId = options.clientId;
   }
+
   serverReady(token: string) {
-    this.connection.send(
-      stringify({
-        kind: 'server-ready',
-        id: this.id,
-        token,
-      }),
-    );
+    this.connection.send({
+      kind: 'server-ready',
+      id: this.id,
+      token,
+    });
   }
 
   dispatch(msg: ChannelMessage) {
@@ -328,128 +282,12 @@ export class WSServerChannel extends WSChannel {
       case 'binary':
         this.emitter.emit('binary', msg.binary);
         break;
+      case 'ping':
+        this.connection.send({
+          kind: 'pong',
+          id: this.id,
+        });
+        break;
     }
   }
 }
-
-export type ChannelMessage =
-  | PingMessage
-  | PongMessage
-  | OpenMessage
-  | ServerReadyMessage
-  | DataMessage
-  | BinaryMessage
-  | CloseMessage
-  | ErrorMessage;
-
-export const PingProtocol = Type.object('ping', {
-  clientId: Type.string(),
-  id: Type.string(),
-});
-
-export const PongProtocol = Type.object('pong', {
-  clientId: Type.string(),
-  id: Type.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: string;
-  path: string;
-  clientId: string;
-  connectionToken: string;
-}
-
-export const OpenProtocol = Type.object('open', {
-  clientId: Type.string(),
-  id: Type.string(),
-  path: Type.string(),
-  connectionToken: Type.string(),
-});
-
-/**
- * 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;
-  token: string;
-}
-
-export const ServerReadyProtocol = Type.object('server-ready', {
-  id: Type.string(),
-  token: Type.string(),
-});
-
-export enum ErrorMessageCode {
-  ChannelNotFound = 1,
-}
-
-export interface ErrorMessage {
-  kind: 'error';
-  id: string;
-  code: ErrorMessageCode;
-  message: string;
-}
-
-export const ErrorProtocol = Type.object('error', {
-  id: Type.string(),
-  code: Type.uint16(),
-  message: Type.string(),
-});
-
-export const DataProtocol = Type.object('data', {
-  id: Type.string(),
-  content: Type.string(),
-});
-
-export const BinaryProtocol = Type.object('binary', {
-  id: Type.string(),
-  binary: Type.binary(),
-});
-
-export const CloseProtocol = Type.object('close', {
-  id: Type.string(),
-  code: Type.uint32(),
-  reason: Type.string(),
-});
-
-const serializer = oneOf([
-  PingProtocol,
-  PongProtocol,
-  OpenProtocol,
-  ServerReadyProtocol,
-  DataProtocol,
-  BinaryProtocol,
-  CloseProtocol,
-  ErrorProtocol,
-]);
-
-export function stringify(obj: ChannelMessage): Uint8Array {
-  return serializer.serialize(obj);
-}
-
-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);