vscode插件体系详解

"main": "./out/extension.js","contributes": {    "commands": [        {      "command": "extension.helloWorld",       "title": "Hello World"   }    ]}"activationEvents": [    "onCommand:extension.helloWorld"]

protected async _initialize(): Promise<void> {    perf.mark('willLoadExtensions');    this._startExtensionHostProcess(true, []);  //启动插件worker进程，建立rpc通道，注入api    this.whenInstalledExtensionsRegistered().then(() => perf.mark('didLoadExtensions'));    await this._scanAndHandleExtensions();     this._releaseBarrier();}

const url = getWorkerBootstrapUrl(require.toUrl('../worker/extensionHostWorkerMain.js'), 'WorkerExtensionHost');const worker = new Worker(url, { name: 'WorkerExtensionHost' });

start(){   .....   const protocol: IMessagePassingProtocol = {        onMessage: emitter.event,  send: vsbuf => {      const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);       worker.postMessage(data, [data]);   }    }   return protocol;}

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

extensionProxy.$compute();

const protocol: IMessagePassingProtocol = ...protocol.send({rpcId, '$compute', ....});

export class RPCProtocol extends Disposable implements IRPCProtocol {  constructor((protocol: IMessagePassingProtocol, ...){     super();     this._protocol = protocol;  }  ....  //创建一个proxy，将对本地对象方法的调用转成一个远程调用  private _createProxy<T>(rpcId: number): T {   let handler = {     get: (target: any, name: PropertyKey) => {        //如果方法名以$开头，则转换成远程调用        if (typeof name === 'string' && !target[name] && name.charCodeAt(0) === CharCode.DollarSign) {           target[name] = (...myArgs: any[]) => {              //发送远程消息              return this._remoteCall(rpcId, name, myArgs);           };        }        return target[name];      }    };    return new Proxy(Object.create(null), handler);   }      //拼装远程消息，通过IMessagePassingProtocol发出   private _remoteCall(rpcId: number, methodName: string, args: any[]): Promise<any> {      const msg = MessageIO.serializeRequest(..., rpcId, methodName, ....);      this._protocol.send(msg);   }}

执行环境的隔离：插件运行在 worker 进程中，保证安全性主进程和 worker 进程的 RPC 通道建立，保证进程间模块互相调用

//插件进程中可调用的apiconst apiFactory = this._instaService.invokeFunction(createApiFactoryAndRegisterActors);

const workspace: typeof vscode.workspace = {    ....    window,    workspace,    Location,    tasks,    .....}

export class ExtHostWindow implements ExtHostWindowShape {   constructor(mainContext: IMainContext) {       //通过mainContext获取proxy，这里的mainContext实际上是一个RPCProtocol       //MainContext.MainThreadWindow是一个ProxyIdentifier       this._proxy = mainContext.getProxy(MainContext.MainThreadWindow);   }    openUri(stringOrUri: string | URI, options: IOpenUriOptions): Promise<boolean> {        ...        //对openUri的调用，实际上转换成对相应的Proxy的$openUri方法调用，最后通过RPC调用发送消息到主进程        return this._proxy.$openUri(stringOrUri, uriAsString, options);    }}

//MainContext.MainThreadWindow是一个ProxyIdentifier@extHostNamedCustomer(MainContext.MainThreadWindow)export class MainThreadWindow implements MainThreadWindowShape {   async $openUri(...): Promise<boolean> {  return this.openerService.open(...);   }}

export class ProxyIdentifier<T> {  public static count = 0;  public readonly isMain: boolean;  public readonly sid: string;  public readonly nid: number;  constructor(isMain: boolean, sid: string) {    this.isMain = isMain;    this.sid = sid;    this.nid = (++ProxyIdentifier.count);  }}

import * as vscode from 'vscode';export function activate(context: vscode.ExtensionContext) {   //插件逻辑}

declare module 'vscode' {  //模块定义}

this._fakeModules = this._instaService.createInstance(WorkerRequireInterceptor, apiFactory, this._registry);await this._fakeModules.install();

class WorkerRequireInterceptor extends RequireInterceptor {  ...  getModule(request: string, parent: URI): undefined | any {    //如果apiFactory中有相应模块则直接返回    if (this._factories.has(request)) {      return this._factories.get(request)!.load(request, parent, () => { throw new Error('CANNOT LOAD MODULE from here.'); });    }    ...}

插件进程执行环境模块定义主进程中的模块通过 @extHostNamedCustomer 注册为 RPC 调用的消费者插件进程 hook 了 require 模块加载机制，以一种优雅的方式将模块提供给开发者使用

export const commandsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({   extensionPoint: 'commands',   jsonSchema: schema.commandsContribution});

"contributes": {  "commands": [     {       "command": "extension.helloWorld",       "title": "Hello World"     }  ]}

const affectedExtensionPoints: { [extPointName: string]: boolean; } = Object.create(null);//遍历插件列表for (let extensionDescription of affectedExtensions) { //找到contributes if (extensionDescription.contributes) {     //把contributes的所有key定义为扩展点     for (let extPointName in extensionDescription.contributes) {       if (hasOwnProperty.call(extensionDescription.contributes, extPointName)) {         affectedExtensionPoints[extPointName] = true;       }     } }}

const extensionPoints = ExtensionsRegistry.getExtensionPoints();

//遍历插件for (const extensionPoint of extensionPoints) {  //是否需要扩展  if (affectedExtensionPoints[extensionPoint.name]) {    //将当前插件应用扩展点    AbstractExtensionService._handleExtensionPoint(extensionPoint, availableExtensions, messageHandler);  }}

extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);

public activateByEvent(activationEvent: string): Promise<void> {    ...    //主进程通过proxy，RPC调用插件进程    return proxy.value.$activateByEvent(activationEvent);}

const activateExtensions = this._registry.getExtensionDescriptionsForActivationEvent(activationEvent);this._activateExtensions(activateExtensions.map(e => ({  id: e.identifier,  reason: { startup, extensionId: e.identifier, activationEvent }}))

this._loadCommonJSModule<IExtensionModule>(joinPath(extensionDescription.extensionLocation, extensionDescription.main), activationTimesBuilder)

//创建插件执行函数const initFn = new Function('module', 'exports', 'require', 'window', jsSourceText);//修改commonjs模块加载的export和requireconst _exports = {};const _module = { exports: _exports };//require从_fakeModules中寻找模块，_fakeModules是由上文讲到的WorkerRequireInterceptor提供的const _require = (request: string) => {  const result = this._fakeModules!.getModule(request, module);  if (result === undefined) {    throw new Error(`Cannot load module '${request}'`);  }   return result;};//使用自定义的require和export，执行插件initFn(_module, _exports, _require, self);