@theia/plugin-ext 1.27.0-next.77 → 1.27.0-next.78

package/src/hosted/node/hosted-plugin-deployer-handler.ts

@@ -46,7 +46,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
     protected readonly uninstallationManager: PluginUninstallationManager;
 
     private readonly deployedLocations = new Map<PluginIdentifiers.VersionedId, Set<string>>();
-    protected readonly originalLocations = new Map<PluginIdentifiers.VersionedId, string>();
+    protected readonly sourceLocations = new Map<PluginIdentifiers.VersionedId, Set<string>>();
 
     /**
      * Managed plugin metadata backend entries.
@@ -80,7 +80,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         const matches: DeployedPlugin[] = [];
         const handle = (plugins: Iterable<DeployedPlugin>): void => {
             for (const plugin of plugins) {
-                if (PluginIdentifiers.componentsToVersionWithId(plugin.metadata.model).version === pluginId) {
+                if (PluginIdentifiers.componentsToVersionWithId(plugin.metadata.model).id === pluginId) {
                     matches.push(plugin);
                 }
             }
@@ -117,28 +117,33 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         }
     }
 
-    async deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<void> {
+    async deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<number> {
+        let successes = 0;
         for (const plugin of frontendPlugins) {
-            await this.deployPlugin(plugin, 'frontend');
+            if (await this.deployPlugin(plugin, 'frontend')) { successes++; }
         }
         // resolve on first deploy
         this.frontendPluginsMetadataDeferred.resolve(undefined);
+        return successes;
     }
 
-    async deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<void> {
+    async deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<number> {
+        let successes = 0;
         for (const plugin of backendPlugins) {
-            await this.deployPlugin(plugin, 'backend');
+            if (await this.deployPlugin(plugin, 'backend')) { successes++; }
         }
         // rebuild translation config after deployment
         this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
         // resolve on first deploy
         this.backendPluginsMetadataDeferred.resolve(undefined);
+        return successes;
     }
 
     /**
-     * @throws never! in order to isolate plugin deployment
+     * @throws never! in order to isolate plugin deployment.
+     * @returns whether the plugin is deployed after running this function. If the plugin was already installed, will still return `true`.
      */
-    protected async deployPlugin(entry: PluginDeployerEntry, entryPoint: keyof PluginEntryPoint): Promise<void> {
+    protected async deployPlugin(entry: PluginDeployerEntry, entryPoint: keyof PluginEntryPoint): Promise<boolean> {
         const pluginPath = entry.path();
         const deployPlugin = this.stopwatch.start('deployPlugin');
         let id;
@@ -147,7 +152,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             const manifest = await this.reader.readPackage(pluginPath);
             if (!manifest) {
                 deployPlugin.error(`Failed to read ${entryPoint} plugin manifest from '${pluginPath}''`);
-                return;
+                return success = false;
             }
 
             const metadata = this.reader.readMetadata(manifest);
@@ -155,15 +160,15 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
 
             id = PluginIdentifiers.componentsToVersionedId(metadata.model);
 
-            const deployedLocations = this.deployedLocations.get(id) || new Set<string>();
+            const deployedLocations = this.deployedLocations.get(id) ?? new Set<string>();
             deployedLocations.add(entry.rootPath);
             this.deployedLocations.set(id, deployedLocations);
-            this.originalLocations.set(id, entry.originalPath());
+            this.setSourceLocationsForPlugin(id, entry);
 
             const deployedPlugins = entryPoint === 'backend' ? this.deployedBackendPlugins : this.deployedFrontendPlugins;
             if (deployedPlugins.has(id)) {
                 deployPlugin.debug(`Skipped ${entryPoint} plugin ${metadata.model.name} already deployed`);
-                return;
+                return true;
             }
 
             const { type } = entry;
@@ -173,23 +178,25 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             deployedPlugins.set(id, deployed);
             deployPlugin.log(`Deployed ${entryPoint} plugin "${id}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
         } catch (e) {
-            success = false;
             deployPlugin.error(`Failed to deploy ${entryPoint} plugin from '${pluginPath}' path`, e);
+            return success = false;
         } finally {
             if (success && id) {
-                this.uninstallationManager.markAsInstalled(id);
+                this.markAsInstalled(id);
             }
         }
+        return success;
     }
 
     async uninstallPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
         try {
-            const originalPath = this.originalLocations.get(pluginId);
-            if (!originalPath) {
+            const sourceLocations = this.sourceLocations.get(pluginId);
+            if (!sourceLocations) {
                 return false;
             }
-            await fs.remove(originalPath);
-            this.originalLocations.delete(pluginId);
+            await Promise.all(Array.from(sourceLocations,
+                location => fs.remove(location).catch(err => console.error(`Failed to remove source for ${pluginId} at ${location}`, err))));
+            this.sourceLocations.delete(pluginId);
             this.uninstallationManager.markAsUninstalled(pluginId);
             return true;
         } catch (e) {
@@ -198,6 +205,26 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         }
     }
 
+    protected markAsInstalled(id: PluginIdentifiers.VersionedId): void {
+        const metadata = PluginIdentifiers.idAndVersionFromVersionedId(id);
+        if (metadata) {
+            const toMarkAsUninstalled: PluginIdentifiers.VersionedId[] = [];
+            const checkForDifferentVersions = (others: Iterable<PluginIdentifiers.VersionedId>) => {
+                for (const other of others) {
+                    const otherMetadata = PluginIdentifiers.idAndVersionFromVersionedId(other);
+                    if (metadata.id === otherMetadata?.id && metadata.version !== otherMetadata.version) {
+                        toMarkAsUninstalled.push(other);
+                    }
+                }
+            };
+            checkForDifferentVersions(this.deployedFrontendPlugins.keys());
+            checkForDifferentVersions(this.deployedBackendPlugins.keys());
+            this.uninstallationManager.markAsUninstalled(...toMarkAsUninstalled);
+            this.uninstallationManager.markAsInstalled(id);
+            toMarkAsUninstalled.forEach(pluginToUninstall => this.uninstallPlugin(pluginToUninstall));
+        }
+    }
+
     async undeployPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
         this.deployedBackendPlugins.delete(pluginId);
         this.deployedFrontendPlugins.delete(pluginId);
@@ -220,4 +247,14 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
 
         return true;
     }
+
+    protected setSourceLocationsForPlugin(id: PluginIdentifiers.VersionedId, entry: PluginDeployerEntry): void {
+        const knownLocations = this.sourceLocations.get(id) ?? new Set();
+        const maybeStoredLocations = entry.getValue('sourceLocations');
+        const storedLocations = Array.isArray(maybeStoredLocations) && maybeStoredLocations.every(location => typeof location === 'string')
+            ? maybeStoredLocations.concat(entry.originalPath())
+            : [entry.originalPath()];
+        storedLocations.forEach(location => knownLocations.add(location));
+        this.sourceLocations.set(id, knownLocations);
+    }
 }

package/src/main/node/handlers/plugin-theia-file-handler.ts

@@ -66,6 +66,7 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
                         fs.copyFile(currentPath, newPath, error => error ? reject(error) : resolve());
                     });
                     context.pluginEntry().updatePath(newPath);
+                    context.pluginEntry().storeValue('sourceLocations', [newPath]);
                 } catch (e) {
                     console.error(`[${context.pluginEntry().id}]: Failed to copy to user directory. Future sessions may not have access to this plugin.`);
                 }

package/src/main/node/plugin-deployer-impl.ts

@@ -22,7 +22,7 @@ import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
     PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers
+    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -146,15 +146,16 @@ export class PluginDeployerImpl implements PluginDeployer {
         }
     }
 
-    async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
+    async deploy(plugin: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
         const deploy = this.measure('deploy');
-        await this.deployMultipleEntries([plugin]);
-        deploy.log(`Deploy plugin ${plugin}`);
+        const numDeployedPlugins = await this.deployMultipleEntries([plugin], options);
+        deploy.log(`Deploy plugin ${plugin.id}`);
+        return numDeployedPlugins;
     }
 
-    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
-        const pluginsToDeploy = await this.resolvePlugins(plugins);
-        await this.deployPlugins(pluginsToDeploy);
+    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<number> {
+        const pluginsToDeploy = await this.resolvePlugins(plugins, options);
+        return this.deployPlugins(pluginsToDeploy);
     }
 
     /**
@@ -166,7 +167,7 @@ export class PluginDeployerImpl implements PluginDeployer {
      * deployer.deployPlugins(await deployer.resolvePlugins(allPluginEntries));
      * ```
      */
-    async resolvePlugins(plugins: UnresolvedPluginEntry[]): Promise<PluginDeployerEntry[]> {
+    async resolvePlugins(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const visited = new Set<string>();
         const hasBeenVisited = (id: string) => visited.has(id) || (visited.add(id), false);
         const pluginsToDeploy = new Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>();
@@ -184,7 +185,7 @@ export class PluginDeployerImpl implements PluginDeployer {
                 }
                 const type = entry.type ?? PluginType.System;
                 try {
-                    const pluginDeployerEntries = await this.resolveAndHandle(entry.id, type);
+                    const pluginDeployerEntries = await this.resolveAndHandle(entry.id, type, options);
                     for (const deployerEntry of pluginDeployerEntries) {
                         const pluginData = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
                         const versionedId = pluginData && PluginIdentifiers.componentsToVersionedId(pluginData.metadata.model);
@@ -222,8 +223,8 @@ export class PluginDeployerImpl implements PluginDeployer {
         return [...pluginsToDeploy.values()];
     }
 
-    protected async resolveAndHandle(id: string, type: PluginType): Promise<PluginDeployerEntry[]> {
-        const entries = await this.resolvePlugin(id, type);
+    protected async resolveAndHandle(id: string, type: PluginType, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
+        const entries = await this.resolvePlugin(id, type, options);
         await this.applyFileHandlers(entries);
         await this.applyDirectoryFileHandlers(entries);
         return entries;
@@ -265,7 +266,7 @@ export class PluginDeployerImpl implements PluginDeployer {
     /**
      * deploy all plugins that have been accepted
      */
-    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<any> {
+    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<number> {
         const acceptedPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted());
         const acceptedFrontendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.FRONTEND));
         const acceptedBackendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.BACKEND));
@@ -282,12 +283,13 @@ export class PluginDeployerImpl implements PluginDeployer {
         const pluginPaths = acceptedBackendPlugins.map(pluginEntry => pluginEntry.path());
         this.logger.debug('local path to deploy on remote instance', pluginPaths);
 
-        await Promise.all([
+        const deployments = await Promise.all([
             // start the backend plugins
             this.pluginDeployerHandler.deployBackendPlugins(acceptedBackendPlugins),
             this.pluginDeployerHandler.deployFrontendPlugins(acceptedFrontendPlugins)
         ]);
         this.onDidDeployEmitter.fire(undefined);
+        return deployments.reduce<number>((accumulated, current) => accumulated += current ?? 0, 0);
     }
 
     /**
@@ -333,7 +335,7 @@ export class PluginDeployerImpl implements PluginDeployer {
     /**
      * Check a plugin ID see if there are some resolvers that can handle it. If there is a matching resolver, then we resolve the plugin
      */
-    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System): Promise<PluginDeployerEntry[]> {
+    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const pluginDeployerEntries: PluginDeployerEntry[] = [];
         const foundPluginResolver = this.pluginResolvers.find(pluginResolver => pluginResolver.accept(pluginId));
         // there is a resolver for the input
@@ -342,7 +344,7 @@ export class PluginDeployerImpl implements PluginDeployer {
             // create context object
             const context = new PluginDeployerResolverContextImpl(foundPluginResolver, pluginId);
 
-            await foundPluginResolver.resolve(context);
+            await foundPluginResolver.resolve(context, options);
 
             context.getPlugins().forEach(entry => {
                 entry.type = type;

package/src/main/node/plugin-server-handler.ts

@@ -18,7 +18,7 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { PluginDeployerImpl } from './plugin-deployer-impl';
 import { PluginsKeyValueStorage } from './plugins-key-value-storage';
-import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers } from '../../common/plugin-protocol';
+import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions } from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
 
 @injectable()
@@ -30,16 +30,20 @@ export class PluginServerHandler implements PluginServer {
     @inject(PluginsKeyValueStorage)
     protected readonly pluginsKeyValueStorage: PluginsKeyValueStorage;
 
-    deploy(pluginEntry: string, arg2?: PluginType | CancellationToken): Promise<void> {
+    async deploy(pluginEntry: string, arg2?: PluginType | CancellationToken, options?: PluginDeployOptions): Promise<void> {
         const type = typeof arg2 === 'number' ? arg2 as PluginType : undefined;
-        return this.doDeploy({
+        const succesfulDeployments = await this.doDeploy({
             id: pluginEntry,
             type: type ?? PluginType.User
-        });
+        }, options);
+        if (succesfulDeployments === 0) {
+            const optionText = options ? ` and options ${JSON.stringify(options)} ` : ' ';
+            throw new Error(`Deployment of extension with ID ${pluginEntry}${optionText}failed.`);
+        }
     }
 
-    protected doDeploy(pluginEntry: UnresolvedPluginEntry): Promise<void> {
-        return this.pluginDeployer.deploy(pluginEntry);
+    protected doDeploy(pluginEntry: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
+        return this.pluginDeployer.deploy(pluginEntry, options);
     }
 
     uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {

package/src/main/node/plugin-uninstallation-manager.ts

@@ -28,25 +28,39 @@ export class PluginUninstallationManager {
 
     protected uninstalledPlugins: PluginIdentifiers.VersionedId[] = [];
 
-    markAsUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+    protected fireDidChange(): void {
+        this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
+    }
+
+    markAsUninstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsUninstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
         if (!this.uninstalledPlugins.includes(pluginId)) {
             this.uninstalledPlugins.push(pluginId);
-            this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
             return true;
         }
         return false;
     }
 
-    markAsInstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+    markAsInstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsInstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsInstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
         let index: number;
         let didChange = false;
         while ((index = this.uninstalledPlugins.indexOf(pluginId)) !== -1) {
             this.uninstalledPlugins.splice(index, 1);
             didChange = true;
         }
-        if (didChange) {
-            this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
-        }
         return didChange;
     }
 

package/src/plugin/plugin-manager.ts

@@ -240,10 +240,10 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
 
     protected registerPlugin(plugin: Plugin): void {
         if (plugin.model.id === 'vscode.json-language-features' && this.jsonValidation.length) {
-            // VS Code contribute all built-in validations via vscode.json-language-features
-            // we enrich them with Theia validations registered on the startup
-            // dynamic validations can be provided only via VS Code extensions
-            // content is fetched by the extension later via vscode.workspace.openTextDocument
+            // VS Code contributes all built-in validations via vscode.json-language-features;
+            // we enrich them with Theia validations registered on startup.
+            // Dynamic validations can be provided only via VS Code extensions.
+            // Content is fetched by the extension later via vscode.workspace.openTextDocument.
             const contributes = plugin.rawModel.contributes = (plugin.rawModel.contributes || {});
             contributes.jsonValidation = (contributes.jsonValidation || []).concat(this.jsonValidation);
         }
@@ -337,11 +337,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     }
 
     protected async activateByBaseEvent(baseEvent: string): Promise<void> {
-        await Promise.all(Array.from(this.activations.keys(), activation => {
-            if (activation.startsWith(baseEvent)) {
-                return this.activateBySingleEvent(activation);
-            }
-        }));
+        await Promise.all(Array.from(this.activations.keys(), activation => activation.startsWith(baseEvent) && this.activateBySingleEvent(activation)));
     }
 
     protected async activateBySingleEvent(activationEvent: string): Promise<void> {