@opensumi/ide-connection 2.21.9-rc-1671176957.0 → 2.21.9

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@opensumi/ide-connection",
-  "version": "2.21.9-rc-1671176957.0",
+  "version": "2.21.9",
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "license": "MIT",
   "main": "lib/index.js",
@@ -17,15 +16,15 @@
     "url": "git@github.com:opensumi/core.git"
   },
   "dependencies": {
-    "@opensumi/ide-core-common": "2.21.9-rc-1671176957.0",
+    "@opensumi/ide-core-common": "2.21.9",
     "@opensumi/vscode-jsonrpc": "^8.0.0-next.2",
     "path-match": "^1.2.4",
     "ws": "^8.9.0"
   },
   "devDependencies": {
-    "@opensumi/ide-components": "2.21.9-rc-1671176957.0",
+    "@opensumi/ide-components": "2.21.9",
     "@opensumi/ide-dev-tool": "^1.3.1",
     "mock-socket": "^9.0.2"
   },
-  "gitHead": "81fe16f43c329c633bd8b2eeb737363c8f4e7110"
+  "gitHead": "6038a6faa5ad85bfb5acb721c1d39190fe674555"
 }

package/src/browser/index.ts

@@ -1 +0,0 @@
-export * from './ws-channel-handler';

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

@@ -1,124 +0,0 @@
-import ReconnectingWebSocket from 'reconnecting-websocket';
-
-import { uuid } from '@opensumi/ide-core-common';
-import { IReporterService, REPORT_NAME, UrlProvider } from '@opensumi/ide-core-common';
-
-import { stringify, parse } from '../common/utils';
-import { WSChannel, MessageString } from '../common/ws-channel';
-
-// 前台链接管理类
-export class WSChannelHandler {
-  public connection: WebSocket;
-  private channelMap: Map<number | string, WSChannel> = new Map();
-  private logger = console;
-  public clientId: string;
-  private heartbeatMessageTimer: NodeJS.Timer | null;
-  private reporterService: IReporterService;
-
-  constructor(public wsPath: UrlProvider, logger: any, public protocols?: string[], clientId?: string) {
-    this.logger = logger || this.logger;
-    this.clientId = clientId || `CLIENT_ID_${uuid()}`;
-    this.connection = new ReconnectingWebSocket(wsPath, protocols, {}) as WebSocket; // new WebSocket(wsPath, protocols);
-  }
-  // 为解决建立连接之后，替换成可落盘的 logger
-  replaceLogger(logger: any) {
-    if (logger) {
-      this.logger = logger;
-    }
-  }
-  setReporter(reporterService: IReporterService) {
-    this.reporterService = reporterService;
-  }
-  private clientMessage() {
-    const clientMsg: MessageString = stringify({
-      kind: 'client',
-      clientId: this.clientId,
-    });
-    this.connection.send(clientMsg);
-  }
-  private heartbeatMessage() {
-    if (this.heartbeatMessageTimer) {
-      clearTimeout(this.heartbeatMessageTimer);
-    }
-    this.heartbeatMessageTimer = global.setTimeout(() => {
-      const msg = stringify({
-        kind: 'heartbeat',
-        clientId: this.clientId,
-      });
-      this.connection.send(msg);
-      this.heartbeatMessage();
-    }, 5000);
-  }
-
-  public async initHandler() {
-    this.connection.onmessage = (e) => {
-      // 一个心跳周期内如果有收到消息，则不需要再发送心跳
-      this.heartbeatMessage();
-
-      const msg = parse(e.data);
-
-      if (msg.id) {
-        const channel = this.channelMap.get(msg.id);
-        if (channel) {
-          if (msg.kind === 'data' && !(channel as any).fireMessage) {
-            // 要求前端发送初始化消息，但后端最先发送消息时，前端并未准备好
-            this.logger.error('channel not ready!', msg);
-          }
-          channel.handleMessage(msg);
-        } else {
-          this.logger.warn(`channel ${msg.id} not found`);
-        }
-      }
-    };
-    await new Promise((resolve) => {
-      this.connection.addEventListener('open', () => {
-        this.clientMessage();
-        this.heartbeatMessage();
-        resolve(undefined);
-        // 重连 channel
-        if (this.channelMap.size) {
-          this.channelMap.forEach((channel) => {
-            channel.onOpen(() => {
-              this.reporterService && this.reporterService.point(REPORT_NAME.CHANNEL_RECONNECT);
-              this.logger && this.logger.log(`channel reconnect ${this.clientId}:${channel.channelPath}`);
-            });
-            channel.open(channel.channelPath);
-
-            // 针对前端需要重新设置下后台状态的情况
-            if (channel.fireReOpen) {
-              channel.fireReOpen();
-            }
-          });
-        }
-      });
-    });
-  }
-  private getChannelSend = (connection) => (content: string) => {
-    connection.send(content, (err: Error) => {
-      if (err) {
-        this.logger.warn(err);
-      }
-    });
-  };
-  public async openChannel(channelPath: string) {
-    const channelSend = this.getChannelSend(this.connection);
-    const channelId = `${this.clientId}:${channelPath}`;
-    const channel = new WSChannel(channelSend, channelId);
-    this.channelMap.set(channel.id, channel);
-
-    await new Promise((resolve) => {
-      channel.onOpen(() => {
-        resolve(undefined);
-      });
-      channel.open(channelPath);
-    });
-
-    return channel;
-  }
-
-  public dispose() {
-    if (this.heartbeatMessageTimer) {
-      clearTimeout(this.heartbeatMessageTimer);
-    }
-  }
-}

package/src/common/connect.ts

@@ -1,199 +0,0 @@
-import { MessageConnection } from '@opensumi/vscode-jsonrpc/lib/common/connection';
-
-import { RPCProxy, NOTREGISTERMETHOD } from './proxy';
-
-export type RPCServiceMethod = (...args: any[]) => any;
-export type ServiceProxy = any;
-
-export enum ServiceType {
-  Service,
-  Stub,
-}
-
-export class RPCServiceStub {
-  constructor(private serviceName: string, private center, private type: ServiceType) {
-    if (this.type === ServiceType.Service) {
-      this.center.registerService(serviceName, this.type);
-    }
-  }
-
-  async ready() {
-    return this.center.when();
-  }
-  getNotificationName(name: string) {
-    return `on:${this.serviceName}:${name}`;
-  }
-  getRequestName(name: string) {
-    return `${this.serviceName}:${name}`;
-  }
-  // 服务方
-  on(name: string, method: RPCServiceMethod) {
-    this.onRequest(name, method);
-  }
-  getServiceMethod(service): string[] {
-    let props: any[] = [];
-
-    if (/^\s*class/.test(service.constructor.toString())) {
-      let obj = service;
-      do {
-        props = props.concat(Object.getOwnPropertyNames(obj));
-      } while ((obj = Object.getPrototypeOf(obj)));
-      props = props.sort().filter((e, i, arr) => e !== arr[i + 1] && typeof service[e] === 'function');
-    } else {
-      for (const prop in service) {
-        if (service[prop] && typeof service[prop] === 'function') {
-          props.push(prop);
-        }
-      }
-    }
-
-    return props;
-  }
-  onRequestService(service: any) {
-    const methods = this.getServiceMethod(service);
-    for (const method of methods) {
-      this.onRequest(method, service[method].bind(service));
-    }
-  }
-
-  onRequest(name: string, method: RPCServiceMethod) {
-    this.center.onRequest(this.getMethodName(name), method);
-  }
-  broadcast(name: string, ...args) {
-    return this.center.broadcast(this.getMethodName(name), ...args);
-  }
-
-  getMethodName(name: string) {
-    return name.startsWith('on') ? this.getNotificationName(name) : this.getRequestName(name);
-  }
-  getProxy = <T>() =>
-    new Proxy<RPCServiceStub & T>(this as any, {
-      // 调用方
-      get: (target, prop: string) => {
-        if (!target[prop]) {
-          if (typeof prop === 'symbol') {
-            return Promise.resolve();
-          } else {
-            return (...args) =>
-              this.ready().then(() => {
-                const name = this.getMethodName(prop);
-                return Promise.all(this.center.serviceProxy.map((proxy) => proxy[name](...args)))
-                  .then((result) => result.filter((res) => res !== NOTREGISTERMETHOD))
-                  .then((result) => (result.length === 1 ? result[0] : result));
-              });
-          }
-        } else {
-          return target[prop];
-        }
-      },
-    });
-}
-
-export function initRPCService<T = void>(center: RPCServiceCenter) {
-  return {
-    createRPCService: (name: string, service?: any) => {
-      const proxy = new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
-      if (service) {
-        proxy.onRequestService(service);
-      }
-
-      return proxy;
-    },
-    getRPCService: (name: string) => new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>(),
-  };
-}
-
-interface IBench {
-  registerService: (service: string) => void;
-}
-
-export interface RPCMessageConnection extends MessageConnection {
-  uid?: string;
-  writer?: any;
-  reader?: any;
-}
-
-export function createRPCService<T = void>(name: string, center: RPCServiceCenter): any {
-  return new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
-}
-
-export function getRPCService<T = void>(name: string, center: RPCServiceCenter): any {
-  return new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>();
-}
-
-export class RPCServiceCenter {
-  public uid: string;
-  public rpcProxy: RPCProxy[] = [];
-  public serviceProxy: ServiceProxy[] = [];
-  private connection: Array<MessageConnection> = [];
-  private serviceMethodMap = { client: undefined };
-
-  private createService: string[] = [];
-  private getService: string[] = [];
-
-  private connectionPromise: Promise<void>;
-  private connectionPromiseResolve: () => void;
-  private logger;
-
-  constructor(private bench?: IBench, logger?: any) {
-    this.uid = 'RPCServiceCenter:' + process.pid;
-    this.connectionPromise = new Promise((resolve) => {
-      this.connectionPromiseResolve = resolve;
-    });
-    this.logger = logger || console;
-  }
-
-  registerService(serviceName: string, type: ServiceType): void {
-    if (type === ServiceType.Service) {
-      this.createService.push(serviceName);
-      if (this.bench) {
-        this.bench.registerService(serviceName);
-      }
-    } else if (type === ServiceType.Stub) {
-      this.getService.push(serviceName);
-    }
-  }
-
-  when() {
-    return this.connectionPromise;
-  }
-
-  setConnection(connection: MessageConnection) {
-    if (!this.connection.length) {
-      this.connectionPromiseResolve();
-    }
-    this.connection.push(connection);
-
-    const rpcProxy = new RPCProxy(this.serviceMethodMap, this.logger);
-    rpcProxy.listen(connection);
-    this.rpcProxy.push(rpcProxy);
-
-    const serviceProxy = rpcProxy.createProxy();
-    this.serviceProxy.push(serviceProxy);
-  }
-
-  removeConnection(connection: MessageConnection) {
-    const removeIndex = this.connection.indexOf(connection);
-    if (removeIndex !== -1) {
-      this.connection.splice(removeIndex, 1);
-      this.rpcProxy.splice(removeIndex, 1);
-      this.serviceProxy.splice(removeIndex, 1);
-    }
-
-    return removeIndex !== -1;
-  }
-  onRequest(name, method: RPCServiceMethod) {
-    if (!this.connection.length) {
-      this.serviceMethodMap[name] = method;
-    } else {
-      this.rpcProxy.forEach((proxy) => {
-        proxy.listenService({ [name]: method });
-      });
-    }
-  }
-  broadcast(name, ...args): Promise<any> {
-    return Promise.all(this.serviceProxy.map((proxy) => proxy[name](...args)) as Promise<any>[])
-      .then((result) => result.filter((res) => res !== NOTREGISTERMETHOD))
-      .then((result) => (result.length === 1 ? result[0] : result));
-  }
-}

package/src/common/index.ts

@@ -1,6 +0,0 @@
-export * from './message';
-export * from './proxy';
-export * from './rpcProtocol';
-export * from './utils';
-export * from './ws-channel';
-export * from './connect';

package/src/common/message.ts

@@ -1,93 +0,0 @@
-import {
-  AbstractMessageReader,
-  AbstractMessageWriter,
-  createMessageConnection,
-} from '@opensumi/vscode-jsonrpc/lib/common/api';
-import { Disposable } from '@opensumi/vscode-jsonrpc/lib/common/disposable';
-import { MessageReader, DataCallback } from '@opensumi/vscode-jsonrpc/lib/common/messageReader';
-import { MessageWriter } from '@opensumi/vscode-jsonrpc/lib/common/messageWriter';
-/**
- * FIXME: 由于 `createMessageConnection` 方法隐式依赖了 `@opensumi/vscode-jsonrpc/lib/browser/main` 或 `@opensumi/vscode-jsonrpc/lib/node/main`
- * 的 `RIL.install()` 初始化代码，而 `browser/main` 中仅支持浏览器使用，
- * 故需要保证提前引入或执行一次 `@opensumi/vscode-jsonrpc/lib/node/main` 代码才能保证逻辑正常执行
- */
-import '@opensumi/vscode-jsonrpc/lib/node/main';
-
-export class WebSocketMessageReader extends AbstractMessageReader implements MessageReader {
-  protected state: 'initial' | 'listening' | 'closed' = 'initial';
-  protected callback: DataCallback | undefined;
-  protected events: { message?: any; error?: any }[] = [];
-
-  constructor(protected readonly socket) {
-    super();
-    if (this.socket.onMessage) {
-      this.socket.onMessage((message) => {
-        this.readMessage(message);
-      });
-    } else if (this.socket.onmessage) {
-      this.socket.onmessage = (message) => {
-        this.readMessage(message);
-      };
-    } else if (this.socket.on) {
-      this.socket.on('message', (message) => {
-        this.readMessage(message);
-      });
-    }
-  }
-
-  public listen(callback: DataCallback): Disposable {
-    if (this.state === 'initial') {
-      this.state = 'listening';
-      this.callback = callback;
-    }
-
-    while (this.events.length !== 0) {
-      const event = this.events.pop()!;
-      if (event.message) {
-        this.readMessage(event.message);
-      }
-    }
-
-    return Disposable.create(() => {
-      this.state = 'closed';
-      this.callback = undefined;
-      this.events = [];
-    });
-  }
-
-  protected readMessage(message) {
-    if (this.state === 'initial') {
-      this.events.splice(0, 0, { message });
-    } else if (this.state === 'listening') {
-      const data = JSON.parse(message);
-      this.callback!(data);
-    }
-  }
-}
-
-export class WebSocketMessageWriter extends AbstractMessageWriter implements MessageWriter {
-  constructor(protected readonly socket) {
-    super();
-  }
-
-  write(msg): Promise<void> {
-    try {
-      const content = JSON.stringify(msg);
-      this.socket.send(content);
-      return Promise.resolve();
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  public end(): void {}
-}
-
-/**
- * 给服务端的 WebSocket 及 Browser 端的 WebSocket 实例共用的方法
- * @param socket
- * @returns
- */
-export function createWebSocketConnection(socket: any) {
-  return createMessageConnection(new WebSocketMessageReader(socket), new WebSocketMessageWriter(socket));
-}