/*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.update.internal.core;
import org.eclipse.update.internal.model.SiteLocalModel;
import org.eclipse.core.runtime.ListenerList;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.configuration.IActivity;
import org.eclipse.update.configuration.IConfiguredSite;
import org.eclipse.update.configuration.IInstallConfiguration;
import org.eclipse.update.configuration.IInstallConfigurationChangedListener;
import org.eclipse.update.configuration.IProblemHandler;
import org.eclipse.update.configurator.ConfiguratorUtils;
import org.eclipse.update.configurator.IPlatformConfiguration;
import org.eclipse.update.core.FeatureContentProvider;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.IFeatureReference;
import org.eclipse.update.core.IPluginEntry;
import org.eclipse.update.core.ISite;
import org.eclipse.update.core.ISiteContentProvider;
import org.eclipse.update.core.ISiteFeatureReference;
import org.eclipse.update.core.Site;
import org.eclipse.update.core.SiteManager;
import org.eclipse.update.core.Utilities;
import org.eclipse.update.core.VersionedIdentifier;
import org.eclipse.update.core.model.SiteModel;
import org.eclipse.update.internal.configurator.ConfigurationActivator;
import org.eclipse.update.internal.configurator.FeatureEntry;
import org.eclipse.update.internal.configurator.PlatformConfiguration;
import org.eclipse.update.internal.configurator.PluginEntry;
import org.eclipse.update.internal.configurator.SiteEntry;
import org.eclipse.update.internal.model.ConfigurationActivityModel;
import org.eclipse.update.internal.model.ConfiguredSiteModel;
import org.eclipse.update.internal.model.InstallConfigurationModel;
import org.osgi.framework.Bundle;
/**
* Manages ConfiguredSites
*
*/
public class InstallConfiguration extends InstallConfigurationModel implements IInstallConfiguration {
private static boolean isWindows = System.getProperty("os.name").startsWith("Win"); //$NON-NLS-1$ //$NON-NLS-2$
private ListenerList listeners = new ListenerList(ListenerList.IDENTITY);
/*
* default constructor.
*/
public InstallConfiguration() {
}
/*
* Copy constructor
* @since 3.0
*/
public InstallConfiguration(IInstallConfiguration config) throws MalformedURLException, CoreException {
this(config, null, null);
}
/*
* copy constructor
*/
public InstallConfiguration(IInstallConfiguration config, URL newLocation, String label) throws CoreException, MalformedURLException {
// set current date and timeline as caller can call setDate if the
// date on the URL string has to be the same
Date now = new Date();
setCreationDate(now);
setCurrent(false);
if (newLocation == null) {
String newFileName = UpdateManagerUtils.getLocalRandomIdentifier(SiteLocalModel.CONFIG_FILE, now);
newLocation = UpdateManagerUtils.getURL(((LocalSite)SiteManager.getLocalSite()).getLocationURL(), newFileName, null);
}
setLocationURLString(newLocation.toExternalForm());
if (label == null)
label = Utilities.format(now);
setLabel(label);
// do not copy list of listeners nor activities
// make a copy of the siteConfiguration object
if (config != null) {
IConfiguredSite[] csites = config.getConfiguredSites();
if (csites != null) {
for (int i = 0; i < csites.length; i++) {
ConfiguredSite configSite = new ConfiguredSite(csites[i]);
addConfigurationSiteModel(configSite);
}
}
}
resolve(newLocation, null);
// no need to parse file, all data are initialized
initialized = true;
}
/*
* Returns the list of configured sites or an empty array
*/
public IConfiguredSite[] getConfiguredSites() {
ConfiguredSiteModel[] result = getConfigurationSitesModel();
if (result.length == 0)
return new IConfiguredSite[0];
else
return (IConfiguredSite[]) result;
}
/*
* Returns the default site policy
*/
private int getDefaultPolicy() {
return PlatformConfiguration.getDefaultPolicy();
}
/**
* Creates a Configuration Site and a new Site
* The policy is from <code> org.eclipse.core.boot.IPlatformConfiguration</code>
*/
public IConfiguredSite createConfiguredSite(File file) throws CoreException {
if (!file.getName().equals("eclipse")) { //$NON-NLS-1$
file = new File(file, "eclipse"); //$NON-NLS-1$
file.mkdirs();
}
if (isDuplicateSite(file))
throw Utilities.newCoreException(NLS.bind(Messages.InstallConfiguration_location_exists, (new String[] { file.getPath() })),null);
ISite site = InternalSiteManager.createSite(file);
//create a config site around the site
// even if the site == null
BaseSiteLocalFactory factory = new BaseSiteLocalFactory();
ConfiguredSite configSite = (ConfiguredSite) factory.createConfigurationSiteModel((SiteModel) site, getDefaultPolicy());
if (configSite.isNativelyLinked()) {
throw Utilities.newCoreException(Messages.InstallConfiguration_AlreadyNativelyLinked, null);
}
if (configSite.isProductSite()) {
throw Utilities.newCoreException(Messages.InstallConfiguration_AlreadyProductSite, null);
}
if (site != null) {
configSite.setPlatformURLString(site.getURL().toExternalForm());
// obtain the list of plugins
IPlatformConfiguration runtimeConfiguration = ConfiguratorUtils.getCurrentPlatformConfiguration();
ConfigurationPolicy configurationPolicy = configSite.getConfigurationPolicy();
String[] pluginPath = new String[0];
if (configurationPolicy.getPolicy() == IPlatformConfiguration.ISitePolicy.USER_INCLUDE)
pluginPath = configurationPolicy.getPluginPath(site);
// create new Site in configuration
IPlatformConfiguration.ISitePolicy sitePolicy = runtimeConfiguration.createSitePolicy(configurationPolicy.getPolicy(), pluginPath);
// change runtime
IPlatformConfiguration.ISiteEntry siteEntry = runtimeConfiguration.createSiteEntry(site.getURL(), sitePolicy);
runtimeConfiguration.configureSite(siteEntry);
// if the privatre marker doesn't already exist create it
configSite.createPrivateSiteMarker();
((SiteModel)site).setConfiguredSiteModel(configSite);
}
// configure all features as enable
configure(configSite);
return configSite;
}
/**
* Creates a Configuration Site and a new Site as a private link site
* The policy is from <code> org.eclipse.core.boot.IPlatformConfiguration</code>
*/
public IConfiguredSite createLinkedConfiguredSite(File file) throws CoreException {
return createConfiguredSite(file);
// if (isDuplicateSite(file))
// throw Utilities.newCoreException(UpdateUtils.getFormattedMessage("InstallConfiguration.location.exists", file.getPath()),null);
//
// ISite site = InternalSiteManager.createSite(file);
//
// //create a config site around the site
// // even if the site == null
// BaseSiteLocalFactory factory = new BaseSiteLocalFactory();
// ConfiguredSite configSite = (ConfiguredSite) factory.createConfigurationSiteModel((SiteModel) site, getDefaultPolicy());
//
// if (!configSite.isExtensionSite()) {
// String msg = Policy.bind("InstallConfiguration.NotAnExtensionSite");
// throw Utilities.newCoreException(msg, null);
// }
//
// if (configSite.isNativelyLinked()) {
// throw Utilities.newCoreException("InstallConfiguration.AlreadyNativelyLinked", null);
// }
//
// if (site != null) {
// configSite.setPlatformURLString(site.getURL().toExternalForm());
//
// // obtain the list of plugins
// IPlatformConfiguration runtimeConfiguration = ConfiguratorUtils.getCurrentPlatformConfiguration();
// ConfigurationPolicy configurationPolicy = configSite.getConfigurationPolicy();
// String[] pluginPath = new String[0];
// if (configurationPolicy.getPolicy() == IPlatformConfiguration.ISitePolicy.USER_INCLUDE)
// pluginPath = configurationPolicy.getPluginPath(site);
//
// // create new Site in configuration
// IPlatformConfiguration.ISitePolicy sitePolicy = runtimeConfiguration.createSitePolicy(configurationPolicy.getPolicy(), pluginPath);
//
// // change runtime
// IPlatformConfiguration.ISiteEntry siteEntry = runtimeConfiguration.createSiteEntry(site.getURL(), sitePolicy);
// runtimeConfiguration.configureSite(siteEntry);
//
// }
//
// // configure all features as enable
// configure(configSite);
//
// return configSite;
}
/*
*Configure all features as Enable Check we only enable highest version
*/
private void configure(ConfiguredSite linkedSite) throws CoreException {
ISite site = linkedSite.getSite();
ISiteFeatureReference[] newFeaturesRef = site.getFeatureReferences();
for (int i = 0; i < newFeaturesRef.length; i++) {
// TRACE
if (UpdateCore.DEBUG && UpdateCore.DEBUG_SHOW_RECONCILER) {
String reconciliationType = "enable (optimistic)"; //$NON-NLS-1$
UpdateCore.debug("New Linked Site:New Feature: " + newFeaturesRef[i].getURL() + " as " + reconciliationType); //$NON-NLS-1$ //$NON-NLS-2$
}
ConfigurationPolicy policy = linkedSite.getConfigurationPolicy();
policy.configure(newFeaturesRef[i], true, false);
}
SiteReconciler.checkConfiguredFeatures(linkedSite);
}
/*
*
*/
public void addConfiguredSite(IConfiguredSite site) {
if (!isCurrent() && isReadOnly())
return;
ConfigurationActivity activity = new ConfigurationActivity(IActivity.ACTION_SITE_INSTALL);
activity.setLabel(site.getSite().getURL().toExternalForm());
activity.setDate(new Date());
ConfiguredSiteModel configSiteModel = (ConfiguredSiteModel) site;
addConfigurationSiteModel(configSiteModel);
configSiteModel.setInstallConfigurationModel(this);
// notify listeners
Object[] configurationListeners = listeners.getListeners();
for (int i = 0; i < configurationListeners.length; i++) {
IInstallConfigurationChangedListener listener = ((IInstallConfigurationChangedListener) configurationListeners[i]);
listener.installSiteAdded(site);
}
// everything done ok
activity.setStatus(IActivity.STATUS_OK);
this.addActivity(activity);
}
/**
* Method addActivity.
* @param activity
*/
public void addActivity(IActivity activity) {
addActivityModel((ConfigurationActivityModel)activity);
}
/*
*
*/
public void removeConfiguredSite(IConfiguredSite site) {
if (!isCurrent() && isReadOnly())
return;
if (removeConfigurationSiteModel((ConfiguredSiteModel) site)) {
// notify listeners
Object[] configurationListeners = listeners.getListeners();
for (int i = 0; i < configurationListeners.length; i++) {
IInstallConfigurationChangedListener listener = ((IInstallConfigurationChangedListener) configurationListeners[i]);
listener.installSiteRemoved(site);
}
//activity
ConfigurationActivity activity = new ConfigurationActivity(IActivity.ACTION_SITE_REMOVE);
activity.setLabel(site.getSite().getURL().toExternalForm());
activity.setDate(new Date());
activity.setStatus(IActivity.STATUS_OK);
this.addActivity(activity);
}
}
/*
* @see IInstallConfiguration#addInstallConfigurationChangedListener(IInstallConfigurationChangedListener)
*/
public void addInstallConfigurationChangedListener(IInstallConfigurationChangedListener listener) {
listeners.add(listener);
}
/*
* @see IInstallConfiguration#removeInstallConfigurationChangedListener(IInstallConfigurationChangedListener)
*/
public void removeInstallConfigurationChangedListener(IInstallConfigurationChangedListener listener) {
listeners.remove(listener);
}
/*
* Deletes the configuration from its URL/location
*/
public void remove() {
// save the configuration
if ("file".equalsIgnoreCase(getURL().getProtocol())) { //$NON-NLS-1$
// the location points to a file
File file = new File(getURL().getFile());
UpdateManagerUtils.removeFromFileSystem(file);
}
}
/**
* Saves the configuration into its URL/location
* and changes the platform configuration.
* The runtime site entries from platform.xml are updated as required
* (cannot recreate these because must preserve other runtime state) [18520]
* @return true if restart is needed
*/
public boolean save() throws CoreException {
// Write info into platform for the next runtime
IPlatformConfiguration runtimeConfiguration = ConfiguratorUtils.getCurrentPlatformConfiguration();
ConfiguredSiteModel[] configurationSites = getConfigurationSitesModel();
// clean configured Entries from platform runtime
IPlatformConfiguration.IFeatureEntry[] configuredFeatureEntries = runtimeConfiguration.getConfiguredFeatureEntries();
for (int i = 0; i < configuredFeatureEntries.length; i++) {
runtimeConfiguration.unconfigureFeatureEntry(configuredFeatureEntries[i]);
}
// [19958] remember sites currently configured by runtime (use
// temp configuration object rather than a straight list to ensure
// correct lookup)
IPlatformConfiguration tempConfig = null;
try {
tempConfig = ConfiguratorUtils.getPlatformConfiguration(null);
IPlatformConfiguration.ISiteEntry[] tmpSites = runtimeConfiguration.getConfiguredSites();
for (int i = 0; i < tmpSites.length; i++) {
tempConfig.configureSite(tmpSites[i]);
}
} catch (IOException e) {
// assume no currently configured sites
}
//check sites
checkSites(configurationSites, runtimeConfiguration);
// Save the plugin path, primary feature and platform
for (int i = 0; i < configurationSites.length; i++) {
ConfiguredSite cSite = ((ConfiguredSite) configurationSites[i]);
ConfigurationPolicy configurationPolicy = cSite.getConfigurationPolicy();
savePluginPath(cSite, runtimeConfiguration, tempConfig);
// IF primary feature URL or platform feature URL that we need to pass to runtime config
// is part of platform:base:, write it as platform:base: URL
IFeatureReference[] configuredFeaturesRef = configurationPolicy.getConfiguredFeatures();
for (int j = 0; j < configuredFeaturesRef.length; j++) {
IFeature feature = null;
try {
feature = configuredFeaturesRef[j].getFeature(null);
} catch (CoreException e) {
UpdateCore.warn(null, e);
}
saveFeatureEntry(cSite, feature, runtimeConfiguration);
}
}
// [19958] remove any extra site entries from runtime configuration
// (site entries that no longer exist in this configuration)
if (tempConfig != null) {
IPlatformConfiguration.ISiteEntry[] tmpSites = tempConfig.getConfiguredSites();
for (int i = 0; i < tmpSites.length; i++) {
runtimeConfiguration.unconfigureSite(tmpSites[i]);
}
}
try {
runtimeConfiguration.save();
// log configuration and activities
this.date = new Date(runtimeConfiguration.getChangeStamp());
if ("file".equalsIgnoreCase(getURL().getProtocol())) //$NON-NLS-1$
UpdateCore.log(this);
resetActivities();
return isRestartNeeded(runtimeConfiguration);
} catch (IOException e) {
CoreException exc = Utilities.newCoreException(NLS.bind(Messages.InstallConfiguration_UnableToSavePlatformConfiguration, (new String[] { runtimeConfiguration.getConfigurationLocation().toExternalForm() })), e);
UpdateCore.warn("",exc); //$NON-NLS-1$
}
return true;
}
/*
* Write the plugin path for each site
* Do not check if the site already existed before [16696].
* Reuse any runtime site objects in platform.cfg (to preserve state) [18520].
*/
private void savePluginPath(ConfiguredSite cSite, IPlatformConfiguration runtimeConfiguration, IPlatformConfiguration tempConfig) // [19958]
throws CoreException {
ConfigurationPolicy configurationPolicy = cSite.getConfigurationPolicy();
// create a ISitePolicy (policy, pluginPath)
// for the site
String[] pluginPath = configurationPolicy.getPluginPath(cSite.getSite());
IPlatformConfiguration.ISitePolicy sitePolicy = runtimeConfiguration.createSitePolicy(configurationPolicy.getPolicy(), pluginPath);
// get the URL of the site that matches the one platform.cfg gave us
URL urlToCheck = null;
try {
urlToCheck = new URL(cSite.getPlatformURLString());
} catch (MalformedURLException e) {
throw Utilities.newCoreException(NLS.bind(Messages.InstallConfiguration_UnableToCreateURL, (new String[] { cSite.getPlatformURLString() })), e);
} catch (ClassCastException e) {
throw Utilities.newCoreException(Messages.InstallConfiguration_UnableToCast, e);
}
// update runtime configuration [18520]
// Note: we must not blindly replace the site entries because they
// contain additional runtime state that needs to be preserved.
IPlatformConfiguration.ISiteEntry siteEntry = runtimeConfiguration.findConfiguredSite(urlToCheck);
if (siteEntry == null)
siteEntry = runtimeConfiguration.createSiteEntry(urlToCheck, sitePolicy);
else {
siteEntry.setSitePolicy(sitePolicy);
((SiteEntry)siteEntry).refreshPlugins();
if (tempConfig != null) // [19958] remove reused entries from list
tempConfig.unconfigureSite(siteEntry);
}
((SiteEntry)siteEntry).setEnabled(cSite.isEnabled());
runtimeConfiguration.configureSite(siteEntry, true /*replace if exists*/);
}
/*
* Save the Feature entry
* The feature can be a primary feature and/or a platform feature
*/
private void saveFeatureEntry(ConfiguredSite cSite, IFeature feature, IPlatformConfiguration runtimeConfiguration) throws CoreException {
if (feature == null)
return;
// get the URL of the plugin that corresponds to the feature (pluginid = featureid)
String id = feature.getVersionedIdentifier().getIdentifier();
IPluginEntry[] entries = feature.getPluginEntries();
URL url = null;
IPluginEntry featurePlugin = null;
for (int k = 0; k < entries.length; k++) {
if (id.equalsIgnoreCase(entries[k].getVersionedIdentifier().getIdentifier())) {
url = getRuntimeConfigurationURL(entries[k], cSite);
featurePlugin = entries[k];
break;
}
}
String pluginVersion = null;
if (featurePlugin != null)
pluginVersion = featurePlugin.getVersionedIdentifier().getVersion().toString();
// Find the site
SiteEntry siteEntry = null;
try {
URL featureUrl = new URL(cSite.getPlatformURLString());
siteEntry = (SiteEntry)runtimeConfiguration.findConfiguredSite(featureUrl);
} catch (MalformedURLException e) {
throw Utilities.newCoreException(NLS.bind(Messages.InstallConfiguration_UnableToCreateURL, (new String[] { cSite.getPlatformURLString() })), e);
} catch (ClassCastException e) {
throw Utilities.newCoreException(Messages.InstallConfiguration_UnableToCast, e);
}
// if the URL doesn't exist throw a CoreException
if (siteEntry == null) {
throw new CoreException(
new Status(IStatus.ERROR, UpdateCore.getPlugin().getBundle().getSymbolicName(),
NLS.bind(Messages.InstallConfiguration_unableToFindSite, (new String[] { cSite.getSite().getURL().toExternalForm(), runtimeConfiguration.getConfigurationLocation().toExternalForm() }))));
}
// write the primary features
if (feature.isPrimary()) {
// get any fragments for the feature plugin
ArrayList list = new ArrayList();
if (url != null)
list.add(url);
if (featurePlugin != null) {
URL[] fragments = getRuntimeFragmentURLs(featurePlugin);
list.addAll(Arrays.asList(fragments));
}
URL[] roots = (URL[]) list.toArray(new URL[0]);
String pluginIdentifier = feature.getPrimaryPluginID();
// save information in runtime platform state
String version = feature.getVersionedIdentifier().getVersion().toString();
String application = feature.getApplication();
FeatureEntry featureEntry = (FeatureEntry)runtimeConfiguration.createFeatureEntry(id, version, pluginIdentifier, pluginVersion, true, application, roots);
featureEntry.setURL(getFeatureRelativeURL(feature));
siteEntry.addFeatureEntry(featureEntry);
} else {
// write non-primary feature entries
String version = feature.getVersionedIdentifier().getVersion().toString();
String pluginIdentifier = feature.getPrimaryPluginID();
FeatureEntry featureEntry = (FeatureEntry)runtimeConfiguration.createFeatureEntry(id, version, pluginIdentifier, pluginVersion, false, null, null);
featureEntry.setURL(getFeatureRelativeURL(feature));
siteEntry.addFeatureEntry(featureEntry);
}
// write the platform features (features that contain special platform plugins)
IPluginEntry[] platformPlugins = getPlatformPlugins(feature, runtimeConfiguration);
for (int k = 0; k < platformPlugins.length; k++) {
id = platformPlugins[k].getVersionedIdentifier().getIdentifier();
url = getRuntimeConfigurationURL(platformPlugins[k], cSite);
if (url != null) {
runtimeConfiguration.setBootstrapPluginLocation(id, url);
}
}
}
/*
* Log if we are about to create a site that didn't exist before
* in platform.cfg [16696].
*/
private void checkSites(ConfiguredSiteModel[] configurationSites, IPlatformConfiguration runtimeConfiguration) throws CoreException {
// check all the sites we are about to write already existed
// they should have existed either because they were created by
// updateManager or because we read them from platform.cfg
for (int i = 0; i < configurationSites.length; i++) {
// get the URL of the site that matches the one platform.cfg gave us
URL urlToCheck = null;
try {
urlToCheck = new URL(configurationSites[i].getPlatformURLString());
} catch (MalformedURLException e) {
UpdateCore.warn(NLS.bind(Messages.InstallConfiguration_UnableToCreateURL, (new String[] { configurationSites[i].getPlatformURLString() })), e);
} catch (ClassCastException e) {
UpdateCore.warn(Messages.InstallConfiguration_UnableToCast, e);
}
// if the URL doesn't exits log it
IPlatformConfiguration.ISiteEntry siteEntry = runtimeConfiguration.findConfiguredSite(urlToCheck);
if (siteEntry == null) {
UpdateCore.warn(NLS.bind(Messages.InstallConfiguration_unableToFindSite, (new String[] { urlToCheck.toExternalForm(), runtimeConfiguration.getConfigurationLocation().toExternalForm() })));
}
}
}
/*
* reverts this configuration to the match the new one
*
* Compare the oldSites with the currentOne. the old state is the state we want to revert to.
*
* If a site was in old state, but not in the currentOne, keep it in the hash.
* If a site is in the currentOne but was not in the old state, unconfigure all features and add it in the hash
* If a site was in baoth state, calculate the 'delta' and re-set it in the hash map
*
* At the end, set the configured site from the new sites hash map
*
*/
public void revertTo(IInstallConfiguration configuration, IProgressMonitor monitor, IProblemHandler handler) throws CoreException, InterruptedException {
IConfiguredSite[] oldConfigSites = configuration.getConfiguredSites();
IConfiguredSite[] nowConfigSites = this.getConfiguredSites();
// create a hashtable of the *old* and *new* sites
Map oldSitesMap = new Hashtable(0);
Map newSitesMap = new Hashtable(0);
for (int i = 0; i < oldConfigSites.length; i++) {
IConfiguredSite element = oldConfigSites[i];
oldSitesMap.put(element.getSite().getURL().toExternalForm(), element);
newSitesMap.put(element.getSite().getURL().toExternalForm(), element);
}
// create list of all the sites that map the *old* sites
// we want the intersection between the old sites and the current sites
if (nowConfigSites != null) {
String key = null;
for (int i = 0; i < nowConfigSites.length; i++) {
key = nowConfigSites[i].getSite().getURL().toExternalForm();
IConfiguredSite oldSite = (IConfiguredSite) oldSitesMap.get(key);
if (oldSite != null) {
// the Site existed before, calculate the delta between its current state and the
// state we are reverting to and put it back into the map
((ConfiguredSite) nowConfigSites[i]).revertTo(oldSite, monitor, handler);
} else {
// the site didn't exist in the InstallConfiguration we are reverting to
// unconfigure everything from this site so it is still present
ISiteFeatureReference[] featuresToUnconfigure = nowConfigSites[i].getSite().getFeatureReferences();
for (int j = 0; j < featuresToUnconfigure.length; j++) {
IFeature featureToUnconfigure = null;
try {
featureToUnconfigure = featuresToUnconfigure[j].getFeature(null);
} catch (CoreException e) {
UpdateCore.warn(null, e);
}
if (featureToUnconfigure != null)
nowConfigSites[i].unconfigure(featureToUnconfigure);
}
}
newSitesMap.put(key,nowConfigSites[i]);
}
// the new configuration has the exact same sites as the old configuration
// the old configuration in the Map are either as-is because they don't exist
// in the current one, or they are the delta from the current one to the old one
Collection sites = newSitesMap.values();
if (sites != null && !sites.isEmpty()) {
ConfiguredSiteModel[] sitesModel = new ConfiguredSiteModel[sites.size()];
sites.toArray(sitesModel);
setConfigurationSiteModel(sitesModel);
}
}
}
/*
* @see IInstallConfiguration#getActivities()
*/
public IActivity[] getActivities() {
if (getActivityModel().length == 0)
return new IActivity[0];
return (IActivity[]) getActivityModel();
}
/*
* returns the list of platform plugins of the feature or an empty list
* if the feature doesn't contain any platform plugins
*/
private IPluginEntry[] getPlatformPlugins(IFeature feature, IPlatformConfiguration runtimeConfiguration) {
Map featurePlatformPlugins = new HashMap();
String[] platformPluginID = runtimeConfiguration.getBootstrapPluginIdentifiers();
IPluginEntry[] featurePlugins = feature.getPluginEntries();
for (int i = 0; i < platformPluginID.length; i++) {
String featurePluginId = null;
for (int j = 0; j < featurePlugins.length; j++) {
featurePluginId = featurePlugins[j].getVersionedIdentifier().getIdentifier();
if (platformPluginID[i].equals(featurePluginId)) {
featurePlatformPlugins.put(platformPluginID[i], featurePlugins[j]);
}
}
}
Collection values = featurePlatformPlugins.values();
if (values == null || values.size() == 0)
return new IPluginEntry[0];
IPluginEntry[] result = new IPluginEntry[values.size()];
Iterator iter = values.iterator();
int index = 0;
while (iter.hasNext()) {
result[index] = ((IPluginEntry) iter.next());
index++;
}
return result;
}
/*
* returns the URL of the pluginEntry on the site
* Transform the URL to use platform: protocol if needed
* return null if the URL to write is not valid
*/
private URL getRuntimeConfigurationURL(IPluginEntry entry, ConfiguredSite cSite) throws CoreException {
String rootString = cSite.getPlatformURLString();
String pluginPathID = getPathID(entry);
try {
ISiteContentProvider siteContentProvider = cSite.getSite().getSiteContentProvider();
URL pluginEntryfullURL = siteContentProvider.getArchiveReference(pluginPathID);
//
if (!rootString.startsWith("platform")) { //$NON-NLS-1$
// DEBUG:
if (UpdateCore.DEBUG && UpdateCore.DEBUG_SHOW_CONFIGURATION)
UpdateCore.debug("getRuntimeConfiguration Plugin Entry Full URL:" + pluginEntryfullURL + " Platform String:" + rootString + " [NON PLATFORM URL]."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
return pluginEntryfullURL;
}
//URL pluginEntryRootURL = Platform.resolve(new URL(rootString));
// Do not resolve [16507], just use platform:base/ as a root
// rootString = platform:base
// pluginRoot = /home/a
// pluginFull = /home/a/c/boot.jar
// relative = platform:/base/c/boot.jar
URL pluginEntryRootURL = cSite.getSite().getURL();
String relativeString = UpdateManagerUtils.getURLAsString(pluginEntryRootURL, pluginEntryfullURL);
URL result = new URL(new URL(rootString), relativeString);
// DEBUG:
if (UpdateCore.DEBUG && UpdateCore.DEBUG_SHOW_CONFIGURATION)
UpdateCore.debug("getRuntimeConfiguration plugin Entry Full URL:" + pluginEntryfullURL + " Platform String:" + rootString + " Site URL:" + pluginEntryRootURL + " Relative:" + relativeString); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
// verify we are about to write a valid file URL
// check with fullURL as it is not resolved to platform:base/
if (pluginEntryfullURL != null) {
if ("file".equals(pluginEntryfullURL.getProtocol())) { //$NON-NLS-1$
String fileString = pluginEntryfullURL.getFile();
if (!new File(fileString).exists()) {
UpdateCore.warn("The URL:" + result + " doesn't point to a valid platform plugin.The URL will not be written in the platform configuration", new Exception()); //$NON-NLS-1$ //$NON-NLS-2$
return null;
}
}
}
return result;
} catch (IOException e) {
throw Utilities.newCoreException(NLS.bind(Messages.InstallConfiguration_UnableToCreateURL, (new String[] { rootString })), e);
}
}
/*
* Return URLs for any fragments that are associated with the specified plugin entry
*/
private URL[] getRuntimeFragmentURLs(IPluginEntry entry) throws CoreException {
// get the identifier associated with the entry
VersionedIdentifier vid = entry.getVersionedIdentifier();
// get the plugin descriptor from the registry
Bundle bundle = Platform.getBundle(vid.getIdentifier());
ArrayList list = new ArrayList();
if (bundle != null && bundle.getState() != Bundle.UNINSTALLED && bundle.getState() != Bundle.INSTALLED) {
FragmentEntry[] fragments = UpdateManagerUtils.getFragments(bundle);
for (int i = 0; fragments != null && i < fragments.length; i++) {
String location = fragments[i].getLocation();
try {
URL locationURL = new URL(location);
locationURL = FileLocator.toFileURL(FileLocator.resolve(locationURL));
list.add(asInstallRelativeURL(locationURL));
} catch (IOException e) {
// skip bad fragments
}
}
}
return (URL[]) list.toArray(new URL[0]);
}
/**
* Returns the path identifier for a plugin entry.
* <code>plugins/<pluginId>_<pluginVersion>.jar</code>
* @return the path identifier
*/
private String getPathID(IPluginEntry entry) {
return Site.DEFAULT_PLUGIN_PATH + entry.getVersionedIdentifier().toString() + FeatureContentProvider.JAR_EXTENSION;
}
/**
* Try to recast URL as platform:/base/
*/
private URL asInstallRelativeURL(URL url) {
// get location of install
URL install = ConfiguratorUtils.getInstallURL();
// try to determine if supplied URL can be recast as install-relative
if (install.getProtocol().equals(url.getProtocol())) {
if (install.getProtocol().equals("file")) { //$NON-NLS-1$
String installS = new File(install.getFile()).getAbsolutePath().replace(File.separatorChar, '/');
if (!installS.endsWith("/")) //$NON-NLS-1$
installS += "/"; //$NON-NLS-1$
String urlS = new File(url.getFile()).getAbsolutePath().replace(File.separatorChar, '/');
if (!urlS.endsWith("/")) //$NON-NLS-1$
urlS += "/"; //$NON-NLS-1$
int ix = installS.lastIndexOf("/"); //$NON-NLS-1$
if (ix != -1) {
installS = installS.substring(0, ix + 1);
if (urlS.startsWith(installS)) {
try {
return new URL("platform:/base/" + urlS.substring(installS.length())); //$NON-NLS-1$
} catch (MalformedURLException e) {
}
}
}
}
}
return url;
}
private boolean isDuplicateSite(File siteDirectory) {
IConfiguredSite[] sites = getConfiguredSites();
URL fileURL;
try {
fileURL = siteDirectory.toURL();
} catch (MalformedURLException e) {
return false;
}
for (int i = 0; i < sites.length; i++) {
URL url = sites[i].getSite().getURL();
if (UpdateManagerUtils.sameURL(fileURL, url))
return true;
}
return false;
}
/*
* Returns the feature url relative to the site.
*/
private String getFeatureRelativeURL(IFeature feature) {
String url = feature.getURL().toExternalForm();
String siteURL = feature.getSite().getURL().toExternalForm();
// TODO fix this. toURL() returns file:/d:/eclipse/etc... wheareas the
// platform.asLocalURL() returns file:d:/eclipse/etc... (no leading / )
// if (url.startsWith("file:/") && Platform.getOS().equals("win32"))
// url = "file:" + url.substring(6);
if (url.startsWith(siteURL))
return url.substring(siteURL.length());
else
return url;
}
/**
* @return true if restart is needed
*/
private boolean isRestartNeeded(IPlatformConfiguration runtimeConfig) {
// First, create a map for faster lookups
Set newPluginsSet = null;
if (runtimeConfig instanceof PlatformConfiguration) {
newPluginsSet = ((PlatformConfiguration)runtimeConfig).getPluginPaths();
// On windows, we will be doing case insensitive search as well, so lower it now
if (isWindows) {
String[] newPluginsSetArray = (String[])newPluginsSet.toArray( new String[newPluginsSet.size()]);
for (int i = 0; i < newPluginsSetArray.length; i++) {
newPluginsSet.add(newPluginsSetArray[i].toLowerCase());
}
}
} else {
URL[] newBundlePaths = runtimeConfig.getPluginPath();
newPluginsSet = new HashSet(newBundlePaths.length);
for (int i=0; i<newBundlePaths.length; i++) {
String pluginLocation = newBundlePaths[i].getFile();
newPluginsSet.add(pluginLocation);
// On windows, we will be doing case insensitive search as well, so lower it now
if (isWindows)
newPluginsSet.add(pluginLocation.toLowerCase());
}
}
Bundle[] oldBundles = UpdateCore.getPlugin().getBundleContext().getBundles();
int offset = ConfigurationActivator.UPDATE_PREFIX.length();
for (int i=0; i<oldBundles.length; i++) {
if (oldBundles[i].getBundleId() == 0)
continue; // skip the system bundle
String oldBundleLocation = oldBundles[i].getLocation();
// Don't worry about bundles we did not install
if (!oldBundleLocation.startsWith(ConfigurationActivator.UPDATE_PREFIX))
continue;
oldBundleLocation = oldBundleLocation.substring(offset);
if (newPluginsSet.contains(oldBundleLocation))
continue;
if (isWindows && newPluginsSet.contains(oldBundleLocation.toLowerCase()))
continue;
if (UpdateCore.DEBUG && UpdateCore.DEBUG_SHOW_CONFIGURATION)
UpdateCore.debug("Bundle " + oldBundleLocation + " has been removed"); //$NON-NLS-1$ //$NON-NLS-2$
return true;
}
if (runtimeConfig instanceof PlatformConfiguration) {
return areThereNewVersionOfOldPlugins( ((PlatformConfiguration)runtimeConfig).getPlugins(), oldBundles);
}
return false;
}
/**
* The method should only be called if all old plug-ins exist in the new
* configuration. Determines if a new version was added to any plugin ID, so
* more versions are enabled for any given plug-in id then in old
* configuration.
*
* @param newConfigurationPlugins
* @param oldConfigurationBundles
* @return
*/
private boolean areThereNewVersionOfOldPlugins(PluginEntry[] newConfigurationPlugins, Bundle[] oldConfigurationBundles) {
for ( int i = 0; i < oldConfigurationBundles.length; i++) {
if (oldConfigurationBundles[i].getBundleId() == 0)
continue; // skip the system bundle
if ( getNumberOfPlugins(oldConfigurationBundles[i].getSymbolicName(), oldConfigurationBundles) != getNumberOfPlugins(oldConfigurationBundles[i].getSymbolicName(), newConfigurationPlugins)) {
return true;
}
}
return false;
}
private int getNumberOfPlugins(String symbolicName, PluginEntry[] newConfigurationPlugins) {
int numberOfPlugins = 0;
for ( int i = 0; i < newConfigurationPlugins.length; i++) {
if ( symbolicName.equals(newConfigurationPlugins[i].getPluginIdentifier())) {
numberOfPlugins++;
}
}
return numberOfPlugins;
}
private int getNumberOfPlugins(String symbolicName, Bundle[] oldConfigurationBundles) {
int numberOfPlugins = 0;
for ( int i = 0; i < oldConfigurationBundles.length; i++) {
if ( symbolicName.equals(oldConfigurationBundles[i].getSymbolicName())) {
numberOfPlugins++;
}
}
return numberOfPlugins;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!(obj instanceof InstallConfiguration))
return false;
InstallConfiguration config = (InstallConfiguration)obj;
return getCreationDate().equals(config.getCreationDate()) &&
getLabel().equals(config.getLabel()) &&
getLocationURLString().equals(config.getLocationURLString());
}
}