@theia/plugin-ext 1.45.1 → 1.46.1

package/src/hosted/browser/hosted-plugin.ts

@@ -21,26 +21,24 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import debounce = require('@theia/core/shared/lodash.debounce');
-import { UUID } from '@theia/core/shared/@phosphor/coreutils';
-import { injectable, inject, interfaces, named, postConstruct } from '@theia/core/shared/inversify';
+import { generateUuid } from '@theia/core/lib/common/uuid';
+import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { PluginWorker } from './plugin-worker';
-import { PluginMetadata, getPluginId, HostedPluginServer, DeployedPlugin, PluginServer, PluginIdentifiers } from '../../common/plugin-protocol';
+import { getPluginId, DeployedPlugin, HostedPluginServer } from '../../common/plugin-protocol';
 import { HostedPluginWatcher } from './hosted-plugin-watcher';
-import { MAIN_RPC_CONTEXT, PluginManagerExt, ConfigStorage, UIKind } from '../../common/plugin-api-rpc';
+import { MAIN_RPC_CONTEXT, PluginManagerExt, UIKind } from '../../common/plugin-api-rpc';
 import { setUpPluginApi } from '../../main/browser/main-context';
 import { RPCProtocol, RPCProtocolImpl } from '../../common/rpc-protocol';
 import {
-    Disposable, DisposableCollection, Emitter, isCancelled,
-    ILogger, ContributionProvider, CommandRegistry, WillExecuteCommandEvent,
-    CancellationTokenSource, RpcProxy, ProgressService, nls
+    Disposable, DisposableCollection, isCancelled,
+    CommandRegistry, WillExecuteCommandEvent,
+    CancellationTokenSource, ProgressService, nls,
+    RpcProxy
 } from '@theia/core';
 import { PreferenceServiceImpl, PreferenceProviderProvider } from '@theia/core/lib/browser/preferences';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { PluginContributionHandler } from '../../main/browser/plugin-contribution-handler';
 import { getQueryParameters } from '../../main/browser/env-main';
-import { MainPluginApiProvider } from '../../common/plugin-ext-api-contribution';
-import { PluginPathsService } from '../../main/common/plugin-paths-protocol';
 import { getPreferences } from '../../main/browser/preference-registry-main';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
@@ -55,7 +53,6 @@ import { WebviewEnvironment } from '../../main/browser/webview/webview-environme
 import { WebviewWidget } from '../../main/browser/webview/webview';
 import { WidgetManager } from '@theia/core/lib/browser/widget-manager';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
-import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import URI from '@theia/core/lib/common/uri';
 import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
 import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
@@ -66,19 +63,21 @@ import { CustomEditorWidget } from '../../main/browser/custom-editors/custom-edi
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { ILanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/language';
 import { LanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageService';
-import { Measurement, Stopwatch } from '@theia/core/lib/common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
 import { BasicChannel } from '@theia/core/lib/common/message-rpc/channel';
 import { NotebookTypeRegistry, NotebookService, NotebookRendererMessagingService } from '@theia/notebook/lib/browser';
+import { ApplicationServer } from '@theia/core/lib/common/application-protocol';
+import {
+    AbstractHostedPluginSupport, PluginContributions, PluginHost,
+    ALL_ACTIVATION_EVENT, isConnectionScopedBackendPlugin
+} from '../common/hosted-plugin';
 
-export type PluginHost = 'frontend' | string;
 export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
 
 export const PluginProgressLocation = 'plugin';
-export const ALL_ACTIVATION_EVENT = '*';
 
 @injectable()
-export class HostedPluginSupport {
+export class HostedPluginSupport extends AbstractHostedPluginSupport<PluginManagerExt, RpcProxy<HostedPluginServer>> {
 
     protected static ADDITIONAL_ACTIVATION_EVENTS_ENV = 'ADDITIONAL_ACTIVATION_EVENTS';
     protected static BUILTIN_ACTIVATION_EVENTS = [
@@ -104,38 +103,18 @@ export class HostedPluginSupport {
         'onNotebookSerializer'
     ];
 
-    protected readonly clientId = UUID.uuid4();
-
-    protected container: interfaces.Container;
-
-    @inject(ILogger)
-    protected readonly logger: ILogger;
-
-    @inject(HostedPluginServer)
-    protected readonly server: RpcProxy<HostedPluginServer>;
-
     @inject(HostedPluginWatcher)
     protected readonly watcher: HostedPluginWatcher;
 
     @inject(PluginContributionHandler)
     protected readonly contributionHandler: PluginContributionHandler;
 
-    @inject(ContributionProvider)
-    @named(MainPluginApiProvider)
-    protected readonly mainPluginApiProviders: ContributionProvider<MainPluginApiProvider>;
-
-    @inject(PluginServer)
-    protected readonly pluginServer: PluginServer;
-
     @inject(PreferenceProviderProvider)
     protected readonly preferenceProviderProvider: PreferenceProviderProvider;
 
     @inject(PreferenceServiceImpl)
     protected readonly preferenceServiceImpl: PreferenceServiceImpl;
 
-    @inject(PluginPathsService)
-    protected readonly pluginPathsService: PluginPathsService;
-
     @inject(WorkspaceService)
     protected readonly workspaceService: WorkspaceService;
 
@@ -190,48 +169,23 @@ export class HostedPluginSupport {
     @inject(TerminalService)
     protected readonly terminalService: TerminalService;
 
-    @inject(EnvVariablesServer)
-    protected readonly envServer: EnvVariablesServer;
-
     @inject(JsonSchemaStore)
     protected readonly jsonSchemaStore: JsonSchemaStore;
 
     @inject(PluginCustomEditorRegistry)
     protected readonly customEditorRegistry: PluginCustomEditorRegistry;
 
-    @inject(Stopwatch)
-    protected readonly stopwatch: Stopwatch;
-
-    protected theiaReadyPromise: Promise<any>;
-
-    protected readonly managers = new Map<string, PluginManagerExt>();
-
-    protected readonly contributions = new Map<PluginIdentifiers.UnversionedId, PluginContributions>();
+    @inject(ApplicationServer)
+    protected readonly applicationServer: ApplicationServer;
 
-    protected readonly activationEvents = new Set<string>();
-
-    protected readonly onDidChangePluginsEmitter = new Emitter<void>();
-    readonly onDidChangePlugins = this.onDidChangePluginsEmitter.event;
-
-    protected readonly deferredWillStart = new Deferred<void>();
-    /**
-     * Resolves when the initial plugins are loaded and about to be started.
-     */
-    get willStart(): Promise<void> {
-        return this.deferredWillStart.promise;
-    }
-
-    protected readonly deferredDidStart = new Deferred<void>();
-    /**
-     * Resolves when the initial plugins are started.
-     */
-    get didStart(): Promise<void> {
-        return this.deferredDidStart.promise;
+    constructor() {
+        super(generateUuid());
     }
 
     @postConstruct()
-    protected init(): void {
-        this.theiaReadyPromise = Promise.all([this.preferenceServiceImpl.ready, this.workspaceService.roots]);
+    protected override init(): void {
+        super.init();
+
         this.workspaceService.onWorkspaceChanged(() => this.updateStoragePath());
 
         const languageService = (StandaloneServices.get(ILanguageService) as LanguageService);
@@ -277,254 +231,50 @@ export class HostedPluginSupport {
         });
     }
 
-    get plugins(): PluginMetadata[] {
-        const plugins: PluginMetadata[] = [];
-        this.contributions.forEach(contributions => plugins.push(contributions.plugin.metadata));
-        return plugins;
+    protected createTheiaReadyPromise(): Promise<unknown> {
+        return Promise.all([this.preferenceServiceImpl.ready, this.workspaceService.roots]);
     }
 
-    getPlugin(id: PluginIdentifiers.UnversionedId): DeployedPlugin | undefined {
-        const contributions = this.contributions.get(id);
-        return contributions && contributions.plugin;
+    protected override runOperation(operation: () => Promise<void>): Promise<void> {
+        return this.progressService.withProgress('', PluginProgressLocation, () => this.doLoad());
     }
 
-    /** do not call it, except from the plugin frontend contribution */
-    onStart(container: interfaces.Container): void {
-        this.container = container;
-        this.load();
+    protected override afterStart(): void {
         this.watcher.onDidDeploy(() => this.load());
         this.server.onDidOpenConnection(() => this.load());
     }
 
-    protected loadQueue: Promise<void> = Promise.resolve(undefined);
-    load = debounce(() => this.loadQueue = this.loadQueue.then(async () => {
-        try {
-            await this.progressService.withProgress('', PluginProgressLocation, () => this.doLoad());
-        } catch (e) {
-            console.error('Failed to load plugins:', e);
-        }
-    }), 50, { leading: true });
+    // Only load connection-scoped plugins
+    protected acceptPlugin(plugin: DeployedPlugin): boolean {
+        return isConnectionScopedBackendPlugin(plugin);
+    }
+
+    protected override async beforeSyncPlugins(toDisconnect: DisposableCollection): Promise<void> {
+        await super.beforeSyncPlugins(toDisconnect);
 
-    protected async doLoad(): Promise<void> {
-        const toDisconnect = new DisposableCollection(Disposable.create(() => { /* mark as connected */ }));
         toDisconnect.push(Disposable.create(() => this.preserveWebviews()));
         this.server.onDidCloseConnection(() => toDisconnect.dispose());
+    }
 
-        // process empty plugins as well in order to properly remove stale plugin widgets
-        await this.syncPlugins();
-
-        // it has to be resolved before awaiting layout is initialized
-        // otherwise clients can hang forever in the initialization phase
-        this.deferredWillStart.resolve();
-
+    protected override async beforeLoadContributions(toDisconnect: DisposableCollection): Promise<void> {
         // make sure that the previous state, including plugin widgets, is restored
         // and core layout is initialized, i.e. explorer, scm, debug views are already added to the shell
         // but shell is not yet revealed
         await this.appState.reachedState('initialized_layout');
+    }
 
-        if (toDisconnect.disposed) {
-            // if disconnected then don't try to load plugin contributions
-            return;
-        }
-        const contributionsByHost = this.loadContributions(toDisconnect);
-
+    protected override async afterLoadContributions(toDisconnect: DisposableCollection): Promise<void> {
         await this.viewRegistry.initWidgets();
         // remove restored plugin widgets which were not registered by contributions
         this.viewRegistry.removeStaleWidgets();
-        await this.theiaReadyPromise;
-
-        if (toDisconnect.disposed) {
-            // if disconnected then don't try to init plugin code and dynamic contributions
-            return;
-        }
-        await this.startPlugins(contributionsByHost, toDisconnect);
-
-        this.deferredDidStart.resolve();
-    }
-
-    /**
-     * Sync loaded and deployed plugins:
-     * - undeployed plugins are unloaded
-     * - newly deployed plugins are initialized
-     */
-    protected async syncPlugins(): Promise<void> {
-        let initialized = 0;
-        const waitPluginsMeasurement = this.measure('waitForDeployment');
-        let syncPluginsMeasurement: Measurement | undefined;
-
-        const toUnload = new Set(this.contributions.keys());
-        let didChangeInstallationStatus = false;
-        try {
-            const newPluginIds: PluginIdentifiers.VersionedId[] = [];
-            const [deployedPluginIds, uninstalledPluginIds] = await Promise.all([this.server.getDeployedPluginIds(), this.server.getUninstalledPluginIds()]);
-            waitPluginsMeasurement.log('Waiting for backend deployment');
-            syncPluginsMeasurement = this.measure('syncPlugins');
-            for (const versionedId of deployedPluginIds) {
-                const unversionedId = PluginIdentifiers.unversionedFromVersioned(versionedId);
-                toUnload.delete(unversionedId);
-                if (!this.contributions.has(unversionedId)) {
-                    newPluginIds.push(versionedId);
-                }
-            }
-            for (const pluginId of toUnload) {
-                this.contributions.get(pluginId)?.dispose();
-            }
-            for (const versionedId of uninstalledPluginIds) {
-                const plugin = this.getPlugin(PluginIdentifiers.unversionedFromVersioned(versionedId));
-                if (plugin && PluginIdentifiers.componentsToVersionedId(plugin.metadata.model) === versionedId && !plugin.metadata.outOfSync) {
-                    plugin.metadata.outOfSync = didChangeInstallationStatus = true;
-                }
-            }
-            for (const contribution of this.contributions.values()) {
-                if (contribution.plugin.metadata.outOfSync && !uninstalledPluginIds.includes(PluginIdentifiers.componentsToVersionedId(contribution.plugin.metadata.model))) {
-                    contribution.plugin.metadata.outOfSync = false;
-                    didChangeInstallationStatus = true;
-                }
-            }
-            if (newPluginIds.length) {
-                const plugins = await this.server.getDeployedPlugins({ pluginIds: newPluginIds });
-                for (const plugin of plugins) {
-                    const pluginId = PluginIdentifiers.componentsToUnversionedId(plugin.metadata.model);
-                    const contributions = new PluginContributions(plugin);
-                    this.contributions.set(pluginId, contributions);
-                    contributions.push(Disposable.create(() => this.contributions.delete(pluginId)));
-                    initialized++;
-                }
-            }
-        } finally {
-            if (initialized || toUnload.size || didChangeInstallationStatus) {
-                this.onDidChangePluginsEmitter.fire(undefined);
-            }
-
-            if (!syncPluginsMeasurement) {
-                // await didn't complete normally
-                waitPluginsMeasurement.error('Backend deployment failed.');
-            }
-        }
-        if (initialized > 0) {
-            // Only log sync measurement if there are were plugins to sync.
-            syncPluginsMeasurement?.log(`Sync of ${this.getPluginCount(initialized)}`);
-        } else {
-            syncPluginsMeasurement.stop();
-        }
     }
 
-    /**
-     * Always synchronous in order to simplify handling disconnections.
-     * @throws never
-     */
-    protected loadContributions(toDisconnect: DisposableCollection): Map<PluginHost, PluginContributions[]> {
-        let loaded = 0;
-        const loadPluginsMeasurement = this.measure('loadPlugins');
-
-        const hostContributions = new Map<PluginHost, PluginContributions[]>();
-        console.log(`[${this.clientId}] Loading plugin contributions`);
-        for (const contributions of this.contributions.values()) {
-            const plugin = contributions.plugin.metadata;
-            const pluginId = plugin.model.id;
-
-            if (contributions.state === PluginContributions.State.INITIALIZING) {
-                contributions.state = PluginContributions.State.LOADING;
-                contributions.push(Disposable.create(() => console.log(`[${pluginId}]: Unloaded plugin.`)));
-                contributions.push(this.contributionHandler.handleContributions(this.clientId, contributions.plugin));
-                contributions.state = PluginContributions.State.LOADED;
-                console.debug(`[${this.clientId}][${pluginId}]: Loaded contributions.`);
-                loaded++;
-            }
-
-            if (contributions.state === PluginContributions.State.LOADED) {
-                contributions.state = PluginContributions.State.STARTING;
-                const host = plugin.model.entryPoint.frontend ? 'frontend' : plugin.host;
-                const dynamicContributions = hostContributions.get(host) || [];
-                dynamicContributions.push(contributions);
-                hostContributions.set(host, dynamicContributions);
-                toDisconnect.push(Disposable.create(() => {
-                    contributions!.state = PluginContributions.State.LOADED;
-                    console.debug(`[${this.clientId}][${pluginId}]: Disconnected.`);
-                }));
-            }
-        }
-        if (loaded > 0) {
-            // Only log load measurement if there are were plugins to load.
-            loadPluginsMeasurement?.log(`Load contributions of ${this.getPluginCount(loaded)}`);
-        } else {
-            loadPluginsMeasurement.stop();
-        }
-
-        return hostContributions;
+    protected handleContributions(plugin: DeployedPlugin): Disposable {
+        return this.contributionHandler.handleContributions(this.clientId, plugin);
     }
 
-    protected async startPlugins(contributionsByHost: Map<PluginHost, PluginContributions[]>, toDisconnect: DisposableCollection): Promise<void> {
-        let started = 0;
-        const startPluginsMeasurement = this.measure('startPlugins');
-
-        const [hostLogPath, hostStoragePath, hostGlobalStoragePath] = await Promise.all([
-            this.pluginPathsService.getHostLogPath(),
-            this.getStoragePath(),
-            this.getHostGlobalStoragePath()
-        ]);
-
-        if (toDisconnect.disposed) {
-            return;
-        }
-
-        const thenable: Promise<void>[] = [];
-        const configStorage: ConfigStorage = {
-            hostLogPath,
-            hostStoragePath,
-            hostGlobalStoragePath
-        };
-
-        for (const [host, hostContributions] of contributionsByHost) {
-            // do not start plugins for electron browser
-            if (host === 'frontend' && environment.electron.is()) {
-                continue;
-            }
-
-            const manager = await this.obtainManager(host, hostContributions, toDisconnect);
-            if (!manager) {
-                continue;
-            }
-
-            const plugins = hostContributions.map(contributions => contributions.plugin.metadata);
-            thenable.push((async () => {
-                try {
-                    const activationEvents = [...this.activationEvents];
-                    await manager.$start({ plugins, configStorage, activationEvents });
-                    if (toDisconnect.disposed) {
-                        return;
-                    }
-                    console.log(`[${this.clientId}] Starting plugins.`);
-                    for (const contributions of hostContributions) {
-                        started++;
-                        const plugin = contributions.plugin;
-                        const id = plugin.metadata.model.id;
-                        contributions.state = PluginContributions.State.STARTED;
-                        console.debug(`[${this.clientId}][${id}]: Started plugin.`);
-                        toDisconnect.push(contributions.push(Disposable.create(() => {
-                            console.debug(`[${this.clientId}][${id}]: Stopped plugin.`);
-                            manager.$stop(id);
-                        })));
-
-                        this.activateByWorkspaceContains(manager, plugin);
-                    }
-                } catch (e) {
-                    console.error(`Failed to start plugins for '${host}' host`, e);
-                }
-            })());
-        }
-
-        await Promise.all(thenable);
-        await this.activateByEvent('onStartupFinished');
-        if (toDisconnect.disposed) {
-            return;
-        }
-
-        if (started > 0) {
-            startPluginsMeasurement.log(`Start of ${this.getPluginCount(started)}`);
-        } else {
-            startPluginsMeasurement.stop();
-        }
+    protected override handlePluginStarted(manager: PluginManagerExt, plugin: DeployedPlugin): void {
+        this.activateByWorkspaceContains(manager, plugin);
     }
 
     protected async obtainManager(host: string, hostContributions: PluginContributions[], toDisconnect: DisposableCollection): Promise<PluginManagerExt | undefined> {
@@ -557,7 +307,10 @@ export class HostedPluginSupport {
             const isElectron = environment.electron.is();
 
             const supportedActivationEvents = [...HostedPluginSupport.BUILTIN_ACTIVATION_EVENTS];
-            const additionalActivationEvents = await this.envServer.getValue(HostedPluginSupport.ADDITIONAL_ACTIVATION_EVENTS_ENV);
+            const [additionalActivationEvents, appRoot] = await Promise.all([
+                this.envServer.getValue(HostedPluginSupport.ADDITIONAL_ACTIVATION_EVENTS_ENV),
+                this.applicationServer.getApplicationRoot()
+            ]);
             if (additionalActivationEvents && additionalActivationEvents.value) {
                 additionalActivationEvents.value.split(',').forEach(event => supportedActivationEvents.push(event));
             }
@@ -572,7 +325,8 @@ export class HostedPluginSupport {
                     shell: defaultShell,
                     uiKind: isElectron ? UIKind.Desktop : UIKind.Web,
                     appName: FrontendApplicationConfigProvider.get().applicationName,
-                    appHost: isElectron ? 'desktop' : 'web' // TODO: 'web' could be the embedder's name, e.g. 'github.dev'
+                    appHost: isElectron ? 'desktop' : 'web', // TODO: 'web' could be the embedder's name, e.g. 'github.dev'
+                    appRoot
                 },
                 extApi,
                 webview: {
@@ -646,14 +400,6 @@ export class HostedPluginSupport {
         return globalStorageFolderFsPath;
     }
 
-    async activateByEvent(activationEvent: string): Promise<void> {
-        if (this.activationEvents.has(activationEvent)) {
-            return;
-        }
-        this.activationEvents.add(activationEvent);
-        await Promise.all(Array.from(this.managers.values(), manager => manager.$activateByEvent(activationEvent)));
-    }
-
     async activateByViewContainer(viewContainerId: string): Promise<void> {
         await Promise.all(this.viewRegistry.getContainerViews(viewContainerId).map(viewId => this.activateByView(viewId)));
     }
@@ -808,22 +554,6 @@ export class HostedPluginSupport {
         }
     }
 
-    async activatePlugin(id: string): Promise<void> {
-        const activation = [];
-        for (const manager of this.managers.values()) {
-            activation.push(manager.$activatePlugin(id));
-        }
-        await Promise.all(activation);
-    }
-
-    protected measure(name: string): Measurement {
-        return this.stopwatch.start(name, { context: this.clientId });
-    }
-
-    protected getPluginCount(plugins: number): string {
-        return `${plugins} plugin${plugins === 1 ? '' : 's'}`;
-    }
-
     protected readonly webviewsToRestore = new Map<string, WebviewWidget>();
     protected readonly webviewRevivers = new Map<string, (webview: WebviewWidget) => Promise<void>>();
 
@@ -889,22 +619,3 @@ export class HostedPluginSupport {
     }
 
 }
-
-export class PluginContributions extends DisposableCollection {
-    constructor(
-        readonly plugin: DeployedPlugin
-    ) {
-        super();
-    }
-    state: PluginContributions.State = PluginContributions.State.INITIALIZING;
-}
-
-export namespace PluginContributions {
-    export enum State {
-        INITIALIZING = 0,
-        LOADING = 1,
-        LOADED = 2,
-        STARTING = 3,
-        STARTED = 4
-    }
-}

package/src/hosted/browser/worker/debug-stub.ts

@@ -15,12 +15,13 @@
 // *****************************************************************************
 
 // eslint-disable-next-line @theia/runtime-import-check
+import { interfaces } from '@theia/core/shared/inversify';
 import { DebugExtImpl } from '../../../plugin/debug/debug-ext';
-import { RPCProtocol } from '../../../common/rpc-protocol';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-export function createDebugExtStub(rpc: RPCProtocol): DebugExtImpl {
-    return new Proxy(new DebugExtImpl(rpc), {
+export function createDebugExtStub(container: interfaces.Container): DebugExtImpl {
+    const delegate = container.get(DebugExtImpl);
+    return new Proxy(delegate, {
         apply: function (target, that, args): void {
             console.error('Debug API works only in plugin container');
         }

package/src/hosted/browser/worker/worker-env-ext.ts

@@ -14,23 +14,24 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from '@theia/core/shared/inversify';
 import { EnvExtImpl } from '../../../plugin/env';
-import { RPCProtocol } from '../../../common/rpc-protocol';
 
 /**
  * Worker specific implementation not returning any FileSystem details
  * Extending the common class
  */
+@injectable()
 export class WorkerEnvExtImpl extends EnvExtImpl {
 
-    constructor(rpc: RPCProtocol) {
-        super(rpc);
+    constructor() {
+        super();
     }
 
     /**
      * Throw error for app-root as there is no filesystem in worker context
      */
-    get appRoot(): string {
+    override get appRoot(): string {
         throw new Error('There is no app root in worker context');
     }