How does Theia listen to install and uninstall vscode plug-ins at runtime

[zx616456607]

Please give a code example, thank you

[martin-fleck-at]

Hi @zx616456607,

You can use the HostedPluginSupport to see if plugins were installed or uninstalled by listening to the onDidChangePlugins event. The event itself will not contain any information about what exactly was installed or uninstalled so you need to track that yourself by retrieving the up-to-date set of plugins using plugins from the same class and doing a diff.

You can see an example for querying the data in the PluginsWidget:

theia/packages/plugin-ext/src/main/browser/plugin-ext-widget.tsx

Lines 32 to 81 in c97a496

	export class PluginWidget extends ReactWidget {
	@inject(HostedPluginSupport)
	protected readonly pluginService: HostedPluginSupport;
	@inject(ProgressBarFactory)
	protected readonly progressBarFactory: ProgressBarFactory;
	constructor() {
	super();
	this.id = 'plugins';
	this.title.label = PLUGINS_LABEL;
	this.title.caption = PLUGINS_LABEL;
	this.title.iconClass = codicon('diff-added');
	this.title.closable = true;
	this.node.tabIndex = 0;
	this.addClass('theia-plugins');
	this.update();
	}
	@postConstruct()
	protected init(): void {
	this.toDispose.push(this.pluginService.onDidChangePlugins(() => this.update()));
	}
	protected override onActivateRequest(msg: Message): void {
	super.onActivateRequest(msg);
	this.node.focus();
	}
	protected readonly toDisposeProgress = new DisposableCollection();
	protected render(): React.ReactNode {
	return <div ref={ref => {
	this.toDisposeProgress.dispose();
	this.toDispose.push(this.toDisposeProgress);
	if (ref) {
	this.toDispose.push(this.progressBarFactory({ container: this.node, insertMode: 'prepend', locationId: PluginProgressLocation }));
	}
	}}>{this.doRender()}</div>;
	}
	protected doRender(): React.ReactNode {
	const plugins = this.pluginService.plugins;
	if (!plugins.length) {
	return <AlertMessage type='INFO' header='No plugins currently available.' />;
	}
	return <React.Fragment>{this.renderPlugins(plugins)}</React.Fragment>;
	}

Another example where we have a keep the list of installed VS Code plugins is VSXExtensionsModel:

theia/packages/vsx-registry/src/browser/vsx-extensions-model.ts

Lines 242 to 268 in c97a496

	protected async updateInstalled(): Promise<void> {
	const prevInstalled = this._installed;
	return this.doChange(async () => {
	const plugins = this.pluginSupport.plugins;
	const currInstalled = new Set<string>();
	const refreshing = [];
	for (const plugin of plugins) {
	if (plugin.model.engine.type === 'vscode') {
	const version = plugin.model.version;
	const id = plugin.model.id;
	this._installed.delete(id);
	const extension = this.setExtension(id);
	currInstalled.add(extension.id);
	refreshing.push(this.refresh(id, version));
	}
	}
	for (const id of this._installed) {
	const extension = this.getExtension(id);
	if (!extension) { continue; }
	refreshing.push(this.refresh(id, extension.version));
	}
	const installed = new Set([...prevInstalled, ...currInstalled]);
	const installedSorted = Array.from(installed).sort((a, b) => this.compareExtensions(a, b));
	this._installed = new Set(installedSorted.values());
	await Promise.all(refreshing);
	});
	}

I hope that helps you get started with this.

[zx616456607]

version: 1.41.0
The first question: after uninstall plug-ins, 'this. puginSupport.plugins' access to or the old plugin list, there is no way to calculate the current which the plug-in uninstall.
Second question: you have installed the plug-in, different versions of the same plug-in installation, 'this.pluginSupport.plugins' unable to identify the latest version number, is there any other solutions?

[martin-fleck-at]

Hi @zx616456607,
You are right. I saw that there is an outOfSync flag on the plugin data which indicates that the installation status has changed. So I think if we can calculate the newly installed plugins and then filter the others through that flag we might get the behavior that we want:

        let pluginsById = new Map(this.pluginService.plugins.map(plugin => [plugin.model.id + '_' + plugin.model.version, plugin]));
        this.pluginService.onDidChangePlugins(() => {
            const newPluginsById = new Map(this.pluginService.plugins.map(plugin => [plugin.model.id + '_' + plugin.model.version, plugin]));
            const installed = [...newPluginsById.keys()].filter(newPluginId => !pluginsById.has(newPluginId)).map(id => newPluginsById.get(id)!);
            const uninstalled = [...newPluginsById.values()].filter(plugin => !installed.includes(plugin) && plugin.outOfSync);
            console.log('INSTALLED', installed);
            console.log('UNINSTALLED', uninstalled);
            pluginsById = newPluginsById;
        });

Regarding your second question: It seems that there is a bug somewhere indeed. I tested it when having a version 0.0.1 installed and then installing a version 0.0.2, I still get 0.0.1 reported as deployed plugin. I'll investigate this a bit more later today.

[zx616456607]

HostedPluginSupport onDidChangePluginsEmitter in class can return to the latest list of plugins? undefined is currently returned

[martin-fleck-at]

So I did some digging into the code and it seems that plugins are handled like that on purpose:

theia/packages/plugin-ext/src/hosted/node/plugin-service.ts

Lines 111 to 134 in 118e514

	/**
	* Ensures that the plugin was not uninstalled when this session was started
	* and that it matches the first version of the given plugin seen by this session.
	*
	* The deployment system may have multiple versions of the same plugin available, but
	* a single session should only ever activate one of them.
	*/
	protected isRelevantPlugin(identifier: PluginIdentifiers.VersionedId): boolean {
	const versionAndId = PluginIdentifiers.idAndVersionFromVersionedId(identifier);
	if (!versionAndId) {
	return false;
	}
	const knownVersion = this.pluginVersions.get(versionAndId.id);
	if (knownVersion !== undefined && knownVersion !== versionAndId.version) {
	return false;
	}
	if (this.ignoredPlugins.has(identifier)) {
	return false;
	}
	if (knownVersion === undefined) {
	this.pluginVersions.set(versionAndId.id, versionAndId.version);
	}
	return true;
	}

Specifically, the the plugin system was modified to handle uninstallation and the presence of multiple versions in this PR so that:

• Most references to plugins include the version number through typing in most cases
• Uninstalling a plugin on the frontend will not delete the deployed files, and the plugin will remain active on the frontend until th application is restarted <-- This is the main reason we still get the "old" plugin version.

Since it was a very deliberate choice, I'm not sure we can simply change the behavior. Could you maybe open an issue on the Theia side so we can open up the discussion to a broader audience? I think the best option for now would be to make a clear distinction between deployed plugins (i.e., multiple versions possible) and active plugins (only the first version is available to the frontend until a reload happens).

[martin-fleck-at]

As for a local workaround in case you are blocked, I'd suggest to extend HostedPluginServerImpl with a method that does not do the isRelevantPlugin check so you can get all plugins in all versions.