After update, old Eclipse plugins remain in "plugins" folder (there are also leftovers in "features" folder).
Is there a way to remove those automatically?
After update, old Eclipse plugins remain in "plugins" folder (there are also leftovers in "features" folder).
Is there a way to remove those automatically?
I use the following command:
eclipse -application org.eclipse.equinox.p2.garbagecollector.application -profile epp.package.jee
Notes:
This is documented in Equinox/p2/FAQ, see "Why aren't bundles being removed when their associated feature has been removed?"
The FAQ answer references an Eclipse Community Forum thread "Plug-in jar remains after feature uninstall" (June 2010) as the origin for this recipe.
The recipe is still valid nowadays, with Eclipse 4.8 Photon.
The -profile
argument depends on what packaging of Eclipse IDE you are using. The above one (epp.package.jee
) is for "Eclipse for Java EE Developers". I found it in the file configuration/config.ini
. The relevant line there is the following:
eclipse.p2.profile=epp.package.jee
To get rid of the old plugins you have to clear the Installation History. Go to Help | About Eclipse | Installation Details | Installation History and select all the old stuff. Then click delete and restart. Voila. This works with Eclipse Helios (3.6)
I also want to remove old plugins, but still found no answer today, so I wrote a quick and dirty script guess-old-eclipse-plugins.sh
to handle old plugins.
This script will scan plugins directory under Eclipse directory. and will generate a remove-old-eclipse-plugins.txt
file which can be used to remove old plugins.
This script is tested under Cygwin 1.7.15 on Windows XP.
PluginsDir=plugins
FeaturesDir=features
PluginIDSeparator=_
RemovingScriptFileName=remove-old-eclipse-plugins.txt
rm -rf $RemovingScriptFileName
#for dir in $PluginsDir $FeaturesDir
for dir in $PluginsDir # $FeaturesDir: most file names in features dir contains more than 1 _ character
do
echo "Processing [$dir] directory..."
# split PluginID from filename
# (not reliable, but general working. (ex: will get one junit PluginID because there're move than 1 _ characters in file name))
file_list=$(ls $dir);
echo "$file_list" | cut -f1 -d $PluginIDSeparator > $dir-all.txt
echo "$file_list" | cut -f1 -d $PluginIDSeparator | uniq > $dir-uniq.txt
# get the PluginList which VERY POSSIBLY has old versions
diff_result=$(diff -U 0 $dir-uniq.txt $dir-all.txt)
plugins_which_has_old_versions=$(echo "$diff_result" | grep -e "^+[^+]" | cut -f 2 -d +)
#
for p in $(echo "$plugins_which_has_old_versions")
do
echo "$p"
i=0
for f in $(ls -d -t $dir/$p$PluginIDSeparator*) # use 'ls' command, can sort result by file time, but can not handle file name contains special characters (white space) when using wildcard
#for f in $(find $dir -name "$p$PluginIDSeparator*") # use 'find' command
do
if [ -d $f ]
then
# should use rm -rf
echo -n "[D]"
else
echo -n " "
fi
echo -n "$f"
((i++))
if [ $i -eq 1 ]
then
echo ""
continue # first file, the newest version
fi
echo " [old]"
echo "rm -rf $f" >> $RemovingScriptFileName
done
echo
done
done
Before use the generated remove-old-eclipse-plugins.txt
file to remove plugins, make sure all the listed plugins in it are REALLY old plugins. Because, this script can't handle file name contains more than 1 _
characters. For example: JUnit v3 and v4 plugins are 2 different plugins, but the script will treat it as same plugins because these 2 file names use same org.junit_
prefix.
org.junit
[D]plugins/org.junit_3.8.2.v3_8_2_v20100427-1100
[D]plugins/org.junit_4.8.2.v4_8_2_v20110321-1705 [old] <-- wrong
So, use it VERY CAREFULLY, remove the wrong part before use it, or your Eclipse IDE may not work properly.
$ ./guess-old-eclipse-plugins.sh
Processing [plugins] directory...
org.eclipse.gef
plugins/org.eclipse.gef_3.7.2.v20111106-2020.jar
plugins/org.eclipse.gef_3.6.2.v20110110-2020.jar [old]
org.eclipse.help.base
plugins/org.eclipse.help.base_3.6.2.v201202080800.jar
plugins/org.eclipse.help.base_3.5.3.v201102101200.jar [old]
org.eclipse.help.ui
plugins/org.eclipse.help.ui_3.5.101.r37_20110819.jar
plugins/org.eclipse.help.ui_3.5.3.r36_20101116.jar [old]
...
rm -rf plugins/org.eclipse.gef_3.6.2.v20110110-2020.jar
rm -rf plugins/org.eclipse.help.base_3.5.3.v201102101200.jar
rm -rf plugins/org.eclipse.help.ui_3.5.3.r36_20101116.jar
rm -rf plugins/org.eclipse.help.webapp_3.5.3.r36_20101130.jar
rm -rf plugins/org.eclipse.jdt.apt.core_3.3.402.R36_v20110120-1000.jar
rm -rf plugins/org.eclipse.jdt.debug.ui_3.5.2.v20100928a_r362.jar
Removing old plugins is always a hassle. Especially when you upgrade and your Eclipse just doesn't want to start again and you need to figure it out via the metadata hell of plugins dependencies.
I've seen that couple of you tried to fix this via a script.
Well I have created a java based tool (with tests, build by maven & hosted at github, so you are free to fork it) that checks for duplicities of plugins by introspecting manifest files (or file names if the manifest is incomplete or corrupted).
you can quite easily for example download the latest Eclipse and put your old Eclipse into dropins/eclipse
folder and the tool will clean up the dropins folder - thus your new bundles are preserved and old one are deleted (The dropins
folder is prefered for deletion if 2 or more same versions are found).
More information about the Eclipse Plugin Cleaner can be found at https://github.com/azachar/eclipse-plugin-cleaner
Instead of sorting, etc. the solutions should be based on the contents of bundles.info
.
Manual solution:
eclipse/configuration/org.eclipse.equinox.simpleconfigurator/bundles.info
.*plugins/([^,]*),.*
, replace with: $1
(e.g. using Notepad++)eclipse/plugin/
I've modified the script to allow for all dropins, features, and plugins. First it relies on reverse sort to guess the most recent canonical plugin version.
Next it reduces that qualified plugin version name to a canonical plugin sed expression. If the plugin is the first match for this expression it stores its pattern and keeps it, otherwise it is an old stale version and it flags it for deletion.
# scan_old_plugins.sh
# script to scan for duplicate old eclipse features, plugins and dropins
# generates a "clean-old-plugins.sh" script to clean old versions.
# warning: DANGEROUS! review clean-old-plugins script before running it.
DropinsDir=dropins
FeaturesDir=features
PluginsDir=plugins
CanonicalPluginsFile=sed_canonical_plugins.sh
CleanPluginScriptFile=clean_old_plugins.sh
echo "" > $CanonicalPluginsFile
echo "" > $CleanPluginScriptFile
#for dir in $PluginsDir
for dir in $FeaturesDir $PluginsDir $DropinsDir
do
echo "Processing [$dir] directory..."
#
file_list=$(\ls -1 $dir | sort -r);
echo "$file_list" > $dir-all.txt
#
for p in $(echo "$file_list")
do
v=$(echo $p | sed -e 's/_[0-9\._\-]*/_.*/g' | sed -e 's/[0-9][0-9]*/.*/g')
g=$(grep -l "$v" $CanonicalPluginsFile | head -1 | awk '{print $1}')
if [ "$g" = "" ]; then
echo "$p=keep";
echo "$v=$p" >> $CanonicalPluginsFile
else
echo "$p=stale";
echo "rm -rf $p" >> $CleanPluginScriptFile
fi
done
done
For me this works:
eclipse -application org.eclipse.equinox.p2.garbagecollector.application -profile SDKProfile
Tested Eclipse v4.9. Removes old version of my plugins.
The profile epp.package.jee
mentioned in other solutions returns "not existing" for me.
With Ganymede (3.4), the correct way to manage your plugins would be to drop them in the 'dropins' folder:
\[eclipse\]/dropins/eclemma1.3.1/eclipse/(plugins|features)
That plugin will be detected by the 'p2' provisioning mechanism and used, but not copied in the plugins and features directories of eclipse. It stays in the dropins folder.
When you will drop eclemma1.3.2, all you have to do is delete eclemma1.3.1 from your dropins directory, and that old version is gone.
Eclipse allows you to revert back to any previous configuration (go to the Help menu, then "Software Updates"). My guess is that Eclipse won't remove these old versions, or this functionality would no longer work.
If when you restart Eclipse you provide the "-clean" argument, it performs various cleanup operations, but for reasons stated above I don't think it will remove old plugins/features.
I've created a script in python to move the old plugins to a backup folder, so if something goes wrong it can go back. The script has two modes of operation: Manual mode asks you what to do with each duplicated plugin detected, and automatic only question in cases where the length of the string has changed and therefore may have changed the system, or version numbering.
I hope this helps someone
# -*- coding: utf-8 -*-
import os
import re
from datetime import datetime
directory="C:\\eclipse64\\plugins"
dirBackup="C:\\eclipse64\\PluginsBackup" #This folder is a kind of recycle bin for save deleted plugins. In case you have problems running eclipse after remove them you can restore them. If you don't detect any problem you can erase this folder to save disk space
manual=False #Verifying deletion of each plugin manually (True) or automatic (False)
def globRegEx(directory,pat,absolutePath=True,type_=0):
'''Function that given a directory and a regular pattern returns a list of files that meets the pattern
:param str directory: Base path where we search for files that meet the pattern
:param str pat: Regular expression that selected files must match
:param bool absolutePath: Optional parameter that indicates if the returned list contains absolute (True) or relative paths (False)
:param int type_: Type of selection 0: selects files and directories 1: only selects files 2: only selects directories
:return: a list with the paths that meet the regular pattern
'''
names=os.listdir(directory)
pat=re.compile(pat)
res=[]
for name in names:
if pat.match(name):
path=directory+os.sep+name
if type_==1 and os.path.isfile(path):
res.append(path if absolutePath else name)
elif type_==2 and os.path.isdir(path):
res.append(path if absolutePath else name)
elif type_==0:
res.append(path if absolutePath else name)
return(res)
def processRepeated(repList):
''' this function is responsible for leaving only the newer version of the plugin
'''
if repList and len(repList)>1: #If the plugin is repeated
repList.sort(reverse=True)
print("Repeated plugins found:")
min=len(repList[0]) # If strings haven't got the same length indicates a change in the numeration version system
max=min
newer=datetime.fromtimestamp(0)
sel=0
for i,path in enumerate(repList):
lr=len(path)
modifDate=datetime.fromtimestamp((os.path.getctime(path)))
if modifDate>newer: #Keep the last creation date and its index
newer=modifDate
sel=i+1
if lr<min:
min=lr
elif lr>max:
max=lr
print(str(i+1) + " " + modifDate.strftime("%Y-%m-%d") + ": " + path)
print(" ")
if manual or min!=max: #If manual mode is enabled or if there is a string length diference between different version of plugins
selec=raw_input("Which version do you want to keep?: ["+str(sel)+"] ")
if selec:
selec=int(selec)
else:
selec=sel #Newer is the Default value
else:
selec=1
del(repList[selec-1]) #Delete selected plugin from the list
for path in repList: #Move the rest of the list to the backup folder
print("Deleting: "+ path)
os.renames(path,os.path.join(dirBackup,os.path.basename(path)))
print("-------------------------------------\n\n")
def main():
filePlugins=globRegEx(directory,"^.*$",False,1) #Creates a list with all the files only
dirPlugins=globRegEx(directory,"^.*$",False,2) #Creates a list with all the folders only
#Process files first
for plugin in filePlugins:
m=re.match(r"(.*_)\d.*?\.jar$",plugin) #Creates the glob pattern
if m:
patAux=m.groups()[0]+".*?\.jar$"
find=globRegEx(directory,patAux,True,1)
processRepeated(find)
#Now Directories
for plugin in dirPlugins:
m=re.match(r"(.*_)\d.*$",plugin) #Creates the glob pattern
if m:
patAux=m.groups()[0]+".*$"
find=globRegEx(directory,patAux,True,2)
processRepeated(find)
if __name__=="__main__":
main()
For STM32CubeIDE, a popular Eclipse-based IDE for the STM32 microcontroller-family, this command did clean-up old plugin versions under Windows 10:
"C:\ST\STM32CubeIDE_1.3.0\STM32CubeIDE\eclipsec" -application org.eclipse.equinox.p2.garbagecollector.application -profile STM32CubeIDE
The most simple, clean and efficient solution is to simply delete the current Eclipse installation and install the latest Eclipse version (or reinstall the current version).
eclipse-java-2021-06-R-win32-x86_64.zip
eclipse
directory containing the current Eclipse installationeclipse
directoryAnother solution is to automate removal by configuring Equinox:
Configure your product to invoke a GC on startup by adding the following line to your product's plugin_customization.ini
(requires the org.eclipse.equinox.p2.ui.sdk.scheduler
bundle):
org.eclipse.equinox.p2.ui.sdk.scheduler/gcOnStartup=true
Manual: Run the garbage collector application:
eclipse -application org.eclipse.equinox.p2.garbagecollector.application -profile SDKProfile