@theia/plugin-ext 1.27.0-next.37 → 1.27.0-next.41

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

@@ -17,11 +17,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { injectable, optional, multiInject, inject, named } from '@theia/core/shared/inversify';
+import * as semver from 'semver';
 import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
     PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry
+    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -135,7 +136,11 @@ export class PluginDeployerImpl implements PluginDeployer {
         deployPlugins.log('Deploy plugins list');
     }
 
-    async undeploy(pluginId: string): Promise<void> {
+    async uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        await this.pluginDeployerHandler.uninstallPlugin(pluginId);
+    }
+
+    async undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         if (await this.pluginDeployerHandler.undeployPlugin(pluginId)) {
             this.onDidDeployEmitter.fire();
         }
@@ -163,49 +168,49 @@ export class PluginDeployerImpl implements PluginDeployer {
      */
     async resolvePlugins(plugins: UnresolvedPluginEntry[]): Promise<PluginDeployerEntry[]> {
         const visited = new Set<string>();
-        const pluginsToDeploy = new Map<string, PluginDeployerEntry>();
+        const hasBeenVisited = (id: string) => visited.has(id) || (visited.add(id), false);
+        const pluginsToDeploy = new Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>();
+        const unversionedIdsHandled = new Map<PluginIdentifiers.UnversionedId, string[]>();
 
-        let queue: UnresolvedPluginEntry[] = [...plugins];
+        const queue: UnresolvedPluginEntry[] = [...plugins];
         while (queue.length) {
-            const dependenciesChunk: Array<{
+            const pendingDependencies: Array<{
                 dependencies: Map<string, string>
                 type: PluginType
             }> = [];
-            const workload: UnresolvedPluginEntry[] = [];
-            while (queue.length) {
-                const current = queue.shift()!;
-                if (visited.has(current.id)) {
-                    continue;
-                } else {
-                    workload.push(current);
-                }
-                visited.add(current.id);
-            }
-            queue = [];
-            await Promise.all(workload.map(async ({ id, type }) => {
-                if (type === undefined) {
-                    type = PluginType.System;
+            await Promise.all(queue.map(async entry => {
+                if (hasBeenVisited(entry.id)) {
+                    return;
                 }
+                const type = entry.type ?? PluginType.System;
                 try {
-                    const pluginDeployerEntries = await this.resolvePlugin(id, type);
-                    await this.applyFileHandlers(pluginDeployerEntries);
-                    await this.applyDirectoryFileHandlers(pluginDeployerEntries);
+                    const pluginDeployerEntries = await this.resolveAndHandle(entry.id, type);
                     for (const deployerEntry of pluginDeployerEntries) {
-                        const dependencies = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
-                        if (dependencies && !pluginsToDeploy.has(dependencies.metadata.model.id)) {
-                            pluginsToDeploy.set(dependencies.metadata.model.id, deployerEntry);
-                            if (dependencies.mapping) {
-                                dependenciesChunk.push({ dependencies: dependencies.mapping, type });
+                        const pluginData = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
+                        const versionedId = pluginData && PluginIdentifiers.componentsToVersionedId(pluginData.metadata.model);
+                        const unversionedId = versionedId && PluginIdentifiers.componentsToUnversionedId(pluginData.metadata.model);
+                        if (unversionedId && !pluginsToDeploy.has(versionedId)) {
+                            pluginsToDeploy.set(versionedId, deployerEntry);
+                            if (pluginData.mapping) {
+                                pendingDependencies.push({ dependencies: pluginData.mapping, type });
+                            }
+                            const otherVersions = unversionedIdsHandled.get(unversionedId) ?? [];
+                            otherVersions.push(pluginData.metadata.model.version);
+                            if (otherVersions.length === 1) {
+                                unversionedIdsHandled.set(unversionedId, otherVersions);
+                            } else {
+                                this.findBestVersion(unversionedId, otherVersions, pluginsToDeploy);
                             }
                         }
                     }
                 } catch (e) {
-                    console.error(`Failed to resolve plugins from '${id}'`, e);
+                    console.error(`Failed to resolve plugins from '${entry.id}'`, e);
                 }
             }));
-            for (const { dependencies, type } of dependenciesChunk) {
+            queue.length = 0;
+            for (const { dependencies, type } of pendingDependencies) {
                 for (const [dependency, deployableDependency] of dependencies) {
-                    if (!pluginsToDeploy.has(dependency)) {
+                    if (!unversionedIdsHandled.has(dependency as PluginIdentifiers.UnversionedId)) {
                         queue.push({
                             id: deployableDependency,
                             type
@@ -217,6 +222,46 @@ export class PluginDeployerImpl implements PluginDeployer {
         return [...pluginsToDeploy.values()];
     }
 
+    protected async resolveAndHandle(id: string, type: PluginType): Promise<PluginDeployerEntry[]> {
+        const entries = await this.resolvePlugin(id, type);
+        await this.applyFileHandlers(entries);
+        await this.applyDirectoryFileHandlers(entries);
+        return entries;
+    }
+
+    protected findBestVersion(unversionedId: PluginIdentifiers.UnversionedId, versions: string[], knownPlugins: Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>): void {
+        // If left better, return negative. Then best is index 0.
+        versions.map(version => ({ version, plugin: knownPlugins.get(PluginIdentifiers.idAndVersionToVersionedId({ version, id: unversionedId })) }))
+            .sort((left, right) => {
+                const leftPlugin = left.plugin;
+                const rightPlugin = right.plugin;
+                if (!leftPlugin && !rightPlugin) {
+                    return 0;
+                }
+                if (!rightPlugin) {
+                    return -1;
+                }
+                if (!leftPlugin) {
+                    return 1;
+                }
+                if (leftPlugin.type === PluginType.System && rightPlugin.type === PluginType.User) {
+                    return -1;
+                }
+                if (leftPlugin.type === PluginType.User && rightPlugin.type === PluginType.System) {
+                    return 1;
+                }
+                if (semver.gtr(left.version, right.version)) {
+                    return -1;
+                }
+                return 1;
+            }).forEach((versionedEntry, index) => {
+                if (index !== 0) {
+                    // Mark as not accepted to prevent deployment of all but the winner.
+                    versionedEntry.plugin?.accept();
+                }
+            });
+    }
+
     /**
      * deploy all plugins that have been accepted
      */

package/src/main/node/plugin-ext-backend-module.ts

@@ -39,6 +39,7 @@ import { PluginCliContribution } from './plugin-cli-contribution';
 import { PluginTheiaEnvironment } from '../common/plugin-theia-environment';
 import { PluginTheiaDeployerParticipant } from './plugin-theia-deployer-participant';
 import { WebviewBackendSecurityWarnings } from './webview-backend-security-warnings';
+import { PluginUninstallationManager } from './plugin-uninstallation-manager';
 
 export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginApiContribution).toSelf().inSingletonScope();
@@ -50,6 +51,8 @@ export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginDeployerContribution).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(PluginDeployerContribution);
 
+    bind(PluginUninstallationManager).toSelf().inSingletonScope();
+
     bind(PluginDeployerResolver).to(LocalDirectoryPluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(LocalFilePluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(GithubPluginDeployerResolver).inSingletonScope();

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 } from '../../common/plugin-protocol';
+import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers } from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
 
 @injectable()
@@ -42,7 +42,11 @@ export class PluginServerHandler implements PluginServer {
         return this.pluginDeployer.deploy(pluginEntry);
     }
 
-    undeploy(pluginId: string): Promise<void> {
+    uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        return this.pluginDeployer.uninstall(pluginId);
+    }
+
+    undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         return this.pluginDeployer.undeploy(pluginId);
     }
 

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

@@ -0,0 +1,60 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Emitter, Event } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { PluginIdentifiers } from '../../common';
+
+@injectable()
+export class PluginUninstallationManager {
+    protected readonly onDidChangeUninstalledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
+
+    get onDidChangeUninstalledPlugins(): Event<readonly PluginIdentifiers.VersionedId[]> {
+        return this.onDidChangeUninstalledPluginsEmitter.event;
+    }
+
+    protected uninstalledPlugins: PluginIdentifiers.VersionedId[] = [];
+
+    markAsUninstalled(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 {
+        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;
+    }
+
+    isUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        return this.uninstalledPlugins.includes(pluginId);
+    }
+
+    getUninstalledPluginIds(): readonly PluginIdentifiers.VersionedId[] {
+        return Object.freeze(this.uninstalledPlugins.slice());
+    }
+}