[VSCode 源码阅读笔记] VSCode 的进程间通讯 ( 一 )

class CodeMain {
  private async startup(args: ParsedArgs): Promise<void> { 
    // ...
    await instantiationService.invokeFunction(async accessor => {
      const environmentService = accessor.get(IEnvironmentService);
      const logService = accessor.get(ILogService);
      const lifecycleMainService = accessor.get(ILifecycleMainService);
      // ...
      const mainIpcServer = await this.doStartup(logService, environmentService, lifecycleMainService, instantiationService, true);
      // ...
    });
    // ...
  }
}

// src/vs/base/parts/ipc/node/ipc.net.ts
let server: Server;
try {
  server = await serve(environmentService.mainIPCHandle);
  once(lifecycleMainService.onWillShutdown)(() => server.dispose());
} catch (error) {
  // ...
}
// src/vs/base/parts/ipc/node/ipc.net.ts
export function serve(hook: any): Promise<Server> {
  return new Promise<Server>((c, e) => {
    const server = createServer();

    server.on('error', e);
    server.listen(hook, () => {
      server.removeListener('error', e);
      c(new Server(server));
    });
  });
}

// src/vs/code/electron-main/main.ts
instantiationService.createInstance(CodeApplication, mainIpcServer, instanceEnvironment).startup();

// src/vs/code/electron-main/app.ts
// Register more Main IPC services
const launchMainService = accessor.get(ILaunchMainService);
const launchChannel = createChannelReceiver(launchMainService, { disableMarshalling: true });
this.mainIpcServer.registerChannel('launch', launchChannel);

export function createChannelReceiver(service: unknown, options?: IChannelReceiverOptions): IServerChannel {
  const handler = service as { [key: string]: unknown };
  const disableMarshalling = options && options.disableMarshalling;

  // Buffer any event that should be supported by
  // iterating over all property keys and finding them
  // 将所有的事件加入到一个 { 事件名称 -> 事件 } 的 Map 中
  const mapEventNameToEvent = new Map<string, Event<unknown>>();
  for (const key in handler) {
    if (propertyIsEvent(key)) {
      mapEventNameToEvent.set(key, Event.buffer(handler[key] as Event<unknown>, true));
    }
  }

  // 返回一个 Channel
  return new class implements IServerChannel {
    // 输入 Event 名称，返回名称对应的 Event
    listen<T>(_: unknown, event: string): Event<T> {
      // 从 Map 中取出 Event
      const eventImpl = mapEventNameToEvent.get(event);
      if (eventImpl) {
        return eventImpl as Event<T>;
      }

      throw new Error(`Event not found: ${event}`);
    }
    
    // 输入函数名，调用对应函数
    call(_: unknown, command: string, args?: any[]): Promise<any> {
      const target = handler[command];
      if (typeof target === 'function') {

        // Revive unless marshalling disabled
        if (!disableMarshalling && Array.isArray(args)) {
          for (let i = 0; i < args.length; i++) {
            args[i] = revive(args[i]);
          }
        }
        // 调用函数
        return target.apply(handler, args);
      }

      throw new Error(`Method not found: ${command}`);
    }
  };
}

registerChannel(channelName: string, channel: IServerChannel<TContext>): void {
  this.channels.set(channelName, channel);

  this._connections.forEach(connection => {
    connection.channelServer.registerChannel(channelName, channel);
  });
}

class IPCServer {
  constructor(onDidClientConnect: Event<ClientConnectionEvent>) {
    // 当客户端已经连接
    onDidClientConnect(({ protocol, onDidClientDisconnect }) => {
      const onFirstMessage = Event.once(protocol.onMessage);
      // 当收到第一条消息
      onFirstMessage(msg => {
        const reader = new BufferReader(msg);
        const ctx = deserialize(reader) as TContext;
        // channelServer 包含 IPCServer 中的所有 channel
        const channelServer = new ChannelServer(protocol, ctx);
        // channelClient 可以得到一个 channel，用于请求调用函数和处理事件
        const channelClient = new ChannelClient(protocol);
        // 这里把已有的 channel 都注册到 server 中
        this.channels.forEach((channel, name) => channelServer.registerChannel(name, channel));

        const connection: Connection<TContext> = { channelServer, channelClient, ctx };
        this._connections.add(connection);
        this._onDidAddConnection.fire(connection);

        // 连接关闭回收资源
        onDidClientDisconnect(() => {
          channelServer.dispose();
          channelClient.dispose();
          this._connections.delete(connection);
          this._onDidRemoveConnection.fire(connection);
        });
      });
    });
  }
}

// src/vs/base/parts/ipc/common/ipc.ts
interface Connection<TContext> extends Client<TContext> {
  readonly channelServer: ChannelServer<TContext>;
  readonly channelClient: ChannelClient;
}
export interface Client<TContext> {
  readonly ctx: TContext;
}

export interface IMessagePassingProtocol {
  send(buffer: VSBuffer): void;
  onMessage: Event<VSBuffer>;
}

export const enum RequestType {
	Promise = 100, // 调用方法
	PromiseCancel = 101, // 取消调用方法
	EventListen = 102, // 监听事件
	EventDispose = 103 // 取消监听事件
}

export const enum ResponseType {
	Initialize = 200, // 初始化
	PromiseSuccess = 201, // 方法调用成功
	PromiseError = 202, // 方法调用错误
	PromiseErrorObj = 203, // 方法调用错误对象
	EventFire = 204 // 事件触发
}