@codingame/monaco-vscode-extensions-service-override
Version:
VSCode public API plugged on the monaco editor - extensions service-override
281 lines (278 loc) • 17.9 kB
JavaScript
import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
import { Schemas } from 'vscode/vscode/vs/base/common/network';
import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
import 'vscode/vscode/vs/platform/instantiation/common/extensions';
import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
import { getLogs } from 'vscode/vscode/vs/platform/log/browser/log';
import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
import { PersistentConnectionEventType } from 'vscode/vscode/vs/platform/remote/common/remoteAgentConnection';
import { RemoteAuthorityResolverError } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver.service';
import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner.service';
import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
import { FetchFileSystemProvider } from './webWorkerFileSystemProvider.js';
import { AbstractExtensionService, ResolvedExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
import { ExtensionHostKind, extensionRunningPreferenceToString, extensionHostKindToString, ExtensionRunningPreference } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
import { toExtensionDescription, ExtensionHostStartup, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
import '../common/extensionsProposedApi.js';
import { dedupExtensions } from '../common/extensionsUtil.js';
import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService.service';
import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service';
import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
var BrowserExtensionHostKindPicker_1;
let ExtensionService = class ExtensionService extends AbstractExtensionService {
constructor(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, _webExtensionsScannerService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, _userDataInitializationService, _userDataProfileService, _workspaceTrustManagementService, _remoteExplorerService, dialogService) {
super(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, dialogService);
this._browserEnvironmentService = _browserEnvironmentService;
this._webExtensionsScannerService = _webExtensionsScannerService;
this._userDataInitializationService = _userDataInitializationService;
this._userDataProfileService = _userDataProfileService;
this._workspaceTrustManagementService = _workspaceTrustManagementService;
this._remoteExplorerService = _remoteExplorerService;
lifecycleService.when(LifecyclePhase.Ready).then(async () => {
await this._userDataInitializationService.initializeInstalledExtensions(this._instantiationService);
this._initialize();
});
this._initFetchFileSystem();
}
_initFetchFileSystem() {
const provider = ( new FetchFileSystemProvider());
this._register(this._fileService.registerProvider(Schemas.http, provider));
this._register(this._fileService.registerProvider(Schemas.https, provider));
}
async _scanWebExtensions() {
const system = [], user = [], development = [];
try {
await Promise.all([
this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, { skipInvalidExtensions: true }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
]);
}
catch (error) {
this._logService.error(error);
}
return dedupExtensions(system, user, [], development, this._logService);
}
async _resolveExtensionsDefault() {
const [localExtensions, remoteExtensions] = await Promise.all([
this._scanWebExtensions(),
this._remoteExtensionsScannerService.scanExtensions()
]);
return ( new ResolvedExtensions(
localExtensions,
remoteExtensions,
false,
true
));
}
async _resolveExtensions() {
if (!this._browserEnvironmentService.expectsResolverExtension) {
return this._resolveExtensionsDefault();
}
const remoteAuthority = this._environmentService.remoteAuthority;
await this._workspaceTrustManagementService.workspaceResolved;
let resolverResult;
try {
resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
}
catch (err) {
if (RemoteAuthorityResolverError.isHandled(err)) {
console.log(`Error handled: Not showing a notification for the error`);
}
this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
return this._resolveExtensionsDefault();
}
this._remoteAuthorityResolverService._setResolvedAuthority(resolverResult.authority, resolverResult.options);
this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
const connection = this._remoteAgentService.getConnection();
if (connection) {
connection.onDidStateChange(async (e) => {
if (e.type === PersistentConnectionEventType.ConnectionLost) {
this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
}
});
connection.onReconnecting(() => this._resolveAuthorityAgain());
}
return this._resolveExtensionsDefault();
}
async _onExtensionHostExit(code) {
this._doStopExtensionHosts();
const automatedWindow = mainWindow;
if (typeof automatedWindow.codeAutomationExit === 'function') {
automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));
}
}
async _resolveAuthority(remoteAuthority) {
return this._resolveAuthorityOnExtensionHosts(ExtensionHostKind.LocalWebWorker, remoteAuthority);
}
};
ExtensionService = ( __decorate([
( __param(3, IInstantiationService)),
( __param(4, INotificationService)),
( __param(5, IBrowserWorkbenchEnvironmentService)),
( __param(6, ITelemetryService)),
( __param(7, IWorkbenchExtensionEnablementService)),
( __param(8, IFileService)),
( __param(9, IProductService)),
( __param(10, IWorkbenchExtensionManagementService)),
( __param(11, IWorkspaceContextService)),
( __param(12, IConfigurationService)),
( __param(13, IExtensionManifestPropertiesService)),
( __param(14, IWebExtensionsScannerService)),
( __param(15, ILogService)),
( __param(16, IRemoteAgentService)),
( __param(17, IRemoteExtensionsScannerService)),
( __param(18, ILifecycleService)),
( __param(19, IRemoteAuthorityResolverService)),
( __param(20, IUserDataInitializationService)),
( __param(21, IUserDataProfileService)),
( __param(22, IWorkspaceTrustManagementService)),
( __param(23, IRemoteExplorerService)),
( __param(24, IDialogService))
], ExtensionService));
let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
constructor(_extensionsProposedApi, _scanWebExtensions, _getExtensionRegistrySnapshotWhenReady, _instantiationService, _remoteAgentService, _remoteAuthorityResolverService, _extensionEnablementService, _logService) {
this._extensionsProposedApi = _extensionsProposedApi;
this._scanWebExtensions = _scanWebExtensions;
this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
this._instantiationService = _instantiationService;
this._remoteAgentService = _remoteAgentService;
this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
this._extensionEnablementService = _extensionEnablementService;
this._logService = _logService;
}
createExtensionHost(runningLocations, runningLocation, isInitialStart) {
switch (runningLocation.kind) {
case ExtensionHostKind.LocalProcess: {
return null;
}
case ExtensionHostKind.LocalWebWorker: {
const startup = (isInitialStart
? ExtensionHostStartup.EagerManualStart
: ExtensionHostStartup.EagerAutoStart);
return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
}
case ExtensionHostKind.Remote: {
const remoteAgentConnection = this._remoteAgentService.getConnection();
if (remoteAgentConnection) {
return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
}
return null;
}
}
}
_createLocalExtensionHostDataProvider(runningLocations, desiredRunningLocation, isInitialStart) {
return {
getInitData: async () => {
if (isInitialStart) {
const localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, await this._scanWebExtensions(), true);
const runningLocation = runningLocations.computeRunningLocation(localExtensions, [], false);
const myExtensions = filterExtensionDescriptions(localExtensions, runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
const extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
return { extensions };
}
else {
const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
const myExtensions = runningLocations.filterByRunningLocation(snapshot.extensions, desiredRunningLocation);
const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
return { extensions };
}
}
};
}
_createRemoteExtensionHostDataProvider(runningLocations, remoteAuthority) {
return {
remoteAuthority: remoteAuthority,
getInitData: async () => {
const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
const remoteEnv = await this._remoteAgentService.getEnvironment();
if (!remoteEnv) {
throw ( new Error('Cannot provide init data for remote extension host!'));
}
const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, ExtensionHostKind.Remote);
const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
return {
connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
pid: remoteEnv.pid,
appRoot: remoteEnv.appRoot,
extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
globalStorageHome: remoteEnv.globalStorageHome,
workspaceStorageHome: remoteEnv.workspaceStorageHome,
extensions,
};
}
};
}
};
BrowserExtensionHostFactory = ( __decorate([
( __param(3, IInstantiationService)),
( __param(4, IRemoteAgentService)),
( __param(5, IRemoteAuthorityResolverService)),
( __param(6, IWorkbenchExtensionEnablementService)),
( __param(7, ILogService))
], BrowserExtensionHostFactory));
let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class BrowserExtensionHostKindPicker {
constructor(_logService) {
this._logService = _logService;
}
pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
const result = BrowserExtensionHostKindPicker_1.pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference);
this._logService.trace(`pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(', ')}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`);
return result;
}
static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
const result = [];
let canRunRemotely = false;
for (const extensionKind of extensionKinds) {
if (extensionKind === 'ui' && isInstalledRemotely) {
if (preference === ExtensionRunningPreference.Remote) {
return ExtensionHostKind.Remote;
}
else {
canRunRemotely = true;
}
}
if (extensionKind === 'workspace' && isInstalledRemotely) {
if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Remote) {
return ExtensionHostKind.Remote;
}
else {
result.push(ExtensionHostKind.Remote);
}
}
if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Local) {
return ExtensionHostKind.LocalWebWorker;
}
else {
result.push(ExtensionHostKind.LocalWebWorker);
}
}
}
if (canRunRemotely) {
result.push(ExtensionHostKind.Remote);
}
return (result.length > 0 ? result[0] : null);
}
};
BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([
( __param(0, ILogService))
], BrowserExtensionHostKindPicker));
export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker, ExtensionService };