Run multiple local extension hosts

src/vs/workbench/api/browser/mainThreadExtensionService.ts

@@ -197,9 +197,9 @@ class ExtensionHostProxy implements IExtensionHostProxy {
  resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult> {
  return this._actual.$resolveAuthority(remoteAuthority, resolveAttempt);
  }
- async getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI> {
+ async getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null> {
  const uriComponents = await this._actual.$getCanonicalURI(remoteAuthority, uri);
- return URI.revive(uriComponents);
+ return (uriComponents ? URI.revive(uriComponents) : uriComponents);
  }
  startExtensionHost(enabledExtensionIds: ExtensionIdentifier[]): Promise<void> {
  return this._actual.$startExtensionHost(enabledExtensionIds);

src/vs/workbench/api/common/extHost.protocol.ts

@@ -1339,7 +1339,10 @@ export interface ExtHostSearchShape {
 
 export interface ExtHostExtensionServiceShape {
  $resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
- $getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents>;
+ /**
+ * Returns `null` if no resolver for `remoteAuthority` is found.
+ */
+ $getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
  $startExtensionHost(enabledExtensionIds: ExtensionIdentifier[]): Promise<void>;
  $extensionTestsExecute(): Promise<number>;
  $extensionTestsExit(code: number): Promise<void>;

src/vs/workbench/api/common/extHostExtensionService.ts

@@ -753,12 +753,13 @@ export abstract class AbstractExtHostExtensionService extends Disposable impleme
  }
  }
 
- public async $getCanonicalURI(remoteAuthority: string, uriComponents: UriComponents): Promise<UriComponents> {
+ public async $getCanonicalURI(remoteAuthority: string, uriComponents: UriComponents): Promise<UriComponents | null> {
  this._logService.info(`$getCanonicalURI invoked for authority (${getRemoteAuthorityPrefix(remoteAuthority)})`);
 
- const { authorityPrefix, resolver } = await this._activateAndGetResolver(remoteAuthority);
+ const { resolver } = await this._activateAndGetResolver(remoteAuthority);
  if (!resolver) {
- throw new Error(`Cannot get canonical URI because no remote extension is installed to resolve ${authorityPrefix}`);
+ // Return `null` if no resolver for `remoteAuthority` is found.
+ return null;
  }
 
  const uri = URI.revive(uriComponents);

src/vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor.ts

@@ -11,7 +11,7 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IExtensionsWorkbenchService, IExtension } from 'vs/workbench/contrib/extensions/common/extensions';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
-import { IExtensionService, IExtensionsStatus, IExtensionHostProfile, ExtensionRunningLocation } from 'vs/workbench/services/extensions/common/extensions';
+import { IExtensionService, IExtensionsStatus, IExtensionHostProfile, LocalWebWorkerRunningLocation } from 'vs/workbench/services/extensions/common/extensions';
 import { IListVirtualDelegate, IListRenderer } from 'vs/base/browser/ui/list/list';
 import { WorkbenchList } from 'vs/platform/list/browser/listService';
 import { append, $, Dimension, clearNode, addDisposableListener } from 'vs/base/browser/dom';
@@ -36,6 +36,7 @@ import { IEditorService } from 'vs/workbench/services/editor/common/editorServic
 import { RuntimeExtensionsInput } from 'vs/workbench/contrib/extensions/common/runtimeExtensionsInput';
 import { Action2, MenuId } from 'vs/platform/actions/common/actions';
 import { CATEGORIES } from 'vs/workbench/common/actions';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
 
 interface IExtensionProfileInformation {
  /**
@@ -80,6 +81,7 @@ export abstract class AbstractRuntimeExtensionsEditor extends EditorPane {
  @IStorageService storageService: IStorageService,
  @ILabelService private readonly _labelService: ILabelService,
  @IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
+ @IClipboardService private readonly _clipboardService: IClipboardService,
  ) {
  super(AbstractRuntimeExtensionsEditor.ID, telemetryService, themeService, storageService);
 
@@ -370,7 +372,7 @@ export abstract class AbstractRuntimeExtensionsEditor extends EditorPane {
  }
 
  let extraLabel: string | null = null;
- if (element.status.runningLocation === ExtensionRunningLocation.LocalWebWorker) {
+ if (element.status.runningLocation && element.status.runningLocation.equals(new LocalWebWorkerRunningLocation())) {
  extraLabel = `$(globe) web worker`;
  } else if (element.description.extensionLocation.scheme === Schemas.vscodeRemote) {
  const hostLabel = this._labelService.getHostLabel(Schemas.vscodeRemote, this._environmentService.remoteAuthority);
@@ -379,6 +381,8 @@ export abstract class AbstractRuntimeExtensionsEditor extends EditorPane {
  } else {
  extraLabel = `$(remote) ${element.description.extensionLocation.authority}`;
  }
+ } else if (element.status.runningLocation && element.status.runningLocation.affinity > 0) {
+ extraLabel = `$(server-process) local process ${element.status.runningLocation.affinity + 1}`;
  }
 
  if (extraLabel) {
@@ -427,11 +431,21 @@ export abstract class AbstractRuntimeExtensionsEditor extends EditorPane {
 
  const actions: IAction[] = [];
 
+ actions.push(new Action(
+ 'runtimeExtensionsEditor.action.copyId',
+ nls.localize('copy id', "Copy id ({0})", e.element!.description.identifier.value),
+ undefined,
+ true,
+ () => {
+ this._clipboardService.writeText(e.element!.description.identifier.value);
+ }
+ ));
+
  const reportExtensionIssueAction = this._createReportExtensionIssueAction(e.element);
  if (reportExtensionIssueAction) {
  actions.push(reportExtensionIssueAction);
- actions.push(new Separator());
  }
+ actions.push(new Separator());
 
  if (e.element!.marketplaceInfo) {
  actions.push(new Action('runtimeExtensionsEditor.action.disableWorkspace', nls.localize('disable workspace', "Disable (Workspace)"), undefined, true, () => this._extensionsWorkbenchService.setEnablement(e.element!.marketplaceInfo!, EnablementState.DisabledWorkspace)));

src/vs/workbench/contrib/extensions/browser/browserRuntimeExtensionsEditor.ts

@@ -4,38 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Action } from 'vs/base/common/actions';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IExtensionsWorkbenchService } from 'vs/workbench/contrib/extensions/common/extensions';
-import { IThemeService } from 'vs/platform/theme/common/themeService';
-import { IExtensionService, IExtensionHostProfile } from 'vs/workbench/services/extensions/common/extensions';
-import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
-import { INotificationService } from 'vs/platform/notification/common/notification';
-import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
-import { IStorageService } from 'vs/platform/storage/common/storage';
-import { ILabelService } from 'vs/platform/label/common/label';
+import { IExtensionHostProfile } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { AbstractRuntimeExtensionsEditor, IRuntimeExtension } from 'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor';
 
 export class RuntimeExtensionsEditor extends AbstractRuntimeExtensionsEditor {
 
- constructor(
- @ITelemetryService telemetryService: ITelemetryService,
- @IThemeService themeService: IThemeService,
- @IContextKeyService contextKeyService: IContextKeyService,
- @IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService,
- @IExtensionService extensionService: IExtensionService,
- @INotificationService notificationService: INotificationService,
- @IContextMenuService contextMenuService: IContextMenuService,
- @IInstantiationService instantiationService: IInstantiationService,
- @IStorageService storageService: IStorageService,
- @ILabelService labelService: ILabelService,
- @IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,
- ) {
- super(telemetryService, themeService, contextKeyService, extensionsWorkbenchService, extensionService, notificationService, contextMenuService, instantiationService, storageService, labelService, environmentService);
- }
-
  protected _getProfileInfo(): IExtensionHostProfile | null {
  return null;
  }

src/vs/workbench/contrib/extensions/electron-sandbox/debugExtensionHostAction.ts

@@ -6,7 +6,7 @@
 import * as nls from 'vs/nls';
 import { IProductService } from 'vs/platform/product/common/productService';
 import { Action } from 'vs/base/common/actions';
-import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionHostKind, IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 import { IDebugService } from 'vs/workbench/contrib/debug/common/debug';
 import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
@@ -29,8 +29,8 @@ export class DebugExtensionHostAction extends Action {
 
  override async run(): Promise<any> {
 
- const inspectPort = await this._extensionService.getInspectPort(false);
- if (!inspectPort) {
+ const inspectPorts = await this._extensionService.getInspectPorts(ExtensionHostKind.LocalProcess, false);
+ if (inspectPorts.length === 0) {
  const res = await this._dialogService.confirm({
  type: 'info',
  message: nls.localize('restart1', "Profile Extensions"),
@@ -45,11 +45,16 @@ export class DebugExtensionHostAction extends Action {
  return;
  }
 
+ if (inspectPorts.length > 1) {
+ // TODO
+ console.warn(`There are multiple extension hosts available for debugging. Picking the first one...`);
+ }
+
  return this._debugService.startDebugging(undefined, {
  type: 'node',
  name: nls.localize('debugExtensionHost.launch.name', "Attach Extension Host"),
  request: 'attach',
- port: inspectPort
+ port: inspectPorts[0]
  });
  }
 }

src/vs/workbench/contrib/extensions/electron-sandbox/extensionProfileService.ts

@@ -6,7 +6,7 @@
 import * as nls from 'vs/nls';
 import { Event, Emitter } from 'vs/base/common/event';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IExtensionHostProfile, ProfileSession, IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { IExtensionHostProfile, ProfileSession, IExtensionService, ExtensionHostKind } from 'vs/workbench/services/extensions/common/extensions';
 import { Disposable, toDisposable, MutableDisposable } from 'vs/base/common/lifecycle';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { StatusbarAlignment, IStatusbarService, IStatusbarEntryAccessor, IStatusbarEntry } from 'vs/workbench/services/statusbar/browser/statusbar';
@@ -116,8 +116,9 @@ export class ExtensionHostProfileService extends Disposable implements IExtensio
  return null;
  }
 
- const inspectPort = await this._extensionService.getInspectPort(true);
- if (!inspectPort) {
+ const inspectPorts = await this._extensionService.getInspectPorts(ExtensionHostKind.LocalProcess, true);
+
+ if (inspectPorts.length === 0) {
  return this._dialogService.confirm({
  type: 'info',
  message: nls.localize('restart1', "Profile Extensions"),
@@ -131,9 +132,14 @@ export class ExtensionHostProfileService extends Disposable implements IExtensio
  });
  }
 
+ if (inspectPorts.length > 1) {
+ // TODO
+ console.warn(`There are multiple extension hosts available for profiling. Picking the first one...`);
+ }
+
  this._setState(ProfileSessionState.Starting);
 
- return this._instantiationService.createInstance(ExtensionHostProfiler, inspectPort).start().then((value) => {
+ return this._instantiationService.createInstance(ExtensionHostProfiler, inspectPorts[0]).start().then((value) => {
  this._profileSession = value;
  this._setState(ProfileSessionState.Running);
  }, (err) => {

src/vs/workbench/contrib/extensions/electron-sandbox/extensionsAutoProfiler.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { IExtensionService, IResponsiveStateChangeEvent, IExtensionHostProfile, ProfileSession } from 'vs/workbench/services/extensions/common/extensions';
+import { IExtensionService, IResponsiveStateChangeEvent, IExtensionHostProfile, ProfileSession, ExtensionHostKind } from 'vs/workbench/services/extensions/common/extensions';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { ILogService } from 'vs/platform/log/common/log';
@@ -46,8 +46,11 @@ export class ExtensionsAutoProfiler extends Disposable implements IWorkbenchCont
  }
 
  private async _onDidChangeResponsiveChange(event: IResponsiveStateChangeEvent): Promise<void> {
+ if (event.extensionHostKind !== ExtensionHostKind.LocalProcess) {
+ return;
+ }
 
- const port = await this._extensionService.getInspectPort(true);
+ const port = await this._extensionService.getInspectPort(event.extensionHostId, true);
 
  if (!port) {
  return;

src/vs/workbench/contrib/extensions/electron-sandbox/runtimeExtensionsEditor.ts

@@ -26,6 +26,7 @@ import { URI } from 'vs/base/common/uri';
 import { IFileService } from 'vs/platform/files/common/files';
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 import { IV8Profile, Utils } from 'vs/platform/profiling/common/profiling';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
 
 export const IExtensionHostProfileService = createDecorator<IExtensionHostProfileService>('extensionHostProfileService');
 export const CONTEXT_PROFILE_SESSION_STATE = new RawContextKey<string>('profileSessionState', 'none');
@@ -72,9 +73,10 @@ export class RuntimeExtensionsEditor extends AbstractRuntimeExtensionsEditor {
  @IStorageService storageService: IStorageService,
  @ILabelService labelService: ILabelService,
  @IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,
+ @IClipboardService clipboardService: IClipboardService,
  @IExtensionHostProfileService private readonly _extensionHostProfileService: IExtensionHostProfileService,
  ) {
- super(telemetryService, themeService, contextKeyService, extensionsWorkbenchService, extensionService, notificationService, contextMenuService, instantiationService, storageService, labelService, environmentService);
+ super(telemetryService, themeService, contextKeyService, extensionsWorkbenchService, extensionService, notificationService, contextMenuService, instantiationService, storageService, labelService, environmentService, clipboardService);
  this._profileInfo = this._extensionHostProfileService.lastProfile;
  this._extensionsHostRecorded = CONTEXT_EXTENSION_HOST_PROFILE_RECORDED.bindTo(contextKeyService);
  this._profileSessionState = CONTEXT_PROFILE_SESSION_STATE.bindTo(contextKeyService);