@x-oasis/async-call-rpc-misc 0.1.38

package/src/buffer/ReadBuffer.ts

@@ -0,0 +1,41 @@
+export enum DataType {
+  Undefined = 0,
+  String = 1,
+  Buffer = 2,
+  VSBuffer = 3,
+  Array = 4,
+  Object = 5,
+  Int = 6,
+}
+
+export default class ReadBuffer {
+  decode(data: any) {
+    return JSON.parse(data);
+  }
+}
+
+// export class BufferReader implements IReader {
+
+// 	private pos = 0;
+
+// 	constructor(private buffer: VSBuffer) { }
+
+// 	read(bytes: number): VSBuffer {
+// 		const result = this.buffer.slice(this.pos, this.pos + bytes);
+// 		this.pos += result.byteLength;
+// 		return result;
+// 	}
+// }
+
+// export class BufferWriter implements IWriter {
+
+// 	private buffers: VSBuffer[] = [];
+
+// 	get buffer(): VSBuffer {
+// 		return VSBuffer.concat(this.buffers);
+// 	}
+
+// 	write(buffer: VSBuffer): void {
+// 		this.buffers.push(buffer);
+// 	}
+// }

package/src/buffer/WriteBuffer.ts

@@ -0,0 +1,5 @@
+export default class WriteBuffer {
+  encode(data: any) {
+    return JSON.stringify(data);
+  }
+}

package/src/buffer/index.ts

@@ -0,0 +1,3 @@
+export { default as ReadBuffer } from './ReadBuffer';
+export { default as WriteBuffer } from './WriteBuffer';
+export { default as DataBuffer } from './DataBuffer';

package/src/channel-protocol/AbstractChannelProtocol.ts

@@ -0,0 +1,204 @@
+import { Disposable } from '@x-oasis/disposable';
+import { Event } from '@x-oasis/emitter';
+import { Deferred } from '@x-oasis/deferred';
+import { generateRandomKey } from '@x-oasis/id';
+
+import {
+  SendingProps,
+  IMessageChannel,
+  ClientMiddleware,
+  SenderMiddleware,
+  RequestRawSequenceId,
+  AbstractChannelProtocolProps,
+  PendingSendEntry,
+} from '../types';
+import { runMiddlewares } from './middlewares';
+import RPCServiceHost from '../rpc-service/RPCServiceHost';
+import { WriteBuffer, ReadBuffer } from '../buffer';
+import { Channel } from './Channel';
+import { resumeMiddlewares } from './middlewares/utils';
+
+abstract class AbstractChannelProtocol
+  extends Disposable
+  implements IMessageChannel
+{
+  private readonly _masterProcessName: string;
+
+  private _key: string;
+
+  public channel: Channel;
+
+  private _serviceHost: RPCServiceHost;
+
+  private readonly _description: string;
+
+  private _seqId: RequestRawSequenceId = -1;
+
+  // decoder should comes first !!!!
+  protected _onMessageMiddleware: ClientMiddleware[] = [];
+
+  private _senderMiddleware: SenderMiddleware[] = [];
+
+  private _readBuffer: ReadBuffer;
+
+  private _writeBuffer: WriteBuffer;
+
+  private _isConnected = true;
+
+  /**
+   * 如果说channel存在的话，那么就是ongoing request
+   */
+  public ongoingRequests: Map<string, Deferred> = new Map();
+
+  /**
+   * 如果说channel不存在，那么请求就会暂时放到这个里面
+   */
+  public pendingSendEntries = new Set<PendingSendEntry>();
+
+  public requestEvents: Map<string, any> = new Map();
+
+  private onDidConnectedEvent = new Event({ name: 'on-did-connected' });
+
+  onDidConnected = this.onDidConnectedEvent.subscribe;
+
+  private onDidDisconnectedEvent = new Event({ name: 'on-did-disconnect' });
+
+  onDidDisconnected = this.onDidDisconnectedEvent.subscribe;
+
+  constructor(props: AbstractChannelProtocolProps) {
+    super();
+    const {
+      description,
+      masterProcessName,
+      serviceHost,
+      connected = true,
+    } = props;
+    this._readBuffer = new ReadBuffer();
+    this._writeBuffer = new WriteBuffer();
+    this._description = description;
+    this._serviceHost = serviceHost;
+    this._isConnected = connected;
+    this._masterProcessName = masterProcessName;
+    // 需要创建，否则创建'message'监听时，会出现混乱
+    this._key = generateRandomKey();
+    this.registerDisposable(this.onDidConnected(this.didConnected.bind(this)));
+  }
+
+  get serviceHost() {
+    return this._serviceHost;
+  }
+
+  setServiceHost(serviceHost: RPCServiceHost) {
+    this._serviceHost = serviceHost;
+  }
+
+  get senderMiddleware() {
+    return this._senderMiddleware;
+  }
+
+  get readBuffer() {
+    return this._readBuffer;
+  }
+
+  get writeBuffer() {
+    return this._writeBuffer;
+  }
+
+  // start from 1
+  get seqId() {
+    this._seqId += 1;
+    return `${this._key}_${this._seqId}`;
+  }
+
+  get description() {
+    return this._description;
+  }
+
+  get masterProcessName() {
+    return this._masterProcessName;
+  }
+
+  addPendingSendEntry(entry: PendingSendEntry) {
+    this.pendingSendEntries.add(entry);
+  }
+
+  applyOnMessageMiddleware(fns: Function | Function[]) {
+    [].concat(fns).forEach((fn) => {
+      if (typeof fn === 'function') {
+        this._onMessageMiddleware.push(fn(this));
+      }
+    });
+  }
+
+  applySendMiddleware(fns: Function | Function[]) {
+    [].concat(fns).forEach((fn) => {
+      if (typeof fn === 'function') {
+        this._senderMiddleware.push(fn(this));
+      }
+    });
+  }
+
+  isConnected() {
+    return this._isConnected;
+  }
+
+  resumePendingEntry() {
+    this.pendingSendEntries.forEach((entry) => {
+      this.pendingSendEntries.delete(entry);
+      resumeMiddlewares(this.senderMiddleware, entry);
+    });
+  }
+
+  didConnected() {
+    this.resumePendingEntry();
+  }
+
+  protected bindChannel(channel: Channel) {
+    this.channel = channel;
+  }
+
+  connect(channel: Channel) {
+    this.channel = channel;
+    this.onDidConnectedEvent.fire();
+  }
+
+  // 已经绑定了channel，这个时候需要直接触发
+  activate() {
+    this._isConnected = true;
+    this.onDidConnectedEvent.fire();
+  }
+
+  disconnect() {
+    this.channel = null;
+    this._isConnected = false;
+    this.onDidDisconnectedEvent.fire();
+  }
+
+  send(props: SendingProps, transfer?: MessagePort[]): Deferred | void;
+
+  send(requestPath: string, fnName: string, ...args: any[]): Deferred | void;
+
+  send(...args: any[]) {
+    const { returnValue } = runMiddlewares(this.senderMiddleware, args);
+    if (returnValue) return returnValue;
+  }
+
+  sendReply(...args: any[]) {
+    // TODO: this.channel may be null when disconnect
+    this.channel?.send(...args);
+  }
+
+  onMessage(...args: any[]) {
+    runMiddlewares(this._onMessageMiddleware, args);
+  }
+
+  runWithMiddlewares(middlewares: ClientMiddleware[], ...args: any[]) {
+    runMiddlewares(
+      // @ts-ignore
+      middlewares.map((m) => m(this)),
+      args
+    );
+  }
+}
+
+export default AbstractChannelProtocol;

package/src/channel-protocol/Channel.ts

@@ -0,0 +1,37 @@
+import { Emitter } from '@x-oasis/emitter';
+import { Disposable, toDisposable } from '@x-oasis/disposable';
+
+type ChannelSend = (...args: any[]) => void;
+type ChannelInitListener = (emitter: Emitter) => void;
+
+type ChannelProps = {
+  send: ChannelSend;
+  initListener: ChannelInitListener;
+};
+
+export class Channel extends Disposable {
+  private _send: (...args: any[]) => void;
+
+  emitter = new Emitter({ name: 'channel' });
+
+  constructor(props: ChannelProps) {
+    super();
+    const { send, initListener } = props;
+    this._send = send;
+    initListener(this.emitter);
+
+    this.registerDisposable(
+      toDisposable(() => {
+        this.emitter.dispose();
+      })
+    );
+  }
+
+  send(...args: any[]) {
+    this._send(...args);
+  }
+
+  on(eventName: string, listener: Function) {
+    this.emitter.getEvent(eventName).subscribe(listener);
+  }
+}

package/src/channel-protocol/DeferredMessageChannelProtocol.ts

@@ -0,0 +1,85 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, DeferredMessageChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  sendRequest,
+  prepareNormalData,
+  handleDisconnectedRequest,
+  normalizeMessageChannelRawMessage,
+} from './middlewares';
+import { Channel } from './Channel';
+
+/**
+ * Basically it is the same with `MessageChannelProtocol`, but for this function
+ * `port` is not required on initlization.
+ */
+export default class DeferredMessageChannelProtocol extends AbstractChannelProtocol {
+  private port: MainPort;
+
+  constructor(props: DeferredMessageChannelProtocolProps) {
+    super({
+      connected: false,
+      ...props,
+    });
+    const { clientMiddlewares, senderMiddlewares, port } = props;
+
+    this.applySendMiddleware(
+      [].concat(
+        prepareNormalData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeMessageChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+
+    if (port) this.bindPort(port);
+  }
+
+  bindPort(port: MainPort) {
+    if (!port) return;
+    if (this.port) {
+      if (this.port === port) return;
+      this.port.close();
+    }
+
+    this.port = port;
+
+    const channel = new Channel({
+      send: (...args) => {
+        // @ts-ignore
+        this.port.postMessage(...args);
+      },
+      initListener: (emitter) => {
+        emitter.register('message');
+        this.port.on('message', (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent('message').fire(...args);
+        });
+      },
+    });
+    this.port.start();
+
+    this.bindChannel(channel);
+  }
+
+  disconnect() {
+    this.dispose();
+    this.port.close();
+    super.disconnect();
+  }
+}

package/src/channel-protocol/IPCMainChannelProtocol.ts

@@ -0,0 +1,65 @@
+import { ipcMain } from 'electron';
+import { IPCMainChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  preparePortData,
+  updateSeqInfo,
+  sendRequest,
+  handleDisconnectedRequest,
+  normalizeIPCChannelRawMessage,
+} from './middlewares';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { Channel } from './Channel';
+
+export default class IPCMainChannelProtocol extends AbstractChannelProtocol {
+  private channelName: string;
+
+  constructor(props: IPCMainChannelProtocolProps) {
+    super(props);
+    const {
+      channelName,
+      webContents,
+      clientMiddlewares = [],
+      senderMiddlewares = [],
+    } = props;
+    this.channelName = channelName;
+    this.channel = new Channel({
+      send: (...args: any[]) =>
+        webContents.postMessage(this.channelName, ...args),
+      initListener: (emitter) => {
+        emitter.register(this.channelName);
+        ipcMain.on(this.channelName, (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent(this.channelName).fire(...args);
+        });
+      },
+    });
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeIPCChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+    this.applySendMiddleware(
+      [].concat(
+        preparePortData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+  }
+
+  disconnect() {
+    this.dispose();
+    super.disconnect();
+  }
+}

package/src/channel-protocol/IPCMainGlobalChannelProtocol.ts

@@ -0,0 +1,66 @@
+import { ipcMain } from 'electron';
+import { IPCMainGlobalChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  preparePortData,
+  updateSeqInfo,
+  handlePortRequest,
+  sendRequest,
+  handleDisconnectedRequest,
+  normalizeIPCChannelRawMessage,
+} from './middlewares';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { Channel } from './Channel';
+
+/**
+ * mainly send through sender to renderer
+ */
+export default class IPCMainGlobalChannelProtocol extends AbstractChannelProtocol {
+  private channelName: string;
+
+  constructor(props: IPCMainGlobalChannelProtocolProps) {
+    super(props);
+    const {
+      clientMiddlewares = [],
+      senderMiddlewares = [],
+      channelName,
+    } = props;
+    this.channelName = channelName;
+    this.channel = new Channel({
+      send: () => {
+        // do nothing...
+      },
+      initListener: (emitter) => {
+        emitter.register(this.channelName);
+        ipcMain.on(this.channelName, (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent(this.channelName).fire(...args);
+        });
+      },
+    });
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeIPCChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handlePortRequest
+      )
+    );
+    this.applySendMiddleware(
+      [].concat(
+        preparePortData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+  }
+
+  disconnect() {
+    this.dispose();
+    super.disconnect();
+  }
+}

package/src/channel-protocol/IPCRendererChannelProtocol.ts

@@ -0,0 +1,81 @@
+import { IPCRendererChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  prepareHostPortData,
+  sendRequest,
+  handleDisconnectedRequest,
+  normalizeIPCChannelRawMessage,
+} from './middlewares';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { Channel } from './Channel';
+import { fromDomEvent } from '@x-oasis/emitter';
+
+class IPCRendererChannelProtocol extends AbstractChannelProtocol {
+  private channelName: string;
+
+  constructor(props: IPCRendererChannelProtocolProps) {
+    super(props);
+    this.projectName = props.projectName;
+    const {
+      channelName,
+      clientMiddlewares = [],
+      senderMiddlewares = [],
+      ipcRenderer,
+    } = props;
+    this.channelName = channelName;
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeIPCChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+    this.applySendMiddleware(
+      [].concat(
+        prepareHostPortData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+
+    this.channel = new Channel({
+      send: (...args) => ipcRenderer.send(this.channelName, ...args),
+      initListener: (emitter) => {
+        emitter.register(this.channelName);
+        ipcRenderer.on(this.channelName, (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent(this.channelName).fire(...args);
+        });
+
+        fromDomEvent(
+          window,
+          'message'
+        )((event: MessageEvent) => {
+          if (event.data?.channel === this.channelName) {
+            this.runWithMiddlewares([deserialize, handleResponse], {
+              event,
+              ports: event.ports,
+              data: event.data?.data,
+            });
+          }
+        });
+      },
+    });
+  }
+
+  disconnect() {
+    this.dispose();
+    super.disconnect();
+  }
+}
+
+export default IPCRendererChannelProtocol;

package/src/channel-protocol/IPCRendererMessageChannelProtocol.ts

@@ -0,0 +1,79 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, MessageChannelProtocolProps } from '../types';
+import {
+  serialize,
+  deserialize,
+  handleRequest,
+  handleResponse,
+  updateSeqInfo,
+  sendRequest,
+  prepareNormalData,
+  handleDisconnectedRequest,
+  normalizeMessageChannelRawMessage,
+} from './middlewares';
+import { Channel } from './Channel';
+
+export default class IPCRendererMessageChannelProtocol extends AbstractChannelProtocol {
+  private readonly port: MainPort;
+
+  constructor(props: MessageChannelProtocolProps) {
+    super({
+      connected: false,
+      ...props,
+    });
+    const { clientMiddlewares, senderMiddlewares, port } = props;
+
+    this.applySendMiddleware(
+      [].concat(
+        prepareNormalData,
+        updateSeqInfo,
+        handleDisconnectedRequest,
+        serialize,
+        senderMiddlewares,
+        sendRequest
+      )
+    );
+    this.applyOnMessageMiddleware(
+      [].concat(
+        normalizeMessageChannelRawMessage,
+        deserialize,
+        clientMiddlewares,
+        handleRequest,
+        handleResponse
+      )
+    );
+    if (port) this.bindPort(port);
+  }
+
+  bindPort(port: MainPort) {
+    if (!port) return;
+    if (this.port) {
+      if (this.port === port) return;
+      this.port.close();
+    }
+
+    this.port = port;
+
+    const channel = new Channel({
+      send: (...args) => {
+        this.port.postMessage(...args);
+      },
+      initListener: (emitter) => {
+        emitter.register('onmessage');
+        this.port.onmessage = (...args: any[]) => {
+          this.onMessage(...args);
+          emitter.getEvent('onmessage').fire(...args);
+        };
+      },
+    });
+    this.port.start();
+
+    this.bindChannel(channel);
+  }
+
+  disconnect() {
+    this.dispose();
+    this.port.close();
+    super.disconnect();
+  }
+}