*** empty log message ***
diff --git a/update/org.eclipse.update.configurator/.classpath b/update/org.eclipse.update.configurator/.classpath
new file mode 100644
index 0000000..065ac06
--- /dev/null
+++ b/update/org.eclipse.update.configurator/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/update/org.eclipse.update.configurator/.cvsignore b/update/org.eclipse.update.configurator/.cvsignore
new file mode 100644
index 0000000..c5e82d7
--- /dev/null
+++ b/update/org.eclipse.update.configurator/.cvsignore
@@ -0,0 +1 @@
+bin
\ No newline at end of file
diff --git a/update/org.eclipse.update.configurator/.options b/update/org.eclipse.update.configurator/.options
new file mode 100644
index 0000000..403dd4a
--- /dev/null
+++ b/update/org.eclipse.update.configurator/.options
@@ -0,0 +1,8 @@
+# Debugging options for the org.eclipse.update.configurator plugin
+
+# Turn on general debugging for the plugin.
+org.eclipse.update.configurator/debug=false
+
+# Turns on debug for the plugin converter.
+org.eclipse.update.configurator/converter/debug=false
+
diff --git a/update/org.eclipse.update.configurator/.project b/update/org.eclipse.update.configurator/.project
new file mode 100644
index 0000000..d860656
--- /dev/null
+++ b/update/org.eclipse.update.configurator/.project
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.update.configurator</name>
+ <comment></comment>
+ <projects>
+ <project>org.eclipse.core.boot</project>
+ <project>org.eclipse.core.runtime</project>
+ <project>org.eclipse.core.runtime.osgi</project>
+ <project>org.eclipse.osgi</project>
+ <project>org.eclipse.osgi.util</project>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/update/org.eclipse.update.configurator/META-INF/MANIFEST.MF b/update/org.eclipse.update.configurator/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..1a3bc9b
--- /dev/null
+++ b/update/org.eclipse.update.configurator/META-INF/MANIFEST.MF
@@ -0,0 +1,24 @@
+Bundle-Name: org.eclipse.update.configurator
+Bundle-GlobalName: org.eclipse.update.configurator
+Bundle-Description: Eclipse Update Configurator
+Bundle-Copyright: Open Source Materials - Eclipse
+Bundle-Version: 3.0.0
+Bundle-DocUrl: http://www.eclipse.org
+Build-Information: ${build-information}
+Bundle-Activator:
+ org.eclipse.update.configurator.ConfigurationActivator
+Bundle-ClassPath:
+ configurator.jar
+Import-Package:
+ org.osgi.framework,
+ org.osgi.util.tracker,
+ org.osgi.service.startlevel,
+ org.osgi.service.packageadmin,
+ org.eclipse.osgi.service.environment
+Export-Package:
+ org.eclipse.update.configurator
+Provide-Package:
+ org.eclipse.update.configurator
+Require-Bundle:
+ org.eclipse.core.runtime.osgi,
+ org.apache.xerces;optional=true
diff --git a/update/org.eclipse.update.configurator/build.properties b/update/org.eclipse.update.configurator/build.properties
new file mode 100644
index 0000000..26fc617
--- /dev/null
+++ b/update/org.eclipse.update.configurator/build.properties
@@ -0,0 +1,6 @@
+bin.includes = .options,\
+ plugin.properties,\
+ plugin.xml,\
+ configurator.jar,\
+ META-INF/
+source.configurator.jar = src/
diff --git a/update/org.eclipse.update.configurator/plugin.properties b/update/org.eclipse.update.configurator/plugin.properties
new file mode 100644
index 0000000..22d0828
--- /dev/null
+++ b/update/org.eclipse.update.configurator/plugin.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+#
+# Contributors:
+# IBM Corporation - initial API and implementation
+###############################################################################
+pluginName= Install/Update Core
+providerName= Eclipse.org
+fragmentNameWin= Install/Update Core for Windows
+fragmentNameLinux= Install/Update Core for Linux
+
+
diff --git a/update/org.eclipse.update.configurator/plugin.xml b/update/org.eclipse.update.configurator/plugin.xml
new file mode 100644
index 0000000..fbeb811
--- /dev/null
+++ b/update/org.eclipse.update.configurator/plugin.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin
+ name="%pluginName"
+ id="org.eclipse.update.configurator"
+ version="3.0.0"
+ provider-name="%providerName">
+
+ <runtime>
+ <library name="configurator.jar">
+ <export name="*"/>
+ </library>
+ </runtime>
+
+ <requires>
+ <import plugin="org.eclipse.osgi"/>
+ <import plugin="org.eclipse.osgi.util"/>
+ <import plugin="org.eclipse.core.runtime.osgi"/>
+ </requires>
+</plugin>
\ No newline at end of file
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/ConfigurationActivator.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/ConfigurationActivator.java
new file mode 100644
index 0000000..8c620c6
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/ConfigurationActivator.java
@@ -0,0 +1,368 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.*;
+import org.eclipse.core.runtime.*;
+import org.eclipse.osgi.service.environment.DebugOptions;
+import org.eclipse.osgi.service.environment.EnvironmentInfo;
+import org.osgi.framework.*;
+import org.osgi.service.packageadmin.PackageAdmin;
+import org.osgi.service.startlevel.StartLevel;
+import org.osgi.util.tracker.ServiceTracker;
+
+public class ConfigurationActivator implements BundleActivator {
+ private final static String DEFAULT_CONVERTER = "org.eclipse.update.configurator.migration.PluginConverter"; //$NON-NLS-1$
+ public static String PI_CONFIGURATOR = "org.eclipse.update.configurator";
+ // debug options
+ public static String OPTION_DEBUG = PI_CONFIGURATOR + "/debug";
+ public static String OPTION_DEBUG_CONVERTER = PI_CONFIGURATOR + "/converter/debug";
+ // debug values
+ public static boolean DEBUG = false;
+ public static boolean DEBUG_CONVERTER = false;
+
+ private static BundleContext context;
+ private ServiceTracker platformTracker;
+ private ServiceRegistration configurationFactorySR;
+ private String[] allArgs;
+
+ // location used to put the generated manfests
+ private String cacheLocation = (String) System.getProperties().get("osgi.manifest.cache"); //PASCAL Need to set this value somewhere (probably from boot)
+ private IPluginConverter converter;
+ private Set ignore;
+ private BundleListener reconcilerListener;
+ private IPlatform platform;
+ private PlatformConfiguration configuration;
+
+ public void start(BundleContext ctx) throws Exception {
+ context = ctx;
+ obtainArgs();
+ initialize();
+ //Short cut, if the configuration has not changed
+ String application = configuration.getApplicationIdentifier();
+
+ //TODO Hack until PDE changes the default application that they are setting
+ if("org.eclipse.ui.workbench".equals(System.getProperties().get("eclipse.application"))) { //$NON-NLS-1$ //$NON-NLS-2$
+ System.setProperty("eclipse.application", "org.eclipse.ui.ide.workbench"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if (!(application.equals(PlatformConfiguration.RECONCILER_APP) || System.getProperties().get("osgi.dev") != null))
+ if (System.getProperty("eclipse.application") == null) {
+ System.setProperty("eclipse.application", application);
+ return;
+ }
+ loadOptions();
+ if (DEBUG)
+ System.out.println("Starting update configurator...");
+ computeIgnoredBundles();
+ loadConverter();
+ installBundles();
+ }
+
+ private void initialize() {
+ platform = acquirePlatform();
+ String metaPath = platform.getLocation().append(".metadata").toOSString();
+ URL installURL = platform.getInstallURL();
+ configurationFactorySR = context.registerService(IPlatformConfigurationFactory.class.getName(), new PlatformConfigurationFactory(), null);
+ configuration = getPlatformConfiguration(allArgs, metaPath, installURL);
+ }
+
+ private void computeIgnoredBundles() {
+ String ignoreList = System.getProperty("eclipse.ignore", "org.eclipse.osgi,org.eclipse.core.boot,org.eclipse.core.runtime.adaptor");
+ ignore = new HashSet();
+ StringTokenizer tokenizer = new StringTokenizer(ignoreList, ",");
+ while (tokenizer.hasMoreTokens())
+ ignore.add(tokenizer.nextToken().trim());
+ }
+ private boolean shouldIgnore(String bundleName) {
+ if (ignore == null)
+ return false;
+ StringTokenizer tokenizer = new StringTokenizer(bundleName, "._");
+ String partialName = "";
+ while (tokenizer.hasMoreTokens()) {
+ partialName += tokenizer.nextToken();
+ if (ignore.contains(partialName))
+ return true;
+ partialName += ".";
+ }
+ return false;
+ }
+ private void loadConverter() {
+ // TODO look at making this an extension
+ String converterClassName = System.getProperty("eclipse.manifestconverter", DEFAULT_CONVERTER);
+ if (converterClassName == null)
+ return;
+ Class converterClass;
+ try {
+ converterClass = Class.forName(converterClassName);
+ } catch (ClassNotFoundException e) {
+ return;
+ }
+ try {
+ converter = (IPluginConverter) converterClass.newInstance();
+ } catch (InstantiationException e1) {
+ return;
+ } catch (IllegalAccessException e1) {
+ return;
+ } catch (ClassCastException cce) {
+ return;
+ }
+ }
+ private void obtainArgs() {
+ // all this is only to get the application args
+ EnvironmentInfo envInfo = null;
+ ServiceReference envInfoSR = context.getServiceReference(EnvironmentInfo.class.getName());
+ if (envInfoSR != null)
+ envInfo = (EnvironmentInfo) context.getService(envInfoSR);
+ if (envInfo == null)
+ throw new IllegalStateException();
+ this.allArgs = envInfo.getAllArgs();
+ // we have what we want - release the service
+ context.ungetService(envInfoSR);
+ }
+
+ public void stop(BundleContext ctx) throws Exception {
+ releasePlatform();
+ configurationFactorySR.unregister();
+ }
+
+ private void releasePlatform() {
+ if (platformTracker == null)
+ return;
+ platformTracker.close();
+ platformTracker = null;
+ }
+ private IPlatform acquirePlatform() {
+ if (platformTracker == null) {
+ platformTracker = new ServiceTracker(context, IPlatform.class.getName(), null);
+ platformTracker.open();
+ }
+ IPlatform result = (IPlatform) platformTracker.getService();
+ while (result == null) {
+ try {
+ platformTracker.waitForService(1000);
+ result = (IPlatform) platformTracker.getService();
+ } catch (InterruptedException ie) {
+ }
+ }
+ return result;
+ }
+
+ private void installBundles() {
+ String metaPath = platform.getLocation().append(".metadata").toOSString();
+ URL installURL = platform.getInstallURL();
+ ServiceReference reference = context.getServiceReference(StartLevel.class.getName());
+ StartLevel start = null;
+ if (reference != null)
+ start = (StartLevel) context.getService(reference);
+ try {
+ URL[] plugins = configuration.getPluginPath();
+ ArrayList installed = new ArrayList(plugins.length);
+ for (int i = 0; i < plugins.length; i++) {
+ String location = plugins[i].toExternalForm();
+ try {
+ checkOrGenerateManifest(location);
+ location = "reference:" + location.substring(0, location.lastIndexOf('/'));
+ if (!isInstalled(location)) {
+ Bundle target = context.installBundle(location);
+ installed.add(target);
+ if (start != null)
+ start.setBundleStartLevel(target, 4);
+ }
+ } catch (Exception e) {
+ System.err.println("Ignoring bundle at: " + location);
+ System.err.println(e.getMessage());
+ }
+ }
+ context.ungetService(reference);
+ refreshPackages((Bundle[]) installed.toArray(new Bundle[installed.size()]));
+ if (System.getProperty("eclipse.application") == null || System.getProperty("eclipse.application").equals(PlatformConfiguration.RECONCILER_APP))
+ System.setProperty("eclipse.application", configuration.getApplicationIdentifier());
+ // if (config.getApplicationIdentifier().equals(PlatformConfiguration.RECONCILER_APP) ) {
+ // reconcilerListener = reconcilerListener();
+ // context.addBundleListener(reconcilerListener);
+ // }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } finally {
+ releasePlatform();
+ }
+ }
+
+ private BundleListener reconcilerListener() {
+ return new BundleListener() {
+ public void bundleChanged(BundleEvent event) {
+ String buid = event.getBundle().getGlobalName();
+ if (event.getType() == BundleEvent.STOPPED && buid != null && buid.equals("org.eclipse.update.core"))
+ runPostReconciler();
+ }
+ };
+ }
+
+ private void runPostReconciler() {
+ Runnable postReconciler = new Runnable() {
+ public void run() {
+ try {
+ Bundle apprunner = context.getBundle("org.eclipse.core.applicationrunner");
+ apprunner.stop();
+ context.removeBundleListener(reconcilerListener);
+ try {
+ PlatformConfiguration.shutdown();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ installBundles();
+ apprunner.start();
+ } catch (BundleException be) {
+ be.printStackTrace();
+ }
+ }
+ };
+ new Thread(postReconciler, "Post reconciler").start();
+ }
+ /**
+ * @param location
+ */
+ private void checkOrGenerateManifest(String pluginManifestLocationURL) {
+ if (converter == null)
+ return;
+ String pluginManifestLocation = null;
+ try {
+ pluginManifestLocation = new URL(pluginManifestLocationURL).getPath();
+ } catch (MalformedURLException e) {
+ return;
+ }
+ File pluginDir = new File(pluginManifestLocation).getParentFile();
+ if (shouldIgnore(pluginDir.getName()))
+ return;
+ File manifest = new File(pluginDir, "META-INF/MANIFEST.MF");
+ if (manifest.exists())
+ return;
+ // bail if the install location is not writable and we don't know where else to write to
+ if (cacheLocation == null)
+ return;
+ File generationLocation = new File(cacheLocation, computeFileName(pluginDir.getPath()) + ".MF");
+ if (generationLocation.exists())
+ return;
+ if (!converter.convertManifest(pluginDir, generationLocation))
+ System.out.println(pluginDir + " manifest generation failed");
+ }
+ /*
+ * Derives a file name corresponding to a path:
+ * c:\autoexec.bat -> c__autoexec.bat
+ */
+ private String computeFileName(String filePath) {
+ StringBuffer newName = new StringBuffer(filePath);
+ for (int i = 0; i < filePath.length(); i++) {
+ char c = newName.charAt(i);
+ if (c == ':' || c == '/' || c == '\\')
+ newName.setCharAt(i, '_');
+ }
+ return newName.toString();
+ }
+ /**
+ * This is a major hack to try to get the reconciler application running. However we should find a way to not run it.
+ * @param args
+ * @param metaPath
+ * @return
+ */
+ private PlatformConfiguration getPlatformConfiguration(String[] args, String metaPath, URL installURL) {
+ try {
+ PlatformConfiguration.startup(args, null, null, metaPath, installURL);
+ } catch (Exception e) {
+ if (platformTracker != null) {
+ String message = e.getMessage();
+ if (message == null)
+ message = "";
+ IStatus status = new Status(IStatus.ERROR, IPlatform.PI_RUNTIME, IStatus.OK, message, e);
+ ((IPlatform) platformTracker.getService()).getLog(context.getBundle()).log(status);
+ }
+ }
+ return PlatformConfiguration.getCurrent();
+
+ }
+
+ /**
+ * Do PackageAdmin.refreshPackages() in a synchronous way. After installing
+ * all the requested bundles we need to do a refresh and want to ensure that
+ * everything is done before returning.
+ * @param bundles
+ */
+ private void refreshPackages(Bundle[] bundles) {
+ if (bundles.length == 0)
+ return;
+ ServiceReference packageAdminRef = context.getServiceReference(PackageAdmin.class.getName());
+ PackageAdmin packageAdmin = null;
+ if (packageAdminRef != null) {
+ packageAdmin = (PackageAdmin) context.getService(packageAdminRef);
+ if (packageAdmin == null)
+ return;
+ }
+ // TODO this is such a hack it is silly. There are still cases for race conditions etc
+ // but this should allow for some progress...
+ final Object semaphore = new Object();
+ FrameworkListener listener = new FrameworkListener() {
+ public void frameworkEvent(FrameworkEvent event) {
+ if (event.getType() == FrameworkEvent.PACKAGES_REFRESHED)
+ synchronized (semaphore) {
+ semaphore.notifyAll();
+ }
+ }
+ };
+ context.addFrameworkListener(listener);
+ packageAdmin.refreshPackages(bundles);
+ synchronized (semaphore) {
+ try {
+ semaphore.wait();
+ } catch (InterruptedException e) {
+ }
+ }
+ context.removeFrameworkListener(listener);
+ context.ungetService(packageAdminRef);
+ }
+
+ private boolean isInstalled(String location) {
+ Bundle[] installed = context.getBundles();
+ for (int i = 0; i < installed.length; i++) {
+ Bundle bundle = installed[i];
+ if (location.equalsIgnoreCase(bundle.getLocation()))
+ return true;
+ }
+ return false;
+ }
+
+ private void loadOptions() {
+ // all this is only to get the application args
+ DebugOptions service = null;
+ ServiceReference reference = context.getServiceReference(DebugOptions.class.getName());
+ if (reference != null)
+ service = (DebugOptions) context.getService(reference);
+ if (service == null)
+ return;
+ try {
+ DEBUG = service.getBooleanOption(OPTION_DEBUG, false);
+ if (!DEBUG)
+ return;
+ DEBUG_CONVERTER = service.getBooleanOption(OPTION_DEBUG_CONVERTER, false);
+ } finally {
+ // we have what we want - release the service
+ context.ungetService(reference);
+ }
+ }
+ public static BundleContext getBundleContext() {
+ return context;
+ }
+}
\ No newline at end of file
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfiguration.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfiguration.java
new file mode 100644
index 0000000..2c31cbe
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfiguration.java
@@ -0,0 +1,566 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.IOException;
+import java.net.URL;
+
+/**
+ * Platform configuration interface. Represents the runtime
+ * configuration used by the Eclipse platform. Any configuration
+ * changes do not take effect until next startup of the Eclipse
+ * platform
+ *
+ * @since 2.0
+ */
+public interface IPlatformConfiguration {
+
+ /**
+ * Configuration entry representing an install site.
+ *
+ * @since 2.0
+ */
+ public interface ISiteEntry {
+
+ /**
+ * Returns the URL for this site
+ *
+ * @return site url
+ * @since 2.0
+ */
+ public URL getURL();
+
+ /**
+ * Returns the policy for this site
+ *
+ * @return site policy
+ * @since 2.0
+ */
+ public ISitePolicy getSitePolicy();
+
+ /**
+ * Sets the site policy
+ *
+ * @param policy site policy
+ * @since 2.0
+ */
+ public void setSitePolicy(ISitePolicy policy);
+
+ /**
+ * Returns a list of features visible on the site. Note, that this is simply a
+ * reflection of the site content. The features may or may not be actually configured.
+ *
+ * @return an array of feature entries, or an empty array if no features are found.
+ * A feature entry is returned as a path relative to the site URL
+ * @since 2.0
+ */
+ public String[] getFeatures();
+
+ /**
+ * Returns a list of plug-ins visible on the site. Note, that this is simply a
+ * reflection of the site content and the current policy for the site. The plug-ins
+ * may or may not end up being used by Eclipse (depends on which plug-in are
+ * actually bound by the platform).
+ *
+ * @return an array of plug-in entries, or an empty array if no plug-ins are found.
+ * A plug-in entry is returned as a path relative to the site URL *
+ * @since 2.0
+ */
+ public String[] getPlugins();
+
+ /**
+ * Returns a stamp reflecting the current state of the site. If called repeatedly,
+ * returns the same value as long as no changes were made to the site (changes to
+ * features or plugins).
+ *
+ * @return site change stamp
+ * @since 2.0
+ */
+ public long getChangeStamp();
+
+ /**
+ * Returns a stamp reflecting the current state of the features on the site.
+ * If called repeatedly, returns the same value as long as no changes were made to
+ * features on the site.
+ *
+ * @return site features change stamp
+ * @since 2.0
+ */
+ public long getFeaturesChangeStamp();
+
+ /**
+ * Returns a stamp reflecting the current state of the plug-ins on the site.
+ * If called repeatedly, returns the same value as long as no changes were made to
+ * plug-ins on the site.
+ *
+ * @return site plug-ins change stamp
+ * @since 2.0
+ */
+ public long getPluginsChangeStamp();
+
+ /**
+ * Returns an indication whether the site can be updated.
+ *
+ * @return <code>true</code> if site can be updated, <code>false</code> otherwise
+ * @since 2.0
+ */
+ public boolean isUpdateable();
+
+ /**
+ * Returns an indication whether the site represents an install site
+ * that has been linked via a native installer (using the links/<linkfile>
+ * mechanism)
+ *
+ * @return <code>true</code> if the site is linked, <code>false</code> otherwise
+ * @since 2.0
+ */
+ public boolean isNativelyLinked();
+ }
+
+ /**
+ * Site policy. The site policy object determines how plug-ins
+ * contained on the site are processed during startup. In general,
+ * there are 3 ways of configuring a site policy
+ * <ul>
+ * <li>explicitly specify which plug-ins are to be included at
+ * startup (type==USER_INCLUDE). Any other plug-ins located
+ * at the site are ignored at startup. This is typically the best
+ * policy when using remote sites where the user wishes
+ * to retain explicit control over the plug-ins that are included
+ * from such site.
+ * <li>explicitly specify which plug-ins are to be excluded at
+ * startup (type==USER-EXCLUDE). All other plug-ins located
+ * at the site are used at startup. This policy requires that
+ * the site support an access "protocol" that allows plug-in
+ * discovery. In general, these are sites defined using the "file"
+ * URL protocol. This is typically the best policy for local
+ * install sites (on the user system).
+ * </ul>
+ *
+ * @since 2.0
+ */
+ public interface ISitePolicy {
+
+ /**
+ * Policy type constants.
+ */
+
+ /**
+ * User-defined inclusion list. The list associated with this
+ * policy type is interpreted as path entries to included plugin.xml
+ * or fragment.xml <b>relative</b> to the site URL
+ */
+ public static final int USER_INCLUDE = 0;
+
+ /**
+ * User-defined exclusion list. The list associated with this
+ * policy type is interpreted as path entries to excluded plugin.xml
+ * or fragment.xml <b>relative</b> to the site URL
+ */
+ public static final int USER_EXCLUDE = 1;
+
+ /**
+ * Return policy type
+ *
+ * @return policy type
+ * @since 2.0
+ */
+ public int getType();
+
+ /**
+ * Return policy inclusion/ exclusion list
+ *
+ * @return the list as an array
+ * @since 2.0
+ */
+ public String[] getList();
+
+ /**
+ * Set new policy list. The list entries are interpreted based on the policy
+ * type. See description of the policy type constants for details.
+ *
+ * @param list policy inclusion/ exclusion list as an array.
+ * Returns an empty array if there are no entries.
+ * @see #USER_INCLUDE
+ * @see #USER_EXCLUDE
+ * @since 2.0
+ */
+ public void setList(String[] list);
+ }
+
+ /**
+ * Feature entry.
+ * Represents runtime "hints" about configured features.
+ * The information is used during execution to locate the
+ * correct attribution information for a feature. Note,
+ * that a typical configuration can declare multiple feature
+ * entries. At execution time, only one can be selected as
+ * the active primary feature. This is determined based on
+ * specified command line arguments or computed defaults.
+ *
+ * @since 2.0
+ */
+ public interface IFeatureEntry {
+
+ /**
+ * Returns feature identifier.
+ * @return feature identifier
+ * @since 2.0
+ */
+ public String getFeatureIdentifier();
+
+ /**
+ * Returns the currently configured version for the feature.
+ * @return feature version (as string), or <code>null</code>
+ * @since 2.0
+ */
+ public String getFeatureVersion();
+
+ /**
+ * Returns the identifier of the feature plug-in for this feature entry.
+ * Note, that there is no guarantee that a feature in fact
+ * supplies a corresponding feature plugin, so the result can be
+ * <code>null</code>. Also, if supplied, there is no guarantee that the
+ * plugin will in fact be loaded into the plug-in registry at runtime
+ * (due to rules and constraint checking performed by the registry
+ * loading support). Consequently code making use of this method must
+ * handle these conditions.
+ * @return feature identifier (as string), or <code>null</code>
+ * @since 2.1
+ */
+ public String getFeaturePluginIdentifier();
+
+ /**
+ * Returns the version of the feature plug-in for this feature
+ * entry. Note, that there is no guarantee that a feature in fact
+ * supplies a corresponding feature plugin, so the result can be
+ * <code>null</code>. Also, if supplied, there is no guarantee that the
+ * plugin will in fact be loaded into the plug-in registry at runtime
+ * (due to rules and constraint checking performed by the registry
+ * loading support). Consequently code making use of this method must
+ * handle these conditions.
+ * @return feature version (as string), or <code>null</code>
+ * @since 2.0
+ */
+ public String getFeaturePluginVersion();
+
+ /**
+ * Returns the application to run when this feature is the
+ * primary feature.
+ * @return application identifier, or <code>null</code>
+ * @since 2.0
+ */
+ public String getFeatureApplication();
+
+ /**
+ * Returns URLs to the feature "root" locations. The root
+ * URLs are install locations of the feature plugin and its
+ * fragments.
+ *
+ * @return array of URLs, or an empty array
+ * @since 2.0
+ */
+ public URL[] getFeatureRootURLs();
+
+ /**
+ * Returns an indication whether this feature has been defined
+ * to act as a primary feature.
+ * @return <code>true</code> if the feature can be primary,
+ * <code>false</code> otherwise.
+ * @since 2.0
+ */
+ public boolean canBePrimary();
+ }
+
+ /**
+ * Create a site entry
+ *
+ * @param url site URL
+ * @param policy site policy
+ * @return created site entry
+ * @since 2.0
+ */
+ public ISiteEntry createSiteEntry(URL url, ISitePolicy policy);
+
+ /**
+ * Create a site policy. The policy determines the way the site
+ * plug-in are processed at startpu
+ *
+ * @param type policy type
+ * @param list an array of site-relative paths representing the
+ * inclusion/ exclusion list
+ * @return created site policy entry
+ * @since 2.0
+ */
+ public ISitePolicy createSitePolicy(int type, String[] list);
+
+ /**
+ * Create a feature entry
+ * @param id feature identifier. Must not be <code>null</code>.
+ * @param version feature version (as String). Can be <code>null</code>.
+ * @param pluginVersion version of the feature plugin (as String). Can be
+ * <code>null</code>.
+ * @param primary <code>true</code> if the feature is defined as a primary
+ * feature, otherwise <code>false</code>.
+ * @param application identifier of the application to run when
+ * this feature is the primary feature. Can be <code>null</code>.
+ * If specified, the identifier must represent a valid extension
+ * registered in the <code>org.eclipse.core.runtime.applications</code>
+ * extension point.
+ * @param an array of URLs to feature root directories.
+ * These are URLs to install locations for the feature plugin
+ * and its fragments. Can be <code>null</code>.
+ * @return create feature entry
+ * @since 2.0
+ */
+ public IFeatureEntry createFeatureEntry(String id, String version, String pluginVersion, boolean primary, String application, URL[] root);
+
+ /**
+ * Create a feature entry
+ * @param id feature identifier. Must not be <code>null</code>.
+ * @param version feature version (as String). Can be <code>null</code>.
+ * @param pluginIdentifier identifier of the feature plugin (as String). Can
+ * be <code>null</code>.
+ * @param pluginVersion version of the feature plugin (as String). Can be
+ * <code>null</code>.
+ * @param primary <code>true</code> if the feature is defined as a primary
+ * feature, otherwise <code>false</code>.
+ * @param application identifier of the application to run when
+ * this feature is the primary feature. Can be <code>null</code>.
+ * If specified, the identifier must represent a valid extension
+ * registered in the <code>org.eclipse.core.runtime.applications</code>
+ * extension point.
+ * @param an array of URLs to feature root directories.
+ * These are URLs to install locations for the feature plugin
+ * and its fragments. Can be <code>null</code>.
+ * @return create feature entry
+ * @since 2.1
+ */
+ public IFeatureEntry createFeatureEntry(String id, String version, String pluginIdentifier, String pluginVersion, boolean primary, String application, URL[] root);
+
+ /**
+ * Configures the specified site entry. If a site entry with the
+ * same site URL is already configured, the entry is <b>not</b> replaced.
+ *
+ * @param entry site entry
+ * @since 2.0
+ */
+ public void configureSite(ISiteEntry entry);
+
+ /**
+ * Configures the specified site entry. If a site entry with the
+ * same site URL is already configured, the replacement behavior for
+ * the entry can be specified.
+ *
+ * @param entry site entry
+ * @param flag indicating whether an existing configured entry with
+ * the same URL should be replaced (<code>true</code>) or not (<code>false</code>).
+ * @since 2.0
+ */
+ public void configureSite(ISiteEntry entry, boolean replace);
+
+ /**
+ * Unconfigures the specified entry. Does not do anything if the entry
+ * is not configured.
+ *
+ * @param entry site entry
+ * @since 2.0
+ */
+ public void unconfigureSite(ISiteEntry entry);
+
+ /**
+ * Returns configured site entries
+ *
+ * @return array of site entries. Returns an empty array if no sites are
+ * configured
+ * @since 2.0
+ */
+ public ISiteEntry[] getConfiguredSites();
+
+ /**
+ * Returns a site entry matching the specified URL
+ *
+ * @param url site url
+ * @return matching site entry, or <code>null</code> if no match found
+ * @since 2.0
+ */
+ public ISiteEntry findConfiguredSite(URL url);
+
+ /**
+ * Configures the feature entry.
+ * If another feature entry with the same feature identifier
+ * already exists, it is replaced.
+ * @param entry feature entry
+ * @since 2.0
+ */
+ public void configureFeatureEntry(IFeatureEntry entry);
+
+ /**
+ * Unconfigures the specified feature entry if it exists.
+ * @param entry feature entry
+ * @since 2.0
+ */
+ public void unconfigureFeatureEntry(IFeatureEntry entry);
+
+ /**
+ * Returns a list of configured feature entries.
+ * @return array or entries, or an empty array if no entries
+ * are configured
+ * @since 2.0
+ */
+ public IFeatureEntry[] getConfiguredFeatureEntries();
+
+ /**
+ * Locates the specified feature entry.
+ * @param id feature identifier
+ * @return ferature entry, or <code>null</code>.
+ * @since 2.0
+ */
+ public IFeatureEntry findConfiguredFeatureEntry(String id);
+
+ /**
+ * Returns the URL location of the configuration information
+ *
+ * @return configuration location URL, or <code>null</code> if the
+ * configuration location could not be determined.
+ * @since 2.0
+ */
+ public URL getConfigurationLocation();
+
+ /**
+ * Returns a stamp reflecting the current state of the configuration. If called repeatedly,
+ * returns the same value as long as no changes were made to the configuration (changes to
+ * sites, features or plugins).
+ *
+ * @return configuration change stamp
+ * @since 2.0
+ */
+ public long getChangeStamp();
+
+ /**
+ * Returns a stamp reflecting the current state of the features in the configuration.
+ * If called repeatedly, returns the same value as long as no changes were made to
+ * features in the configuration.
+ *
+ * @return configuration features change stamp
+ * @since 2.0
+ */
+ public long getFeaturesChangeStamp();
+
+ /**
+ * Returns a stamp reflecting the current state of the plug-ins in the configuration.
+ * If called repeatedly, returns the same value as long as no changes were made to
+ * plug-ins in the configuration.
+ *
+ * @return configuration plug-ins change stamp
+ * @since 2.0
+ */
+ public long getPluginsChangeStamp();
+
+ /**
+ * Returns the identifier of the configured primary feature. A primary feature
+ * is used to specify product customization information for a running instance
+ * of Eclipse.
+ *
+ * @return primary feature identifier, or <code>null</code> if none configured
+ * @since 2.0
+ */
+ public String getPrimaryFeatureIdentifier();
+
+ /**
+ * Computes the plug-in path for this configuration. The result includes all plug-ins
+ * visible on each of the configured sites based on each site policy.
+ *
+ * @return an array of plug-in path elements (full URL entries), or an empty array.
+ * @since 2.0
+ */
+ public URL[] getPluginPath();
+
+ /**
+ * Returns an array of bootstrap plugin identifiers whose
+ * location needs to be explicitly identified in the configuration.
+ *
+ * @return an array of identifiers, or empty array
+ * otherwise
+ * @since 2.0
+ */
+ public String[] getBootstrapPluginIdentifiers();
+
+ /**
+ * Sets the location of a bootstrap plugin.
+ *
+ * @see IPlatformConfiguration#getBootstrapPluginIdentifiers()
+ * @param id plugin identifier. Must match one of the entries returned
+ * by getBootstrapPluginIdentifiers()
+ * @param location
+ * @since 2.0
+ */
+ public void setBootstrapPluginLocation(String id, URL location);
+
+ /**
+ * Returns an indication whether the configuration can be updated.
+ *
+ * @return <code>true</code> if configuration can be updated, <code>false</code>
+ * otherwise
+ * @since 2.0
+ */
+ public boolean isUpdateable();
+
+ /**
+ * Returns an indication whether the configuration is transient. A transient
+ * configuration typically represents a scenario where the configuration
+ * was computed for a single instantiation of the platform and is not
+ * guaranteed to be valid on subsequent instantiations.
+ *
+ * @return <code>true</code> if configuration is transient, <code>false</code>
+ * otherwise
+ * @since 2.0
+ */
+ public boolean isTransient();
+
+ /**
+ * Indicates whether the configuration is transient or not. A transient
+ * configuration typically represents a scenario where the configuration
+ * was computed for a single instantiation of the platform and is not
+ * guaranteed to be valid on subsequent instantiations. This method has
+ * no effect if called on the current platform configuration.
+ *
+ * @see BootLoader#getCurrentPlatformConfiguration()
+ * @param value <code>true</code> if configuration is transient, <code>false</code>
+ * otherwise
+ * @since 2.0
+ */
+ public void isTransient(boolean value);
+
+ /**
+ * Called to refresh the configuration information. In particular,
+ * causes change stamps to be recomputed based on the current
+ * configuration state, and updates the lists of available plug-ins.
+ * @since 2.0
+ */
+ public void refresh();
+
+ /**
+ * Called to save the configuration information
+ * @since 2.0
+ */
+ public void save() throws IOException;
+
+ /**
+ * Called to save the configuration information in the
+ * specified location
+ *
+ * @param url save location.
+ * @since 2.0
+ */
+ public void save(URL url) throws IOException;
+
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfigurationFactory.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfigurationFactory.java
new file mode 100644
index 0000000..3fcdebf
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPlatformConfigurationFactory.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.IOException;
+import java.net.URL;
+
+public interface IPlatformConfigurationFactory {
+ /**
+ * Returns the current platform configuration.
+ *
+ * @return platform configuration used in current instance of platform
+ */
+ public IPlatformConfiguration getCurrentPlatformConfiguration();
+ /**
+ * Returns a platform configuration object, optionally initialized with previously saved
+ * configuration information.
+ *
+ * @param url location of previously save configuration information. If <code>null</code>
+ * is specified, an empty configuration object is returned
+ * @return platform configuration used in current instance of platform
+ */
+ public IPlatformConfiguration getPlatformConfiguration(URL url) throws IOException;
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPluginConverter.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPluginConverter.java
new file mode 100644
index 0000000..5652156
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/IPluginConverter.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.File;
+
+public interface IPluginConverter {
+ /**
+ * Converts a plug-in/fragment into a bundle (host/fragment).
+ * @param pluginLocation
+ * @param bundleManifestLocation
+ * @return <code>true</coed>
+ */
+ public boolean convertManifest(File pluginLocation, File bundleManifestLocation);
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfiguration.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfiguration.java
new file mode 100644
index 0000000..534c583
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfiguration.java
@@ -0,0 +1,2929 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import org.eclipse.core.internal.boot.PlatformURLConnection;
+import org.eclipse.core.internal.boot.PlatformURLHandler;
+
+public class PlatformConfiguration implements IPlatformConfiguration {
+
+ private static PlatformConfiguration currentPlatformConfiguration = null;
+
+ private URL configLocation;
+ private URL rootLocation;
+ private HashMap sites;
+ private HashMap externalLinkSites; // used to restore prior link site state
+ private HashMap cfgdFeatures;
+ private HashMap bootPlugins;
+ private String defaultFeature;
+ private long lastChangeStamp;
+ private long changeStamp;
+ private boolean changeStampIsValid = false;
+ private long lastFeaturesChangeStamp;
+ private long featuresChangeStamp;
+ private boolean featuresChangeStampIsValid = false;
+ private long lastPluginsChangeStamp;
+ private long pluginsChangeStamp;
+ private boolean pluginsChangeStampIsValid = false;
+ private boolean featureChangesConfigured = false;
+ private boolean transientConfig = false;
+ private File cfgLockFile;
+ private RandomAccessFile cfgLockFileRAF;
+ private BootDescriptor runtimeDescriptor;
+
+ private static String cmdConfiguration = null;
+ private static String cmdFeature = null;
+ private static String cmdApplication = null;
+ private static URL cmdPlugins = null;
+ private static boolean cmdInitialize = false;
+ private static boolean cmdFirstUse = false;
+ private static boolean cmdUpdate = false;
+ private static boolean cmdNoUpdate = false;
+ private static boolean cmdDev = false;
+
+ static boolean DEBUG = false;
+
+ private static final String BOOT_XML = "boot.xml"; //$NON-NLS-1$
+ private static final String BOOT_PLUGIN_ID = "org.eclipse.core.boot"; //$NON-NLS-1$
+ private static final String RUNTIME_PLUGIN_ID = "org.eclipse.core.runtime"; //$NON-NLS-1$
+
+ private static final String ECLIPSE = "eclipse"; //$NON-NLS-1$
+ private static final String PLUGINS = "plugins"; //$NON-NLS-1$
+ private static final String FEATURES = "features"; //$NON-NLS-1$
+ private static final String CONFIG_DIR = ".config"; //$NON-NLS-1$
+ private static final String CONFIG_FILE = CONFIG_DIR + "/platform.cfg"; //$NON-NLS-1$
+ private static final String CONFIG_FILE_INIT = "install.ini"; //$NON-NLS-1$
+ private static final String CONFIG_FILE_LOCK_SUFFIX = ".lock"; //$NON-NLS-1$
+ private static final String CONFIG_FILE_TEMP_SUFFIX = ".tmp"; //$NON-NLS-1$
+ private static final String CONFIG_FILE_BAK_SUFFIX = ".bak"; //$NON-NLS-1$
+ private static final String CHANGES_MARKER = ".newupdates"; //$NON-NLS-1$
+ private static final String LINKS = "links"; //$NON-NLS-1$
+ private static final String PLUGIN_XML = "plugin.xml"; //$NON-NLS-1$
+ private static final String FRAGMENT_XML = "fragment.xml"; //$NON-NLS-1$
+ private static final String FEATURE_XML = "feature.xml"; //$NON-NLS-1$
+ private static final String PRODUCT_SITE_MARKER = ".eclipseproduct"; //$NON-NLS-1$
+ private static final String PRODUCT_SITE_ID = "id"; //$NON-NLS-1$
+ private static final String PRODUCT_SITE_VERSION = "version"; //$NON-NLS-1$
+
+ private static final String[] BOOTSTRAP_PLUGINS = { "org.eclipse.core.boot" }; //$NON-NLS-1$
+ private static final String CFG_BOOT_PLUGIN = "bootstrap"; //$NON-NLS-1$
+ private static final String CFG_SITE = "site"; //$NON-NLS-1$
+ private static final String CFG_URL = "url"; //$NON-NLS-1$
+ private static final String CFG_POLICY = "policy"; //$NON-NLS-1$
+ private static final String[] CFG_POLICY_TYPE = { "USER-INCLUDE", "USER-EXCLUDE" }; //$NON-NLS-1$ //$NON-NLS-2$
+ private static final String CFG_POLICY_TYPE_UNKNOWN = "UNKNOWN"; //$NON-NLS-1$
+ private static final String CFG_LIST = "list"; //$NON-NLS-1$
+ private static final String CFG_STAMP = "stamp"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_STAMP = "stamp.features"; //$NON-NLS-1$
+ private static final String CFG_PLUGIN_STAMP = "stamp.plugins"; //$NON-NLS-1$
+ private static final String CFG_UPDATEABLE = "updateable"; //$NON-NLS-1$
+ private static final String CFG_LINK_FILE = "linkfile"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY = "feature"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_DEFAULT = "feature.default.id"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_ID = "id"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_PRIMARY = "primary"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_VERSION = "version"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_PLUGIN_VERSION = "plugin-version"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_PLUGIN_IDENTIFIER = "plugin-identifier"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_APPLICATION = "application"; //$NON-NLS-1$
+ private static final String CFG_FEATURE_ENTRY_ROOT = "root"; //$NON-NLS-1$
+
+ private static final String INIT_DEFAULT_FEATURE_ID = "feature.default.id"; //$NON-NLS-1$
+ private static final String INIT_DEFAULT_PLUGIN_ID = "feature.default.plugin.id"; //$NON-NLS-1$
+ private static final String INIT_DEFAULT_FEATURE_APPLICATION = "feature.default.application"; //$NON-NLS-1$
+ private static final String DEFAULT_FEATURE_ID = "org.eclipse.platform"; //$NON-NLS-1$
+ private static final String DEFAULT_FEATURE_APPLICATION = "org.eclipse.ui.workbench"; //$NON-NLS-1$
+
+ private static final String CFG_VERSION = "version"; //$NON-NLS-1$
+ private static final String CFG_TRANSIENT = "transient"; //$NON-NLS-1$
+ private static final String VERSION = "2.1"; //$NON-NLS-1$
+ private static final String EOF = "eof"; //$NON-NLS-1$
+ private static final int CFG_LIST_LENGTH = 10;
+
+ private static final int DEFAULT_POLICY_TYPE = ISitePolicy.USER_EXCLUDE;
+ private static final String[] DEFAULT_POLICY_LIST = new String[0];
+
+ private static final String LINK_PATH = "path"; //$NON-NLS-1$
+ private static final String LINK_READ = "r"; //$NON-NLS-1$
+ private static final String LINK_READ_WRITE = "rw"; //$NON-NLS-1$
+
+ private static final String CMD_CONFIGURATION = "-configuration"; //$NON-NLS-1$
+ private static final String CMD_FEATURE = "-feature"; //$NON-NLS-1$
+ private static final String CMD_APPLICATION = "-application"; //$NON-NLS-1$
+ private static final String CMD_PLUGINS = "-plugins"; //$NON-NLS-1$
+ private static final String CMD_UPDATE = "-update"; //$NON-NLS-1$
+ private static final String CMD_INITIALIZE = "-initialize"; //$NON-NLS-1$
+ private static final String CMD_FIRSTUSE = "-firstuse"; //$NON-NLS-1$
+ private static final String CMD_NO_UPDATE = "-noupdate"; //$NON-NLS-1$
+ private static final String CMD_NEW_UPDATES = "-newUpdates"; //$NON-NLS-1$
+ private static final String CMD_DEV = "-dev"; // triggers -noupdate //$NON-NLS-1$
+
+ protected static final String RECONCILER_APP = "org.eclipse.update.core.reconciler"; //$NON-NLS-1$
+
+ private static final char[] HEX = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+ private static URL installURL;
+
+ public class SiteEntry implements IPlatformConfiguration.ISiteEntry {
+
+ private URL url; // this is the external URL for the site
+ private URL resolvedURL; // this is the resolved URL used internally
+ private ISitePolicy policy;
+ private boolean updateable = true;
+ private ArrayList features;
+ private ArrayList plugins;
+ private PlatformConfiguration parent;
+ private long lastChangeStamp;
+ private long changeStamp;
+ private boolean changeStampIsValid = false;
+ private long lastFeaturesChangeStamp;
+ private long featuresChangeStamp;
+ private boolean featuresChangeStampIsValid = false;
+ private long lastPluginsChangeStamp;
+ private long pluginsChangeStamp;
+ private boolean pluginsChangeStampIsValid = false;
+ private String linkFileName = null;
+
+ private SiteEntry() {
+ }
+ private SiteEntry(URL url, ISitePolicy policy, PlatformConfiguration parent) {
+ if (url == null)
+ throw new IllegalArgumentException();
+
+ if (policy == null)
+ throw new IllegalArgumentException();
+
+ if (parent == null)
+ throw new IllegalArgumentException();
+
+ this.url = url;
+ this.policy = policy;
+ this.parent = parent;
+ this.features = null;
+ this.plugins = null;
+ this.resolvedURL = this.url;
+ if (url.getProtocol().equals(PlatformURLHandler.PROTOCOL)) {
+ try {
+ resolvedURL = resolvePlatformURL(url); // 19536
+ } catch (IOException e) {
+ // will use the baseline URL ...
+ }
+ }
+ }
+
+ /*
+ * @see ISiteEntry#getURL()
+ */
+ public URL getURL() {
+ return url;
+ }
+
+ /*
+ * @see ISiteEntry#getSitePolicy()
+ */
+ public ISitePolicy getSitePolicy() {
+ return policy;
+ }
+
+ /*
+ * @see ISiteEntry#setSitePolicy(ISitePolicy)
+ */
+ public synchronized void setSitePolicy(ISitePolicy policy) {
+ if (policy == null)
+ throw new IllegalArgumentException();
+ this.policy = policy;
+ }
+
+ /*
+ * @see ISiteEntry#getFeatures()
+ */
+ public String[] getFeatures() {
+ return getDetectedFeatures();
+ }
+
+ /*
+ * @see ISiteEntry#getPlugins()
+ */
+ public String[] getPlugins() {
+
+ ISitePolicy policy = getSitePolicy();
+
+ if (policy.getType() == ISitePolicy.USER_INCLUDE)
+ return policy.getList();
+
+ if (policy.getType() == ISitePolicy.USER_EXCLUDE) {
+ ArrayList detectedPlugins = new ArrayList(Arrays.asList(getDetectedPlugins()));
+ String[] excludedPlugins = policy.getList();
+ for (int i = 0; i < excludedPlugins.length; i++) {
+ if (detectedPlugins.contains(excludedPlugins[i]))
+ detectedPlugins.remove(excludedPlugins[i]);
+ }
+ return (String[]) detectedPlugins.toArray(new String[0]);
+ }
+
+ // bad policy type
+ return new String[0];
+ }
+
+ /*
+ * @see ISiteEntry#getChangeStamp()
+ */
+ public long getChangeStamp() {
+ if (!changeStampIsValid)
+ computeChangeStamp();
+ return changeStamp;
+ }
+
+ /*
+ * @see ISiteEntry#getFeaturesChangeStamp()
+ */
+ public long getFeaturesChangeStamp() {
+ if (!featuresChangeStampIsValid)
+ computeFeaturesChangeStamp();
+ return featuresChangeStamp;
+ }
+
+ /*
+ * @see ISiteEntry#getPluginsChangeStamp()
+ */
+ public long getPluginsChangeStamp() {
+ if (!pluginsChangeStampIsValid)
+ computePluginsChangeStamp();
+ return pluginsChangeStamp;
+ }
+
+ /*
+ * @see ISiteEntry#isUpdateable()
+ */
+ public boolean isUpdateable() {
+ return updateable;
+ }
+
+ /*
+ * @see ISiteEntry#isNativelyLinked()
+ */
+ public boolean isNativelyLinked() {
+ return isExternallyLinkedSite();
+ }
+
+ private String[] detectFeatures() {
+
+ // invalidate stamps ... we are doing discovery
+ changeStampIsValid = false;
+ featuresChangeStampIsValid = false;
+ parent.changeStampIsValid = false;
+ parent.featuresChangeStampIsValid = false;
+
+ features = new ArrayList();
+
+ if (!supportsDetection(resolvedURL))
+ return new String[0];
+
+ // locate feature entries on site
+ File siteRoot = new File(resolvedURL.getFile().replace('/', File.separatorChar));
+ File root = new File(siteRoot, FEATURES);
+
+ String[] list = root.list();
+ String path;
+ File plugin;
+ for (int i = 0; list != null && i < list.length; i++) {
+ path = list[i] + File.separator + FEATURE_XML;
+ plugin = new File(root, path);
+ if (!plugin.exists()) {
+ continue;
+ }
+ features.add(FEATURES + "/" + path.replace(File.separatorChar, '/')); //$NON-NLS-1$
+ }
+ if (DEBUG) {
+ debug(resolvedURL.toString() + " located " + features.size() + " feature(s)"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return (String[]) features.toArray(new String[0]);
+ }
+
+ private String[] detectPlugins() {
+
+ // invalidate stamps ... we are doing discovery
+ changeStampIsValid = false;
+ pluginsChangeStampIsValid = false;
+ parent.changeStampIsValid = false;
+ parent.pluginsChangeStampIsValid = false;
+
+ plugins = new ArrayList();
+
+ if (!supportsDetection(resolvedURL))
+ return new String[0];
+
+ // locate plugin entries on site
+ File root = new File(resolvedURL.getFile().replace('/', File.separatorChar) + PLUGINS);
+ String[] list = root.list();
+ String path;
+ File plugin;
+ for (int i = 0; list != null && i < list.length; i++) {
+ path = list[i] + File.separator + PLUGIN_XML;
+ plugin = new File(root, path);
+ if (!plugin.exists()) {
+ path = list[i] + File.separator + FRAGMENT_XML;
+ plugin = new File(root, path);
+ if (!plugin.exists())
+ continue;
+ }
+ plugins.add(PLUGINS + "/" + path.replace(File.separatorChar, '/')); //$NON-NLS-1$
+ }
+ if (DEBUG) {
+ debug(resolvedURL.toString() + " located " + plugins.size() + " plugin(s)"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return (String[]) plugins.toArray(new String[0]);
+ }
+
+ private synchronized String[] getDetectedFeatures() {
+ if (features == null)
+ return detectFeatures();
+ else
+ return (String[]) features.toArray(new String[0]);
+ }
+
+ private synchronized String[] getDetectedPlugins() {
+ if (plugins == null)
+ return detectPlugins();
+ else
+ return (String[]) plugins.toArray(new String[0]);
+ }
+
+ private URL getResolvedURL() {
+ return resolvedURL;
+ }
+
+ private void computeChangeStamp() {
+ computeFeaturesChangeStamp();
+ computePluginsChangeStamp();
+ changeStamp = resolvedURL.hashCode() ^ featuresChangeStamp ^ pluginsChangeStamp;
+ changeStampIsValid = true;
+ }
+
+ private synchronized void computeFeaturesChangeStamp() {
+ if (featuresChangeStampIsValid)
+ return;
+
+ long start = 0;
+ if (DEBUG)
+ start = (new Date()).getTime();
+ String[] features = getFeatures();
+ featuresChangeStamp = computeStamp(features);
+ featuresChangeStampIsValid = true;
+ if (DEBUG) {
+ long end = (new Date()).getTime();
+ debug(resolvedURL.toString() + " feature stamp: " + featuresChangeStamp + ((featuresChangeStamp == lastFeaturesChangeStamp) ? " [no changes]" : " [was " + lastFeaturesChangeStamp + "]") + " in " + (end - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
+ }
+ }
+
+ private synchronized void computePluginsChangeStamp() {
+ if (pluginsChangeStampIsValid)
+ return;
+
+ long start = 0;
+ if (DEBUG)
+ start = (new Date()).getTime();
+ String[] plugins = getPlugins();
+ pluginsChangeStamp = computeStamp(plugins);
+ pluginsChangeStampIsValid = true;
+ if (DEBUG) {
+ long end = (new Date()).getTime();
+ debug(resolvedURL.toString() + " plugin stamp: " + pluginsChangeStamp + ((pluginsChangeStamp == lastPluginsChangeStamp) ? " [no changes]" : " [was " + lastPluginsChangeStamp + "]") + " in " + (end - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
+ }
+ }
+
+ private long computeStamp(String[] targets) {
+
+ long result = 0;
+ if (!supportsDetection(resolvedURL)) {
+ // NOTE: this path should not be executed until we support running
+ // from an arbitrary URL (in particular from http server). For
+ // now just compute stamp across the list of names. Eventually
+ // when general URLs are supported we need to do better (factor
+ // in at least the existence of the target). However, given this
+ // code executes early on the startup sequence we need to be
+ // extremely mindful of performance issues.
+ for (int i = 0; i < targets.length; i++)
+ result ^= targets[i].hashCode();
+ if (DEBUG)
+ debug("*WARNING* computing stamp using URL hashcodes only"); //$NON-NLS-1$
+ } else {
+ // compute stamp across local targets
+ String rootPath = resolvedURL.getFile().replace('/', File.separatorChar);
+ if (!rootPath.endsWith(File.separator))
+ rootPath += File.separator;
+ File rootFile = new File(rootPath);
+ if (rootFile.exists()) {
+ File f = null;
+ for (int i = 0; i < targets.length; i++) {
+ f = new File(rootFile, targets[i]);
+ if (f.exists())
+ result ^= f.getAbsolutePath().hashCode() ^ f.lastModified() ^ f.length();
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private boolean isExternallyLinkedSite() {
+ return (linkFileName != null && !linkFileName.trim().equals("")); //$NON-NLS-1$
+ }
+
+ private synchronized void refresh() {
+ // reset computed values. Will be updated on next access.
+ lastChangeStamp = changeStamp;
+ lastFeaturesChangeStamp = featuresChangeStamp;
+ lastPluginsChangeStamp = pluginsChangeStamp;
+ changeStampIsValid = false;
+ featuresChangeStampIsValid = false;
+ pluginsChangeStampIsValid = false;
+ features = null;
+ plugins = null;
+ }
+
+ }
+
+ public class SitePolicy implements IPlatformConfiguration.ISitePolicy {
+
+ private int type;
+ private String[] list;
+
+ private SitePolicy() {
+ }
+ private SitePolicy(int type, String[] list) {
+ if (type != ISitePolicy.USER_INCLUDE && type != ISitePolicy.USER_EXCLUDE)
+ throw new IllegalArgumentException();
+ this.type = type;
+
+ if (list == null)
+ this.list = new String[0];
+ else
+ this.list = list;
+ }
+
+ /*
+ * @see ISitePolicy#getType()
+ */
+ public int getType() {
+ return type;
+ }
+
+ /*
+ * @see ISitePolicy#getList()
+ */
+ public String[] getList() {
+ return list;
+ }
+
+ /*
+ * @see ISitePolicy#setList(String[])
+ */
+ public synchronized void setList(String[] list) {
+ if (list == null)
+ this.list = new String[0];
+ else
+ this.list = list;
+ }
+
+ }
+
+ public class FeatureEntry implements IPlatformConfiguration.IFeatureEntry {
+ private String id;
+ private String version;
+ private String pluginVersion;
+ private String application;
+ private URL[] root;
+ private boolean primary;
+ private String pluginIdentifier;
+
+ private FeatureEntry(String id, String version, String pluginIdentifier, String pluginVersion, boolean primary, String application, URL[] root) {
+ if (id == null)
+ throw new IllegalArgumentException();
+ this.id = id;
+ this.version = version;
+ this.pluginVersion = pluginVersion;
+ this.pluginIdentifier = pluginIdentifier;
+ this.primary = primary;
+ this.application = application;
+ this.root = (root == null ? new URL[0] : root);
+ }
+
+ private FeatureEntry(String id, String version, String pluginVersion, boolean primary, String application, URL[] root) {
+ this(id, version, id, pluginVersion, primary, application, root);
+ }
+
+ /*
+ * @see IFeatureEntry#getFeatureIdentifier()
+ */
+ public String getFeatureIdentifier() {
+ return id;
+ }
+
+ /*
+ * @see IFeatureEntry#getFeatureVersion()
+ */
+ public String getFeatureVersion() {
+ return version;
+ }
+
+ /*
+ * @see IFeatureEntry#getFeaturePluginVersion()
+ */
+ public String getFeaturePluginVersion() {
+ return pluginVersion;
+ }
+
+ /*
+ * @see IFeatureEntry#getFeatureApplication()
+ */
+ public String getFeatureApplication() {
+ return application;
+ }
+
+ /*
+ * @see IFeatureEntry#getFeatureRootURLs()
+ */
+ public URL[] getFeatureRootURLs() {
+ return root;
+ }
+
+ /*
+ * @see IFeatureEntry#canBePrimary()
+ */
+ public boolean canBePrimary() {
+ return primary;
+ }
+ /*
+ * @see IFeatureEntry#getFeaturePluginIdentifier()
+ */
+ public String getFeaturePluginIdentifier() {
+ return pluginIdentifier;
+ }
+
+ }
+
+ private class VersionedIdentifier {
+ private String identifier = ""; //$NON-NLS-1$
+ private int major = 0;
+ private int minor = 0;
+ private int service = 0;
+ private String qualifier = ""; //$NON-NLS-1$
+
+ private static final String VER_SEPARATOR = "."; //$NON-NLS-1$
+ private static final String ID_SEPARATOR = "_"; //$NON-NLS-1$
+
+ public static final int LESS_THAN = -1;
+ public static final int EQUAL = 0;
+ public static final int EQUIVALENT = 1;
+ public static final int COMPATIBLE = 2;
+ public static final int GREATER_THAN = 3;
+
+ public VersionedIdentifier(String s) {
+ if (s == null || (s = s.trim()).equals("")) //$NON-NLS-1$
+ return;
+
+ int loc = s.lastIndexOf(ID_SEPARATOR);
+ if (loc != -1) {
+ this.identifier = s.substring(0, loc);
+ String version = s.substring(loc + 1);
+ parseVersion(version);
+ } else
+ this.identifier = s;
+ }
+
+ public boolean equalIdentifiers(VersionedIdentifier id) {
+ if (id == null)
+ return identifier == null;
+ else
+ return id.identifier.equals(identifier);
+ }
+
+ public int compareVersion(VersionedIdentifier id) {
+
+ if (id == null) {
+ if (major == 0 && minor == 0 && service == 0)
+ return -1;
+ else
+ return 1;
+ }
+
+ if (major > id.major)
+ return GREATER_THAN;
+ if (major < id.major)
+ return LESS_THAN;
+ if (minor > id.minor)
+ return COMPATIBLE;
+ if (minor < id.minor)
+ return LESS_THAN;
+ if (service > id.service)
+ return EQUIVALENT;
+ if (service < id.service)
+ return LESS_THAN;
+ return compareQualifiers(qualifier, id.qualifier);
+ }
+
+ private int compareQualifiers(String q1, String q2) {
+ int result = q1.compareTo(q2);
+ if (result < 0)
+ return LESS_THAN;
+ else if (result > 0)
+ return EQUIVALENT;
+ else
+ return EQUAL;
+ }
+
+ private void parseVersion(String v) {
+ if (v == null || (v = v.trim()).equals("")) //$NON-NLS-1$
+ return;
+
+ try {
+ StringTokenizer st = new StringTokenizer(v, VER_SEPARATOR);
+ ArrayList elements = new ArrayList(4);
+
+ while (st.hasMoreTokens()) {
+ elements.add(st.nextToken());
+ }
+
+ if (elements.size() >= 1)
+ this.major = (new Integer((String) elements.get(0))).intValue();
+ if (elements.size() >= 2)
+ this.minor = (new Integer((String) elements.get(1))).intValue();
+ if (elements.size() >= 3)
+ this.service = (new Integer((String) elements.get(2))).intValue();
+ if (elements.size() >= 4)
+ this.qualifier = removeWhiteSpace((String) elements.get(3));
+
+ } catch (Exception e) {
+ // use what we got so far ...
+ }
+ }
+
+ private String removeWhiteSpace(String s) {
+ char[] chars = s.trim().toCharArray();
+ boolean whitespace = false;
+ for (int i = 0; i < chars.length; i++) {
+ if (Character.isWhitespace(chars[i])) {
+ chars[i] = '_';
+ whitespace = true;
+ }
+ }
+ return whitespace ? new String(chars) : s;
+ }
+ }
+
+ /*
+ * Element selector for use with "tiny" parser. Parser callers supply
+ * concrete selectors
+ */
+ public interface Selector {
+
+ /*
+ * Method is called to pre-select a specific xml type. Pre-selected
+ * elements are then fully parsed and result in calls to full
+ * select method.
+ * @return <code>true</code> is the element should be considered,
+ * <code>false</code> otherwise
+ */
+ public boolean select(String entry);
+
+ /*
+ * Method is called with a fully parsed element.
+ * @return <code>true</code> to select this element and terminate the parse,
+ * <code>false</code> otherwise
+ */
+ public boolean select(String element, HashMap attributes);
+ }
+
+ /*
+ * "Tiny" xml parser. Performs a rudimentary parse of a well-formed xml file.
+ * Is specifically geared to parsing plugin.xml files of "bootstrap" plug-ins
+ * during the platform startup sequence before full xml plugin is available.
+ */
+ public static class Parser {
+
+ private ArrayList elements = new ArrayList();
+
+ /*
+ * Construct parser for the specified file
+ */
+ public Parser(File file) {
+ try {
+ load(new FileInputStream(file));
+ } catch (Exception e) {
+ // continue ... actual parsing will report errors
+ }
+ }
+
+ /*
+ * Construct parser for the specified URL
+ */
+ public Parser(URL url) {
+ try {
+ load(url.openStream());
+ } catch (Exception e) {
+ // continue ... actual parsing will report errors
+ }
+ }
+
+ /*
+ * Return selected elements as an (attribute-name, attribute-value) map.
+ * The name of the selected element is returned as the value of entry with
+ * name "<element>".
+ * @return attribute map for selected element, or <code>null</code>
+ */
+ public HashMap getElement(Selector selector) {
+ if (selector == null)
+ return null;
+
+ String element;
+ for (int i = 0; i < elements.size(); i++) {
+ // make pre-parse selector call
+ element = (String) elements.get(i);
+ if (selector.select(element)) {
+ // parse selected entry
+ HashMap attributes = new HashMap();
+ String elementName;
+ int j;
+ // parse out element name
+ for (j = 0; j < element.length(); j++) {
+ if (Character.isWhitespace(element.charAt(j)))
+ break;
+ }
+ if (j >= element.length()) {
+ elementName = element;
+ } else {
+ elementName = element.substring(0, j);
+ element = element.substring(j);
+ // parse out attributes
+ StringTokenizer t = new StringTokenizer(element, "=\""); //$NON-NLS-1$
+ boolean isKey = true;
+ String key = ""; //$NON-NLS-1$
+ while (t.hasMoreTokens()) {
+ String token = t.nextToken().trim();
+ if (!token.equals("")) { //$NON-NLS-1$
+ // collect (key, value) pairs
+ if (isKey) {
+ key = token;
+ isKey = false;
+ } else {
+ attributes.put(key, token);
+ isKey = true;
+ }
+ }
+ }
+ }
+ // make post-parse selector call
+ if (selector.select(elementName, attributes)) {
+ attributes.put("<element>", elementName); //$NON-NLS-1$
+ return attributes;
+ }
+ }
+ }
+ return null;
+ }
+
+ private void load(InputStream is) {
+ if (is == null)
+ return;
+
+ // read file
+ StringBuffer xml = new StringBuffer(4096);
+ char[] iobuf = new char[4096];
+ InputStreamReader r = null;
+ try {
+ r = new InputStreamReader(is);
+ int len = r.read(iobuf, 0, iobuf.length);
+ while (len != -1) {
+ xml.append(iobuf, 0, len);
+ len = r.read(iobuf, 0, iobuf.length);
+ }
+ } catch (Exception e) {
+ return;
+ } finally {
+ if (r != null)
+ try {
+ r.close();
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+
+ // parse out element tokens
+ String xmlString = xml.toString();
+ StringTokenizer t = new StringTokenizer(xmlString, "<>"); //$NON-NLS-1$
+ while (t.hasMoreTokens()) {
+ String token = t.nextToken().trim();
+ if (!token.equals("")) //$NON-NLS-1$
+ elements.add(token);
+ }
+ }
+ }
+
+ public static class BootDescriptor {
+ private String id;
+ private String version;
+ private String[] libs;
+ private URL dir;
+
+ public BootDescriptor(String id, String version, String[] libs, URL dir) {
+ this.id = id;
+ this.version = version;
+ this.libs = libs;
+ this.dir = dir;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public String getVersion() {
+ return version;
+ }
+
+ public String[] getLibraries() {
+ return libs;
+ }
+
+ public URL getPluginDirectoryURL() {
+ return dir;
+ }
+ }
+
+ private PlatformConfiguration(String configArg, String metaPath, URL pluginPath) throws IOException {
+ this.sites = new HashMap();
+ this.externalLinkSites = new HashMap();
+ this.cfgdFeatures = new HashMap();
+ this.bootPlugins = new HashMap();
+
+ // Determine configuration URL to use (based on command line argument)
+ URL configURL = null;
+ if (configArg != null && !configArg.trim().equals("")) { //$NON-NLS-1$
+ configURL = new URL(configArg);
+ }
+
+ // initialize configuration
+ boolean createRootSite = (pluginPath == null);
+ initializeCurrent(configURL, metaPath, createRootSite);
+
+ // merge in any plugin-path entries (converted to site(s))
+ if (pluginPath != null) {
+ updateConfigurationFromPlugins(pluginPath);
+ }
+
+ // pick up any first-time default settings (relative to install location)
+ loadInitializationAttributes();
+
+ // Detect external links. These are "soft link" to additional sites. The link
+ // files are usually provided by external installation programs. They are located
+ // relative to this configuration URL.
+ configureExternalLinks();
+
+ // Validate sites in the configuration. Causes any sites that do not exist to
+ // be removed from the configuration
+ validateSites();
+
+ // compute differences between configuration and actual content of the sites
+ // (base sites and link sites)
+ computeChangeStamp();
+
+ // determine which plugins we will use to start the rest of the "kernel"
+ // (need to get core.runtime matching the executing core.boot and
+ // xerces matching the selected core.runtime)
+ // locateDefaultPlugins();
+ }
+
+ PlatformConfiguration(URL url) throws IOException {
+ this.sites = new HashMap();
+ this.externalLinkSites = new HashMap();
+ this.cfgdFeatures = new HashMap();
+ this.bootPlugins = new HashMap();
+ initialize(url);
+ }
+
+ /*
+ * @see IPlatformConfiguration#createSiteEntry(URL, ISitePolicy)
+ */
+ public ISiteEntry createSiteEntry(URL url, ISitePolicy policy) {
+ return new PlatformConfiguration.SiteEntry(url, policy, this);
+ }
+
+ /*
+ * @see IPlatformConfiguration#createSitePolicy(int, String[])
+ */
+ public ISitePolicy createSitePolicy(int type, String[] list) {
+ return new PlatformConfiguration.SitePolicy(type, list);
+ }
+
+ /*
+ * @see IPlatformConfiguration#createFeatureEntry(String, String, String, boolean, String, URL)
+ */
+ public IFeatureEntry createFeatureEntry(String id, String version, String pluginVersion, boolean primary, String application, URL[] root) {
+ return new PlatformConfiguration.FeatureEntry(id, version, pluginVersion, primary, application, root);
+ }
+
+ /*
+ * @see IPlatformConfiguration#createFeatureEntry(String, String, String,
+ * String, boolean, String, URL)
+ */
+ public IFeatureEntry createFeatureEntry(String id, String version, String pluginIdentifier, String pluginVersion, boolean primary, String application, URL[] root) {
+ return new PlatformConfiguration.FeatureEntry(id, version, pluginIdentifier, pluginVersion, primary, application, root);
+ }
+
+ /*
+ * @see IPlatformConfiguration#configureSite(ISiteEntry)
+ */
+ public void configureSite(ISiteEntry entry) {
+ configureSite(entry, false);
+ }
+
+ /*
+ * @see IPlatformConfiguration#configureSite(ISiteEntry, boolean)
+ */
+ public synchronized void configureSite(ISiteEntry entry, boolean replace) {
+
+ if (entry == null)
+ return;
+
+ URL url = entry.getURL();
+ if (url == null)
+ return;
+ String key = url.toExternalForm();
+
+ if (sites.containsKey(key) && !replace)
+ return;
+
+ sites.put(key, entry);
+ }
+
+ /*
+ * @see IPlatformConfiguration#unconfigureSite(ISiteEntry)
+ */
+ public synchronized void unconfigureSite(ISiteEntry entry) {
+ if (entry == null)
+ return;
+
+ URL url = entry.getURL();
+ if (url == null)
+ return;
+ String key = url.toExternalForm();
+
+ sites.remove(key);
+ }
+
+ /*
+ * @see IPlatformConfiguration#getConfiguredSites()
+ */
+ public ISiteEntry[] getConfiguredSites() {
+ if (sites.size() == 0)
+ return new ISiteEntry[0];
+
+ return (ISiteEntry[]) sites.values().toArray(new ISiteEntry[0]);
+ }
+
+ /*
+ * @see IPlatformConfiguration#findConfiguredSite(URL)
+ */
+ public ISiteEntry findConfiguredSite(URL url) {
+ if (url == null)
+ return null;
+ String key = url.toExternalForm();
+
+ ISiteEntry result = (ISiteEntry) sites.get(key);
+ if (result == null) // retry with decoded URL string
+ result = (ISiteEntry) sites.get(URLDecoder.decode(key));
+ return result;
+ }
+
+ /*
+ * @see IPlatformConfiguration#configureFeatureEntry(IFeatureEntry)
+ */
+ public synchronized void configureFeatureEntry(IFeatureEntry entry) {
+ if (entry == null)
+ return;
+
+ String key = entry.getFeatureIdentifier();
+ if (key == null)
+ return;
+
+ cfgdFeatures.put(key, entry);
+ }
+
+ /*
+ * @see IPlatformConfiguration#unconfigureFeatureEntry(IFeatureEntry)
+ */
+ public synchronized void unconfigureFeatureEntry(IFeatureEntry entry) {
+ if (entry == null)
+ return;
+
+ String key = entry.getFeatureIdentifier();
+ if (key == null)
+ return;
+
+ cfgdFeatures.remove(key);
+ }
+
+ /*
+ * @see IPlatformConfiguration#getConfiguredFeatureEntries()
+ */
+ public IFeatureEntry[] getConfiguredFeatureEntries() {
+ if (cfgdFeatures.size() == 0)
+ return new IFeatureEntry[0];
+
+ return (IFeatureEntry[]) cfgdFeatures.values().toArray(new IFeatureEntry[0]);
+ }
+
+ /*
+ * @see IPlatformConfiguration#findConfiguredFeatureEntry(String)
+ */
+ public IFeatureEntry findConfiguredFeatureEntry(String id) {
+ if (id == null)
+ return null;
+
+ return (IFeatureEntry) cfgdFeatures.get(id);
+ }
+
+ /*
+ * @see IPlatformConfiguration#getConfigurationLocation()
+ */
+ public URL getConfigurationLocation() {
+ return configLocation;
+ }
+
+ /*
+ * @see IPlatformConfiguration#getChangeStamp()
+ */
+ public long getChangeStamp() {
+ if (!changeStampIsValid)
+ computeChangeStamp();
+ return changeStamp;
+ }
+
+ /*
+ * @see IPlatformConfiguration#getFeaturesChangeStamp()
+ */
+ public long getFeaturesChangeStamp() {
+ if (!featuresChangeStampIsValid)
+ computeFeaturesChangeStamp();
+ return featuresChangeStamp;
+ }
+
+ /*
+ * @see IPlatformConfiguration#getPluginsChangeStamp()
+ */
+ public long getPluginsChangeStamp() {
+ if (!pluginsChangeStampIsValid)
+ computePluginsChangeStamp();
+ return pluginsChangeStamp;
+ }
+
+ /*
+ * @see IPlatformConfiguration#getApplicationIdentifier()
+ */
+ public String getApplicationIdentifier() {
+
+ if (cmdInitialize) {
+ // we are running post-install initialization. Force
+ // running of the reconciler
+ return RECONCILER_APP;
+ }
+
+ if (featuresChangeStamp != lastFeaturesChangeStamp) {
+ // we have detected feature changes ... see if we need to reconcile
+ boolean update = !cmdNoUpdate || cmdUpdate;
+ if (update)
+ return RECONCILER_APP;
+ }
+
+ // "normal" startup ... run specified application
+ return getApplicationIdentifierInternal();
+ }
+
+ private String getApplicationIdentifierInternal() {
+
+ if (cmdApplication != null) // application was specified
+ return cmdApplication;
+ else {
+ // if -feature was not specified use the default feature
+ String feature = cmdFeature;
+ if (feature == null)
+ feature = defaultFeature;
+
+ // lookup application for feature (specified or defaulted)
+ if (feature != null) {
+ IFeatureEntry fe = findConfiguredFeatureEntry(feature);
+ if (fe != null) {
+ if (fe.getFeatureApplication() != null)
+ return fe.getFeatureApplication();
+ }
+ }
+ }
+
+ // return hardcoded default if we failed
+ return DEFAULT_FEATURE_APPLICATION;
+ }
+
+ /*
+ * @see IPlatformConfiguration#getPrimaryFeatureIdentifier()
+ */
+ public String getPrimaryFeatureIdentifier() {
+
+ if (cmdFeature != null) // -feature was specified on command line
+ return cmdFeature;
+
+ // feature was not specified on command line
+ if (defaultFeature != null)
+ return defaultFeature; // return customized default if set
+ else
+ return DEFAULT_FEATURE_ID; // return hardcoded default
+ }
+
+ /*
+ * @see IPlatformConfiguration#getPluginPath()
+ */
+ public URL[] getPluginPath() {
+ ArrayList path = new ArrayList();
+ if (DEBUG)
+ debug("computed plug-in path:"); //$NON-NLS-1$
+
+ ISiteEntry[] sites = getConfiguredSites();
+ URL pathURL;
+ for (int i = 0; i < sites.length; i++) {
+ String[] plugins = sites[i].getPlugins();
+ for (int j = 0; j < plugins.length; j++) {
+ try {
+ pathURL = new URL(((SiteEntry) sites[i]).getResolvedURL(), plugins[j]);
+ path.add(pathURL);
+ if (DEBUG)
+ debug(" " + pathURL.toString()); //$NON-NLS-1$
+ } catch (MalformedURLException e) {
+ // skip entry ...
+ if (DEBUG)
+ debug(" bad URL: " + e); //$NON-NLS-1$
+ }
+ }
+ }
+ return (URL[]) path.toArray(new URL[0]);
+ }
+
+ /*
+ * @see IPlatformConfiguration#getBootstrapPluginIdentifiers()
+ */
+ public String[] getBootstrapPluginIdentifiers() {
+ return BOOTSTRAP_PLUGINS;
+ }
+
+ /*
+ * @see IPlatformConfiguration#setBootstrapPluginLocation(String, URL)
+ */
+ public void setBootstrapPluginLocation(String id, URL location) {
+ String[] ids = getBootstrapPluginIdentifiers();
+ for (int i = 0; i < ids.length; i++) {
+ if (ids[i].equals(id)) {
+ bootPlugins.put(id, location.toExternalForm());
+ break;
+ }
+ }
+ }
+
+ /*
+ * @see IPlatformConfiguration#isUpdateable()
+ */
+ public boolean isUpdateable() {
+ return true;
+ }
+
+ /*
+ * @see IPlatformConfiguration#isTransient()
+ */
+ public boolean isTransient() {
+ return transientConfig;
+ }
+
+ /*
+ * @see IPlatformConfiguration#isTransient(boolean)
+ */
+ public void isTransient(boolean value) {
+ // if (this != BootLoader.getCurrentPlatformConfiguration())
+ // transientConfig = value;
+ }
+
+ /*
+ * @see IPlatformConfiguration#refresh()
+ */
+ public synchronized void refresh() {
+ // Reset computed values. Will be lazily refreshed
+ // on next access
+ ISiteEntry[] sites = getConfiguredSites();
+ for (int i = 0; i < sites.length; i++) {
+ // reset site entry
+ ((SiteEntry) sites[i]).refresh();
+ }
+ // reset configuration entry.
+ lastChangeStamp = changeStamp;
+ lastFeaturesChangeStamp = featuresChangeStamp;
+ lastPluginsChangeStamp = pluginsChangeStamp;
+ changeStampIsValid = false;
+ featuresChangeStampIsValid = false;
+ pluginsChangeStampIsValid = false;
+ }
+
+ /*
+ * @see IPlatformConfiguration#save()
+ */
+ public void save() throws IOException {
+ if (isUpdateable())
+ save(configLocation);
+ }
+
+ /*
+ * @see IPlatformConfiguration#save(URL)
+ */
+ public synchronized void save(URL url) throws IOException {
+ if (url == null)
+ throw new IOException(Policy.bind("cfig.unableToSave.noURL")); //$NON-NLS-1$
+
+ PrintWriter w = null;
+ OutputStream os = null;
+ if (!url.getProtocol().equals("file")) { //$NON-NLS-1$
+ // not a file protocol - attempt to save to the URL
+ URLConnection uc = url.openConnection();
+ uc.setDoOutput(true);
+ os = uc.getOutputStream();
+ w = new PrintWriter(os);
+ try {
+ write(w);
+ } finally {
+ w.close();
+ }
+ } else {
+ // file protocol - do safe i/o
+ File cfigFile = new File(url.getFile().replace('/', File.separatorChar));
+ File cfigDir = cfigFile.getParentFile();
+ if (cfigDir != null)
+ cfigDir.mkdirs();
+
+ // first save the file as temp
+ File cfigTmp = new File(cfigFile.getAbsolutePath() + CONFIG_FILE_TEMP_SUFFIX);
+ os = new FileOutputStream(cfigTmp);
+ w = new PrintWriter(os);
+ try {
+ write(w);
+ } finally {
+ w.close();
+ }
+
+ // make sure we actually succeeded saving the whole configuration.
+ InputStream is = new FileInputStream(cfigTmp);
+ Properties tmpProps = new Properties();
+ try {
+ tmpProps.load(is);
+ if (!EOF.equals(tmpProps.getProperty(EOF))) {
+ throw new IOException(Policy.bind("cfig.unableToSave", cfigTmp.getAbsolutePath())); //$NON-NLS-1$
+ }
+ } finally {
+ is.close();
+ }
+
+ // make the saved config the "active" one
+ File cfigBak = new File(cfigFile.getAbsolutePath() + CONFIG_FILE_BAK_SUFFIX);
+ cfigBak.delete(); // may have old .bak due to prior failure
+
+ if (cfigFile.exists())
+ cfigFile.renameTo(cfigBak);
+
+ // at this point we have old config (if existed) as "bak" and the
+ // new config as "tmp".
+ boolean ok = cfigTmp.renameTo(cfigFile);
+ if (ok) {
+ // at this point we have the new config "activated", and the old
+ // config (if it existed) as "bak"
+ cfigBak.delete(); // clean up
+ } else {
+ // this codepath represents a tiny failure window. The load processing
+ // on startup will detect missing config and will attempt to start
+ // with "tmp" (latest), then "bak" (the previous). We can also end up
+ // here if we failed to rename the current config to "bak". In that
+ // case we will restart with the previous state.
+ throw new IOException(Policy.bind("cfig.unableToSave", cfigTmp.getAbsolutePath())); //$NON-NLS-1$
+ }
+ }
+ }
+
+ public BootDescriptor getPluginBootDescriptor(String id) {
+ // return the plugin descriptor for the specified plugin. This method
+ // is used during boot processing to obtain information about "kernel" plugins
+ // whose class loaders must be created prior to the plugin registry being
+ // available (ie. loaders needed to create the plugin registry).
+
+ if (RUNTIME_PLUGIN_ID.equals(id))
+ return runtimeDescriptor;
+ else
+ return null;
+ }
+
+ static PlatformConfiguration getCurrent() {
+ return currentPlatformConfiguration;
+ }
+
+ /**
+ * Create and initialize the current platform configuration
+ * @param cmdArgs command line arguments (startup and boot arguments are
+ * already consumed)
+ * @param r10plugins plugin-path URL as passed on the BootLoader.run(...)
+ * or BootLoader.startup(...) method. Supported for R1.0 compatibility
+ * @param r10apps application identifies as passed on the BootLoader.run(...)
+ * method. Supported for R1.0 compatibility.
+ * @param metaPath path to the platform metadata area
+ */
+ static synchronized String[] startup(String[] cmdArgs, URL r10plugins, String r10app, String metaPath, URL installURL) throws Exception {
+ PlatformConfiguration.installURL = installURL;
+
+ // if BootLoader was invoked directly (rather than via Main), it is possible
+ // to have the plugin-path and application set in 2 ways: (1) via an explicit
+ // argument on the invocation method, or (2) via a command line argument (passed
+ // into this method as the argument String[]). If specified, the explicit
+ // values are used even if the command line arguments were specified as well.
+ cmdPlugins = r10plugins; // R1.0 compatibility
+ cmdApplication = r10app; // R1.0 compatibility
+
+ // process command line arguments
+ String[] passthruArgs = processCommandLine(cmdArgs);
+ if (cmdDev)
+ cmdNoUpdate = true; // force -noupdate when in dev mode (eg. PDE)
+
+ // create current configuration
+ if (currentPlatformConfiguration == null)
+ currentPlatformConfiguration = new PlatformConfiguration(cmdConfiguration, metaPath, cmdPlugins);
+
+ // check if we will be forcing reconciliation
+ passthruArgs = checkForFeatureChanges(passthruArgs, currentPlatformConfiguration);
+
+ // check if we should indicate new changes
+ passthruArgs = checkForNewUpdates(currentPlatformConfiguration, passthruArgs);
+
+ return passthruArgs;
+ }
+
+ static synchronized void shutdown() throws IOException {
+
+ // save platform configuration
+ PlatformConfiguration config = getCurrent();
+ if (config != null) {
+ try {
+ config.save();
+ } catch (IOException e) {
+ if (DEBUG)
+ debug("Unable to save configuration " + e.toString()); //$NON-NLS-1$
+ // will recover on next startup
+ }
+ config.clearConfigurationLock();
+ }
+ }
+
+ private synchronized void initializeCurrent(URL url, String metaPath, boolean createRootSite) throws IOException {
+ // FIXME: commented out for now. Remove if not needed.
+ //boolean concurrentUse = false;
+
+ if (cmdInitialize) {
+ // we are running post-install initialization (-install command
+ // line argument). Ignore any configuration URL passed in.
+ // Force the configuration to be saved in the install location.
+ // Allow an existing configuration to be re-initialized.
+ url = new URL(getInstallURL(), CONFIG_FILE); // if we fail here, return exception
+ // FIXME: commented out for now. Remove if not needed.
+ // I left the call to #getConfigurationLock in just in case
+ // calling it has useful side effect. If not, then it can be removed too.
+ //concurrentUse = getConfigurationLock(url);
+ getConfigurationLock(url);
+
+ resetInitializationConfiguration(url); // [20111]
+ if (createRootSite)
+ configureSite(getRootSite());
+ if (DEBUG)
+ debug("Initializing configuration " + url.toString()); //$NON-NLS-1$
+ configLocation = url;
+ verifyPath(configLocation);
+ return;
+ }
+
+ if (url != null) {
+ // configuration URL was specified. Use it (if exists), or create one
+ // in specified location
+
+ // check concurrent use lock
+ // FIXME: might not need this method call.
+ getConfigurationLock(url);
+
+ // try loading the configuration
+ try {
+ load(url);
+ if (DEBUG)
+ debug("Using configuration " + url.toString()); //$NON-NLS-1$
+ } catch (IOException e) {
+ cmdFirstUse = true;
+ if (createRootSite)
+ configureSite(getRootSite());
+ if (DEBUG)
+ debug("Creating configuration " + url.toString()); //$NON-NLS-1$
+ }
+ configLocation = url;
+ verifyPath(configLocation);
+ return;
+
+ } else {
+ // configuration URL was not specified. Default behavior is to look
+ // for configuration in the workspace meta area. If not found, look
+ // for pre-initialized configuration in the installation location.
+ // If it is found it is used as the initial configuration. Otherwise
+ // a new configuration is created. In either case the resulting
+ // configuration is written into the default state area.
+ // The default state area is computed as follows:
+ // 1) We store the config state relative to the 'eclipse' directory if possible
+ // 2) If this directory is read-only OR
+ // if shared install is desired (using command line argument -shared),
+ // we store the state in <user.home>/.eclipse/<application-id>_<version> where <user.home>
+ // is unique for each local user, and <application-id> is the one
+ // defined in .eclipseproduct marker file. If .eclipseproduct does not
+ // exist, use "eclipse" as the application-id.
+
+ // if we fail here, return exception
+ URL defaultStateURL = getDefaultStateLocation();
+ URL cfigURL = new URL(defaultStateURL, CONFIG_FILE);
+
+ // check concurrent use lock
+ // FIXME: might not need this method call
+ getConfigurationLock(cfigURL);
+
+ // if we can load it, use it
+ try {
+ load(cfigURL);
+ configLocation = cfigURL;
+ verifyPath(configLocation);
+ if (DEBUG)
+ debug("Using configuration " + configLocation.toString()); //$NON-NLS-1$
+ return;
+ } catch (IOException e) {
+ cmdFirstUse = true; // we are creating new configuration
+ }
+
+ // failed to load, see if we can find pre-initialized configuration.
+ // Don't attempt this initialization when self-hosting (is unpredictable)
+ if (createRootSite) {
+ try {
+ url = new URL(getInstallURL(), CONFIG_FILE);
+ load(url);
+ // pre-initialized config loaded OK ... copy any remaining update metadata
+ // Only copy if the default config location is not the install location
+ if (getInstallURL() != defaultStateURL)
+ copyInitializedState(getInstallURL(), defaultStateURL.getFile(), CONFIG_DIR);
+ configLocation = cfigURL; // config in default location is the right URL
+ verifyPath(configLocation);
+ if (DEBUG) {
+ debug("Using configuration " + configLocation.toString()); //$NON-NLS-1$
+ debug("Initialized from " + url.toString()); //$NON-NLS-1$
+ }
+ return;
+ } catch (IOException e) {
+ // continue ...
+ }
+ }
+
+ // if load failed, initialize with default site info
+ if (createRootSite)
+ configureSite(getRootSite());
+ configLocation = cfigURL;
+ verifyPath(configLocation);
+ if (DEBUG)
+ debug("Creating configuration " + configLocation.toString()); //$NON-NLS-1$
+ return;
+ }
+ }
+
+ private synchronized void initialize(URL url) throws IOException {
+ if (url == null) {
+ if (DEBUG)
+ debug("Creating empty configuration object"); //$NON-NLS-1$
+ return;
+ }
+
+ load(url);
+ configLocation = url;
+ if (DEBUG)
+ debug("Using configuration " + configLocation.toString()); //$NON-NLS-1$
+ }
+
+ private ISiteEntry getRootSite() {
+ // create default site entry for the root
+ ISitePolicy defaultPolicy = createSitePolicy(DEFAULT_POLICY_TYPE, DEFAULT_POLICY_LIST);
+ URL siteURL = null;
+ try {
+ siteURL = new URL(PlatformURLHandler.PROTOCOL + PlatformURLHandler.PROTOCOL_SEPARATOR + "/" + "base" + "/"); //$NON-NLS-1$ //$NON-NLS-2$ // try using platform-relative URL
+ } catch (MalformedURLException e) {
+ siteURL = getInstallURL(); // ensure we come up ... use absolute file URL
+ }
+ ISiteEntry defaultSite = createSiteEntry(siteURL, defaultPolicy);
+ return defaultSite;
+ }
+
+ private void resetInitializationConfiguration(URL url) throws IOException {
+ // [20111]
+ if (!supportsDetection(url))
+ return; // can't do ...
+
+ URL resolved = resolvePlatformURL(url);
+ File initCfg = new File(resolved.getFile().replace('/', File.separatorChar));
+ File initDir = initCfg.getParentFile();
+ resetInitializationLocation(initDir);
+ }
+
+ private void resetInitializationLocation(File dir) {
+ // [20111]
+ if (dir == null || !dir.exists() || !dir.isDirectory())
+ return;
+ File[] list = dir.listFiles();
+ for (int i = 0; i < list.length; i++) {
+ if (list[i].isDirectory())
+ resetInitializationLocation(list[i]);
+ list[i].delete();
+ }
+ }
+
+ private boolean getConfigurationLock(URL url) {
+ if (configurationInWorkspace(url))
+ return false;
+
+ if (!url.getProtocol().equals("file")) //$NON-NLS-1$
+ return false;
+
+ verifyPath(url);
+ String cfgName = url.getFile().replace('/', File.separatorChar);
+ String lockName = cfgName + CONFIG_FILE_LOCK_SUFFIX;
+ cfgLockFile = new File(lockName);
+
+ //if the lock file already exists, try to delete,
+ //assume failure means another eclipse has it open
+ if (cfgLockFile.exists())
+ cfgLockFile.delete();
+ if (cfgLockFile.exists()) {
+ throw new RuntimeException(Policy.bind("cfig.inUse", cfgName, lockName)); //$NON-NLS-1$
+ }
+
+ // OK so far ... open the lock file so other instances will fail
+ try {
+ cfgLockFileRAF = new RandomAccessFile(cfgLockFile, "rw"); //$NON-NLS-1$
+ cfgLockFileRAF.writeByte(0);
+ } catch (IOException e) {
+ throw new RuntimeException(Policy.bind("cfig.failCreateLock", cfgName)); //$NON-NLS-1$
+ }
+
+ return false;
+ }
+
+ private void clearConfigurationLock() {
+ try {
+ if (cfgLockFileRAF != null) {
+ cfgLockFileRAF.close();
+ cfgLockFileRAF = null;
+ }
+ } catch (IOException e) {
+ // ignore ...
+ }
+ if (cfgLockFile != null) {
+ cfgLockFile.delete();
+ cfgLockFile = null;
+ }
+ }
+
+ private boolean configurationInWorkspace(URL url) {
+ // the configuration file is now in the workspace, so return true
+ return true;
+ }
+
+ private void computeChangeStamp() {
+ computeFeaturesChangeStamp();
+ computePluginsChangeStamp();
+ changeStamp = featuresChangeStamp ^ pluginsChangeStamp;
+ changeStampIsValid = true;
+ }
+
+ private void computeFeaturesChangeStamp() {
+ if (featuresChangeStampIsValid)
+ return;
+
+ long result = 0;
+ ISiteEntry[] sites = getConfiguredSites();
+ for (int i = 0; i < sites.length; i++) {
+ result ^= sites[i].getFeaturesChangeStamp();
+ }
+ featuresChangeStamp = result;
+ featuresChangeStampIsValid = true;
+ }
+
+ private void computePluginsChangeStamp() {
+ if (pluginsChangeStampIsValid)
+ return;
+
+ long result = 0;
+ ISiteEntry[] sites = getConfiguredSites();
+ for (int i = 0; i < sites.length; i++) {
+ result ^= sites[i].getPluginsChangeStamp();
+ }
+ pluginsChangeStamp = result;
+ pluginsChangeStampIsValid = true;
+ }
+
+ private void configureExternalLinks() {
+ URL linkURL = getInstallURL();
+ if (!supportsDetection(linkURL))
+ return;
+
+ try {
+ linkURL = new URL(linkURL, LINKS + "/"); //$NON-NLS-1$
+ } catch (MalformedURLException e) {
+ // skip bad links ...
+ if (DEBUG)
+ debug("Unable to obtain link URL"); //$NON-NLS-1$
+ return;
+ }
+
+ File linkDir = new File(linkURL.getFile());
+ File[] links = linkDir.listFiles();
+ if (links == null || links.length == 0) {
+ if (DEBUG)
+ debug("No links detected in " + linkURL.toExternalForm()); //$NON-NLS-1$
+ return;
+ }
+
+ for (int i = 0; i < links.length; i++) {
+ if (links[i].isDirectory())
+ continue;
+ if (DEBUG)
+ debug("Link file " + links[i].getAbsolutePath()); //$NON-NLS-1$
+ Properties props = new Properties();
+ FileInputStream is = null;
+ try {
+ is = new FileInputStream(links[i]);
+ props.load(is);
+ configureExternalLinkSites(links[i], props);
+ } catch (IOException e) {
+ // skip bad links ...
+ if (DEBUG)
+ debug(" unable to load link file " + e); //$NON-NLS-1$
+ continue;
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ // ignore ...
+ }
+ }
+ }
+ }
+ }
+
+ private void configureExternalLinkSites(File linkFile, Properties props) {
+ String path = props.getProperty(LINK_PATH);
+ if (path == null) {
+ if (DEBUG)
+ debug(" no path definition"); //$NON-NLS-1$
+ return;
+ }
+
+ String link;
+ boolean updateable = true;
+ URL siteURL;
+ SiteEntry linkSite;
+ ISitePolicy linkSitePolicy = createSitePolicy(DEFAULT_POLICY_TYPE, DEFAULT_POLICY_LIST);
+
+ // parse out link information
+ if (path.startsWith(LINK_READ + " ")) { //$NON-NLS-1$
+ updateable = false;
+ link = path.substring(2).trim();
+ } else if (path.startsWith(LINK_READ_WRITE + " ")) { //$NON-NLS-1$
+ link = path.substring(3).trim();
+ } else {
+ link = path;
+ }
+
+ // make sure we have a valid link specification
+ try {
+ if (!link.endsWith(File.separator))
+ link += File.separator;
+ File target = new File(link + ECLIPSE);
+ link = "file:" + target.getAbsolutePath().replace(File.separatorChar, '/'); //$NON-NLS-1$
+ if (!link.endsWith("/")) //$NON-NLS-1$
+ link += "/"; // sites must be directories //$NON-NLS-1$
+ siteURL = new URL(link);
+ } catch (MalformedURLException e) {
+ // ignore bad links ...
+ if (DEBUG)
+ debug(" bad URL " + e); //$NON-NLS-1$
+ return;
+ }
+
+ // process the link
+ linkSite = (SiteEntry) externalLinkSites.get(siteURL);
+ if (linkSite != null) {
+ // we already have a site for this link target, update it if needed
+ linkSite.updateable = updateable;
+ linkSite.linkFileName = linkFile.getAbsolutePath();
+ } else {
+ // this is a link to a new target so create site for it
+ linkSite = (SiteEntry) createSiteEntry(siteURL, linkSitePolicy);
+ linkSite.updateable = updateable;
+ linkSite.linkFileName = linkFile.getAbsolutePath();
+ }
+
+ // configure the new site
+ // NOTE: duplicates are not replaced (first one in wins)
+ configureSite(linkSite);
+ if (DEBUG)
+ debug(" " + (updateable ? "R/W -> " : "R/O -> ") + siteURL.toString()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ /*
+ * compute site(s) from plugin-path and merge into specified configuration
+ */
+ private void updateConfigurationFromPlugins(URL file) throws IOException {
+
+ // get the actual plugin path
+ URL[] pluginPath = Utils.getPluginPath(file);
+ if (pluginPath == null || pluginPath.length == 0)
+ return;
+
+ // create a temp configuration and populate it based on plugin path
+ PlatformConfiguration tempConfig = new PlatformConfiguration((URL) null);
+ for (int i = 0; i < pluginPath.length; i++) {
+ String entry = pluginPath[i].toExternalForm();
+ String sitePortion;
+ String pluginPortion;
+ int ix;
+ if (entry.endsWith("/")) { //$NON-NLS-1$
+ // assume directory path in the form <site>/plugins/
+ // look for -------------------------------^
+ ix = findEntrySeparator(entry, 2); // second from end
+ sitePortion = entry.substring(0, ix + 1);
+ pluginPortion = entry.substring(ix + 1);
+ if (!pluginPortion.equals("plugins/")) //$NON-NLS-1$
+ continue; // unsupported entry ... skip it ("fragments/" are handled)
+ pluginPortion = null;
+ } else {
+ // assume full path in the form <site>/<pluginsDir>/<some.plugin>/plugin.xml
+ // look for --------------------------^
+ ix = findEntrySeparator(entry, 3); // third from end
+ sitePortion = entry.substring(0, ix + 1);
+ pluginPortion = entry.substring(ix + 1);
+ }
+ if (ix == -1)
+ continue; // bad entry ... skip it
+
+ URL siteURL = null;
+ try {
+ siteURL = new URL(sitePortion);
+ if (siteURL.getProtocol().equals("file")) { //$NON-NLS-1$
+ File sf = new File(siteURL.getFile());
+ String sfn = sf.getAbsolutePath().replace(File.separatorChar, '/');
+ if (!sfn.endsWith("/")) //$NON-NLS-1$
+ sfn += "/"; //$NON-NLS-1$
+ siteURL = new URL("file:" + sfn); //$NON-NLS-1$
+ }
+ } catch (MalformedURLException e) {
+ continue; // bad entry ... skip it
+ }
+
+ // configure existing site or create a new one for the entry
+ ISiteEntry site = tempConfig.findConfiguredSite(siteURL);
+ ISitePolicy policy;
+ if (site == null) {
+ // new site
+ if (pluginPortion == null)
+ policy = tempConfig.createSitePolicy(ISitePolicy.USER_EXCLUDE, null);
+ else
+ policy = tempConfig.createSitePolicy(ISitePolicy.USER_INCLUDE, new String[] { pluginPortion });
+ site = tempConfig.createSiteEntry(siteURL, policy);
+ tempConfig.configureSite(site);
+ } else {
+ // existing site
+ policy = site.getSitePolicy();
+ if (policy.getType() == ISitePolicy.USER_EXCLUDE)
+ continue; // redundant entry ... skip it
+ if (pluginPortion == null) {
+ // directory entry ... change policy to exclusion (with empty list)
+ policy = tempConfig.createSitePolicy(ISitePolicy.USER_EXCLUDE, null);
+ } else {
+ // explicit entry ... add it to the inclusion list
+ ArrayList list = new ArrayList(Arrays.asList(policy.getList()));
+ list.add(pluginPortion);
+ policy = tempConfig.createSitePolicy(ISitePolicy.USER_INCLUDE, (String[]) list.toArray(new String[0]));
+ }
+ site.setSitePolicy(policy);
+ }
+ }
+
+ // merge resulting site(s) into the specified configuration
+ ISiteEntry[] tempSites = tempConfig.getConfiguredSites();
+ for (int i = 0; i < tempSites.length; i++) {
+ configureSite(tempSites[i], true /*replace*/
+ );
+ }
+ }
+
+ private void validateSites() {
+
+ // check to see if all sites are valid. Remove any sites that do not exist.
+ SiteEntry[] list = (SiteEntry[]) sites.values().toArray(new SiteEntry[0]);
+ for (int i = 0; i < list.length; i++) {
+ URL siteURL = list[i].getResolvedURL();
+ if (!supportsDetection(siteURL))
+ continue;
+
+ File siteRoot = new File(siteURL.getFile().replace('/', File.separatorChar));
+ if (!siteRoot.exists()) {
+ unconfigureSite(list[i]);
+ if (DEBUG)
+ debug("Site " + siteURL + " does not exist ... removing from configuration"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ }
+ }
+
+ private void copyInitializedState(URL source, String target, String dir) {
+ try {
+ if (!source.getProtocol().equals("file")) //$NON-NLS-1$
+ return; // need to be able to do "dir"
+
+ copy(new File(source.getFile()), new File(target), dir);
+
+ } catch (IOException e) {
+ // this is an optimistic copy. If we fail, the state will be reconciled
+ // when the update manager is triggered.
+ }
+ }
+
+ private void copy(File srcDir, File tgtDir, String extraPath) throws IOException {
+ File src = new File(srcDir, extraPath);
+ File tgt = new File(tgtDir, extraPath);
+
+ if (src.isDirectory()) {
+ // copy content of directories
+ tgt.mkdir();
+ String[] list = src.list();
+ if (list == null)
+ return;
+ for (int i = 0; i < list.length; i++) {
+ copy(srcDir, tgtDir, extraPath + File.separator + list[i]);
+ }
+ } else {
+ // copy individual files
+ FileInputStream is = null;
+ FileOutputStream os = null;
+ try {
+ is = new FileInputStream(src);
+ os = new FileOutputStream(tgt);
+ byte[] buff = new byte[1024];
+ int count = is.read(buff);
+ while (count != -1) {
+ os.write(buff, 0, count);
+ count = is.read(buff);
+ }
+ } catch (IOException e) {
+ // continue ... update reconciler will have to reconstruct state
+ } finally {
+ if (is != null)
+ try {
+ is.close();
+ } catch (IOException e) {
+ // ignore ...
+ }
+ if (os != null)
+ try {
+ os.close();
+ } catch (IOException e) {
+ // ignore ...
+ }
+ }
+ }
+ }
+
+ private void load(URL url) throws IOException {
+
+ if (url == null)
+ throw new IOException(Policy.bind("cfig.unableToLoad.noURL")); //$NON-NLS-1$
+
+ // try to load saved configuration file (watch for failed prior save())
+ Properties props = null;
+ IOException originalException = null;
+ try {
+ props = loadProperties(url, null); // try to load config file
+ } catch (IOException e1) {
+ originalException = e1;
+ try {
+ props = loadProperties(url, CONFIG_FILE_TEMP_SUFFIX); // check for failures on save
+ } catch (IOException e2) {
+ try {
+ props = loadProperties(url, CONFIG_FILE_BAK_SUFFIX); // check for failures on save
+ } catch (IOException e3) {
+ throw originalException; // we tried, but no config here ...
+ }
+ }
+ }
+
+ // check version
+ String v = props.getProperty(CFG_VERSION);
+ if (!VERSION.equals(v)) {
+ // the state is invalid, delete any files under the directory
+ // bug 33493
+ resetUpdateManagerState(url);
+ throw new IOException(Policy.bind("cfig.badVersion", v)); //$NON-NLS-1$
+ }
+
+ // load simple properties
+ defaultFeature = loadAttribute(props, CFG_FEATURE_ENTRY_DEFAULT, null);
+
+ String flag = loadAttribute(props, CFG_TRANSIENT, null);
+ if (flag != null) {
+ if (flag.equals("true")) //$NON-NLS-1$
+ transientConfig = true;
+ else
+ transientConfig = false;
+ }
+
+ String stamp = loadAttribute(props, CFG_STAMP, null);
+ if (stamp != null) {
+ try {
+ lastChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ stamp = loadAttribute(props, CFG_FEATURE_STAMP, null);
+ if (stamp != null) {
+ try {
+ lastFeaturesChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ stamp = loadAttribute(props, CFG_PLUGIN_STAMP, null);
+ if (stamp != null) {
+ try {
+ lastPluginsChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ // load bootstrap entries
+ String[] ids = getBootstrapPluginIdentifiers();
+ for (int i = 0; i < ids.length; i++) {
+ bootPlugins.put(ids[i], loadAttribute(props, CFG_BOOT_PLUGIN + "." + ids[i], null)); //$NON-NLS-1$
+ }
+
+ // load feature entries
+ IFeatureEntry fe = loadFeatureEntry(props, CFG_FEATURE_ENTRY + ".0", null); //$NON-NLS-1$
+ for (int i = 1; fe != null; i++) {
+ configureFeatureEntry(fe);
+ fe = loadFeatureEntry(props, CFG_FEATURE_ENTRY + "." + i, null); //$NON-NLS-1$
+ }
+
+ // load site properties
+ SiteEntry root = (SiteEntry) getRootSite();
+ String rootUrlString = root.getURL().toExternalForm();
+ SiteEntry se = (SiteEntry) loadSite(props, CFG_SITE + ".0", null); //$NON-NLS-1$
+ for (int i = 1; se != null; i++) {
+
+ // check if we are forcing "first use" processing with an existing
+ // platform.cfg. In this case ignore site entry that represents
+ // the platform install, and use a root site entry in its place.
+ // This ensures we do not get messed up by an exclusion list that
+ // is read from the prior state.
+ if (cmdFirstUse && rootUrlString.equals(se.getURL().toExternalForm()))
+ se = root;
+
+ if (!se.isExternallyLinkedSite())
+ configureSite(se);
+ else
+ // remember external link site state, but do not configure at this point
+ externalLinkSites.put(se.getURL(), se);
+ se = (SiteEntry) loadSite(props, CFG_SITE + "." + i, null); //$NON-NLS-1$
+ }
+ }
+
+ private Properties loadProperties(URL url, String suffix) throws IOException {
+
+ // figure out what we will be loading
+ if (suffix != null && !suffix.equals("")) //$NON-NLS-1$
+ url = new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile() + suffix);
+
+ // try to load saved configuration file
+ Properties props = new Properties();
+ InputStream is = null;
+ try {
+ is = url.openStream();
+ props.load(is);
+ // check to see if we have complete config file
+ if (!EOF.equals(props.getProperty(EOF))) {
+ throw new IOException(Policy.bind("cfig.unableToLoad.incomplete", url.toString())); //$NON-NLS-1$
+ }
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ // ignore ...
+ }
+ }
+ }
+ return props;
+ }
+
+ private ISiteEntry loadSite(Properties props, String name, ISiteEntry dflt) {
+
+ String urlString = loadAttribute(props, name + "." + CFG_URL, null); //$NON-NLS-1$
+ if (urlString == null)
+ return dflt;
+
+ URL url = null;
+ try {
+ url = new URL(urlString);
+ } catch (MalformedURLException e) {
+ return dflt;
+ }
+
+ int policyType;
+ String[] policyList;
+ String typeString = loadAttribute(props, name + "." + CFG_POLICY, null); //$NON-NLS-1$
+ if (typeString == null) {
+ policyType = DEFAULT_POLICY_TYPE;
+ policyList = DEFAULT_POLICY_LIST;
+ } else {
+ int i;
+ for (i = 0; i < CFG_POLICY_TYPE.length; i++) {
+ if (typeString.equals(CFG_POLICY_TYPE[i])) {
+ break;
+ }
+ }
+ if (i >= CFG_POLICY_TYPE.length) {
+ policyType = DEFAULT_POLICY_TYPE;
+ policyList = DEFAULT_POLICY_LIST;
+ } else {
+ policyType = i;
+ policyList = loadListAttribute(props, name + "." + CFG_LIST, new String[0]); //$NON-NLS-1$
+ }
+ }
+
+ ISitePolicy sp = createSitePolicy(policyType, policyList);
+ SiteEntry site = (SiteEntry) createSiteEntry(url, sp);
+
+ String stamp = loadAttribute(props, name + "." + CFG_STAMP, null); //$NON-NLS-1$
+ if (stamp != null) {
+ try {
+ site.lastChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ stamp = loadAttribute(props, name + "." + CFG_FEATURE_STAMP, null); //$NON-NLS-1$
+ if (stamp != null) {
+ try {
+ site.lastFeaturesChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ stamp = loadAttribute(props, name + "." + CFG_PLUGIN_STAMP, null); //$NON-NLS-1$
+ if (stamp != null) {
+ try {
+ site.lastPluginsChangeStamp = Long.parseLong(stamp);
+ } catch (NumberFormatException e) {
+ // ignore bad attribute ...
+ }
+ }
+
+ String flag = loadAttribute(props, name + "." + CFG_UPDATEABLE, null); //$NON-NLS-1$
+ if (flag != null) {
+ if (flag.equals("true")) //$NON-NLS-1$
+ site.updateable = true;
+ else
+ site.updateable = false;
+ }
+
+ String linkname = loadAttribute(props, name + "." + CFG_LINK_FILE, null); //$NON-NLS-1$
+ if (linkname != null && !linkname.equals("")) { //$NON-NLS-1$
+ site.linkFileName = linkname.replace('/', File.separatorChar);
+ }
+
+ return site;
+ }
+
+ private IFeatureEntry loadFeatureEntry(Properties props, String name, IFeatureEntry dflt) {
+ String id = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_ID, null); //$NON-NLS-1$
+ if (id == null)
+ return dflt;
+ String version = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_VERSION, null); //$NON-NLS-1$
+ String pluginVersion = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_PLUGIN_VERSION, null); //$NON-NLS-1$
+ if (pluginVersion == null)
+ pluginVersion = version;
+ String pluginIdentifier = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_PLUGIN_IDENTIFIER, null); //$NON-NLS-1$
+ if (pluginIdentifier == null)
+ pluginIdentifier = id;
+ String application = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_APPLICATION, null); //$NON-NLS-1$
+ ArrayList rootList = new ArrayList();
+
+ // get install locations
+ String rootString = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_ROOT + ".0", null); //$NON-NLS-1$ //$NON-NLS-2$
+ for (int i = 1; rootString != null; i++) {
+ try {
+ URL rootEntry = new URL(rootString);
+ rootList.add(rootEntry);
+ } catch (MalformedURLException e) {
+ // skip bad entries ...
+ }
+ rootString = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_ROOT + "." + i, null); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ URL[] roots = (URL[]) rootList.toArray(new URL[0]);
+
+ // get primary flag
+ boolean primary = false;
+ String flag = loadAttribute(props, name + "." + CFG_FEATURE_ENTRY_PRIMARY, null); //$NON-NLS-1$
+ if (flag != null) {
+ if (flag.equals("true")) //$NON-NLS-1$
+ primary = true;
+ }
+ return createFeatureEntry(id, version, pluginIdentifier, pluginVersion, primary, application, roots);
+ }
+
+ private String[] loadListAttribute(Properties props, String name, String[] dflt) {
+ ArrayList list = new ArrayList();
+ String value = loadAttribute(props, name + ".0", null); //$NON-NLS-1$
+ if (value == null)
+ return dflt;
+
+ for (int i = 1; value != null; i++) {
+ loadListAttributeSegment(list, value);
+ value = loadAttribute(props, name + "." + i, null); //$NON-NLS-1$
+ }
+ return (String[]) list.toArray(new String[0]);
+ }
+
+ private void loadListAttributeSegment(ArrayList list, String value) {
+
+ if (value == null)
+ return;
+
+ StringTokenizer tokens = new StringTokenizer(value, ","); //$NON-NLS-1$
+ String token;
+ while (tokens.hasMoreTokens()) {
+ token = tokens.nextToken().trim();
+ if (!token.equals("")) //$NON-NLS-1$
+ list.add(token);
+ }
+ return;
+ }
+
+ private String loadAttribute(Properties props, String name, String dflt) {
+ String prop = props.getProperty(name);
+ if (prop == null)
+ return dflt;
+ else
+ return prop.trim();
+ }
+
+ private void loadInitializationAttributes() {
+
+ // look for the product initialization file relative to the install location
+ URL url = getInstallURL();
+
+ // load any initialization attributes. These are the default settings for
+ // key attributes (eg. default primary feature) supplied by the packaging team.
+ // They are always reloaded on startup to pick up any changes due to
+ // "native" updates.
+ Properties initProps = new Properties();
+ InputStream is = null;
+ try {
+ URL initURL = new URL(url, CONFIG_FILE_INIT);
+ is = initURL.openStream();
+ initProps.load(is);
+ if (DEBUG)
+ debug("Defaults from " + initURL.toExternalForm()); //$NON-NLS-1$
+ } catch (IOException e) {
+ return; // could not load default settings
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ // ignore ...
+ }
+ }
+ }
+
+ // use default settings if supplied
+ String initId = loadAttribute(initProps, INIT_DEFAULT_FEATURE_ID, null);
+ if (initId != null) {
+ String application = loadAttribute(initProps, INIT_DEFAULT_FEATURE_APPLICATION, null);
+ String initPluginId = loadAttribute(initProps, INIT_DEFAULT_PLUGIN_ID, null);
+ if (initPluginId == null)
+ initPluginId = initId;
+ IFeatureEntry fe = findConfiguredFeatureEntry(initId);
+
+ if (fe == null) {
+ // bug 26896 : setup optimistic reconciliation if the primary feature has changed or is new
+ cmdFirstUse = true;
+ // create entry if not exists
+ fe = createFeatureEntry(initId, null, initPluginId, null, true, application, null);
+ } else
+ // update existing entry with new info
+ fe = createFeatureEntry(initId, fe.getFeatureVersion(), fe.getFeaturePluginIdentifier(), fe.getFeaturePluginVersion(), fe.canBePrimary(), application, fe.getFeatureRootURLs());
+ configureFeatureEntry(fe);
+ defaultFeature = initId;
+ if (DEBUG) {
+ debug(" Default primary feature: " + defaultFeature); //$NON-NLS-1$
+ if (application != null)
+ debug(" Default application : " + application); //$NON-NLS-1$
+ }
+ }
+ }
+
+ private HashMap getImport(URL entry, String id) {
+ if (id == null)
+ return null;
+ final String fId = id;
+
+ // parse out the import element attributes
+ Selector importSel = new Selector() {
+ // parse out import attributes
+ public boolean select(String element) {
+ if (element.startsWith("import")) //$NON-NLS-1$
+ return true;
+ else
+ return false;
+ }
+ public boolean select(String element, HashMap attributes) {
+ if (attributes == null)
+ return false;
+ String plugin = (String) attributes.get("plugin"); //$NON-NLS-1$
+ return fId.equals(plugin);
+ }
+ };
+ Parser p = new Parser(entry);
+ return p.getElement(importSel);
+ }
+
+ private BootDescriptor createPluginBootDescriptor(URL entry) {
+ if (entry == null)
+ return null;
+
+ // selector for plugin element
+ Selector pluginSel = new Selector() {
+ public boolean select(String element) {
+ if (element.startsWith("plugin")) //$NON-NLS-1$
+ return true;
+ else
+ return false;
+ }
+ public boolean select(String element, HashMap attributes) {
+ return true;
+ }
+ };
+
+ // selector for library elements
+ final ArrayList libs = new ArrayList();
+ Selector librarySel = new Selector() {
+ public boolean select(String element) {
+ if (element.startsWith("library")) //$NON-NLS-1$
+ return true;
+ else
+ return false;
+ }
+ public boolean select(String element, HashMap attributes) {
+ if (attributes == null)
+ return false;
+ String lib = (String) attributes.get("name"); //$NON-NLS-1$
+ if (lib != null)
+ libs.add(lib);
+ return false; // accumulate all library elements
+ }
+ };
+
+ // parse out descriptor information
+ Parser p = new Parser(entry);
+ String id = null;
+ String version = null;
+ HashMap attributes = p.getElement(pluginSel);
+ if (attributes != null) {
+ id = (String) attributes.get("id"); //$NON-NLS-1$
+ version = (String) attributes.get("version"); //$NON-NLS-1$
+ }
+ if (id == null)
+ id = ""; //$NON-NLS-1$
+ if (version == null)
+ version = "0.0.0"; //$NON-NLS-1$
+
+ p.getElement(librarySel);
+ String[] libraries = (String[]) libs.toArray(new String[0]);
+
+ String dir = entry.getFile();
+ int ix = dir.lastIndexOf("/"); //$NON-NLS-1$
+ dir = dir.substring(0, ix + 1);
+ URL dirURL = null;
+ try {
+ dirURL = new URL(entry.getProtocol(), entry.getHost(), entry.getPort(), dir);
+ } catch (MalformedURLException e) {
+ // continue ...
+ }
+
+ // return boot descriptor for the plugin
+ return new BootDescriptor(id, version, libraries, dirURL);
+ }
+
+ private URL getPluginPath(HashMap importElement) {
+ // return the plugin path element for the specified import element
+
+ if (importElement == null)
+ return null;
+
+ // determine which plugin we are looking for
+ VersionedIdentifier id;
+ String pid = (String) importElement.get("plugin"); //$NON-NLS-1$
+ String version = (String) importElement.get("version"); //$NON-NLS-1$
+ String match = (String) importElement.get("match"); //$NON-NLS-1$
+ if (pid == null)
+ return null; // bad <import> element
+ if (version == null)
+ id = new VersionedIdentifier(pid);
+ else {
+ id = new VersionedIdentifier(pid + "_" + version); //$NON-NLS-1$
+ if (match == null)
+ match = "compatible"; //$NON-NLS-1$
+ }
+
+ // search plugins on all configured sites
+ ISiteEntry[] sites = getConfiguredSites();
+ if (sites == null || sites.length == 0)
+ return null;
+
+ VersionedIdentifier savedVid = id; // initialize with baseline we are looking for
+ String savedEntry = null;
+ URL savedURL = null;
+ for (int j = 0; j < sites.length; j++) {
+ String[] plugins = sites[j].getPlugins();
+ for (int i = 0; plugins != null && i < plugins.length; i++) {
+ // look for best match.
+ // The entries are in the form <path>/<pluginDir>/plugin.xml
+ // look for -------------------------^
+ int ix = findEntrySeparator(plugins[i], 2); // second from end
+ if (ix == -1)
+ continue; // bad entry ... skip
+ String pluginDir = plugins[i].substring(ix + 1);
+ ix = pluginDir.indexOf("/"); //$NON-NLS-1$
+ if (ix != -1)
+ pluginDir = pluginDir.substring(0, ix);
+ if (pluginDir.equals("")) //$NON-NLS-1$
+ continue; // bad entry ... skip
+
+ // compare the candidate plugin using the matching rule
+ VersionedIdentifier vid = new VersionedIdentifier(pluginDir);
+ if (vid.equalIdentifiers(id)) {
+
+ // check if we have suffixed directory. If not (eg. self-hosting)
+ // we need to actually parse the plugin.xml to get its version
+ if (pluginDir.indexOf("_") == -1) { //$NON-NLS-1$
+ URL xmlURL = null;
+ try {
+ xmlURL = new URL(((SiteEntry) sites[j]).getResolvedURL(), plugins[i]);
+ } catch (MalformedURLException e) {
+ continue; // bad URL ... skip
+ }
+
+ // parse out the plugin element attributes
+ final String fpid = pid;
+ Selector versionSel = new Selector() {
+ // parse out plugin attributes
+ public boolean select(String element) {
+ if (element.startsWith("plugin")) //$NON-NLS-1$
+ return true;
+ else
+ return false;
+ }
+ public boolean select(String element, HashMap attributes) {
+ if (attributes == null)
+ return false;
+ String plugin = (String) attributes.get("id"); //$NON-NLS-1$
+ return fpid.equals(plugin);
+ }
+ };
+ Parser p = new Parser(xmlURL);
+ HashMap attributes = p.getElement(versionSel);
+ if (attributes == null)
+ continue; // bad xml ... skip
+ String pluginVersion;
+ if ((pluginVersion = (String) attributes.get("version")) == null) //$NON-NLS-1$
+ continue; // bad xml ... skip
+ pluginDir += "_" + pluginVersion; //$NON-NLS-1$
+ vid = new VersionedIdentifier(pluginDir);
+ }
+
+ // do the comparison
+ int result;
+ if ((result = vid.compareVersion(savedVid)) >= 0) {
+ if ("greaterOrEqual".equals(match)) { //$NON-NLS-1$
+ if (result > VersionedIdentifier.GREATER_THAN)
+ continue;
+ } else if ("compatible".equals(match)) { //$NON-NLS-1$
+ if (result > VersionedIdentifier.COMPATIBLE)
+ continue;
+ } else if ("equivalent".equals(match)) { //$NON-NLS-1$
+ if (result > VersionedIdentifier.EQUIVALENT)
+ continue;
+ } else if ("perfect".equals(match)) { //$NON-NLS-1$
+ if (result > VersionedIdentifier.EQUAL)
+ continue;
+ } else if (result > VersionedIdentifier.GREATER_THAN)
+ continue; // use the latest
+ savedVid = vid;
+ savedEntry = plugins[i];
+ savedURL = ((SiteEntry) sites[j]).getResolvedURL();
+ }
+ }
+ }
+ }
+
+ if (savedEntry == null)
+ return null;
+
+ try {
+ return new URL(savedURL, savedEntry);
+ } catch (MalformedURLException e) {
+ return null;
+ }
+ }
+
+ private void write(PrintWriter w) {
+ // write header
+ w.println("# " + (new Date()).toString()); //$NON-NLS-1$
+ writeAttribute(w, CFG_VERSION, VERSION);
+ if (transientConfig)
+ writeAttribute(w, CFG_TRANSIENT, "true"); //$NON-NLS-1$
+ w.println(""); //$NON-NLS-1$
+
+ // write global attributes
+ writeAttribute(w, CFG_STAMP, Long.toString(getChangeStamp()));
+ writeAttribute(w, CFG_FEATURE_STAMP, Long.toString(getFeaturesChangeStamp()));
+ writeAttribute(w, CFG_PLUGIN_STAMP, Long.toString(getPluginsChangeStamp()));
+
+ // write out bootstrap entries
+ String[] ids = getBootstrapPluginIdentifiers();
+ for (int i = 0; i < ids.length; i++) {
+ String location = (String) bootPlugins.get(ids[i]);
+ if (location != null)
+ writeAttribute(w, CFG_BOOT_PLUGIN + "." + ids[i], location); //$NON-NLS-1$
+ }
+
+ // write out feature entries
+ w.println(""); //$NON-NLS-1$
+ writeAttribute(w, CFG_FEATURE_ENTRY_DEFAULT, defaultFeature);
+ IFeatureEntry[] feats = getConfiguredFeatureEntries();
+ for (int i = 0; i < feats.length; i++) {
+ writeFeatureEntry(w, CFG_FEATURE_ENTRY + "." + Integer.toString(i), feats[i]); //$NON-NLS-1$
+ }
+
+ // write out site entries
+ SiteEntry[] list = (SiteEntry[]) sites.values().toArray(new SiteEntry[0]);
+ for (int i = 0; i < list.length; i++) {
+ writeSite(w, CFG_SITE + "." + Integer.toString(i), list[i]); //$NON-NLS-1$
+ }
+
+ // write end-of-file marker
+ writeAttribute(w, EOF, EOF);
+ }
+
+ private void writeSite(PrintWriter w, String id, SiteEntry entry) {
+
+ // write site separator
+ w.println(""); //$NON-NLS-1$
+
+ // write out site settings
+ writeAttribute(w, id + "." + CFG_URL, entry.getURL().toString()); //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_STAMP, Long.toString(entry.getChangeStamp())); //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_FEATURE_STAMP, Long.toString(entry.getFeaturesChangeStamp())); //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_PLUGIN_STAMP, Long.toString(entry.getPluginsChangeStamp())); //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_UPDATEABLE, entry.updateable ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ if (entry.linkFileName != null && !entry.linkFileName.trim().equals("")) //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_LINK_FILE, entry.linkFileName.trim().replace(File.separatorChar, '/')); //$NON-NLS-1$
+
+ // write out site policy
+ int type = entry.getSitePolicy().getType();
+ String typeString = CFG_POLICY_TYPE_UNKNOWN;
+ try {
+ typeString = CFG_POLICY_TYPE[type];
+ } catch (IndexOutOfBoundsException e) {
+ // ignore bad attribute ...
+ }
+ writeAttribute(w, id + "." + CFG_POLICY, typeString); //$NON-NLS-1$
+ writeListAttribute(w, id + "." + CFG_LIST, entry.getSitePolicy().getList()); //$NON-NLS-1$
+ }
+
+ private void writeFeatureEntry(PrintWriter w, String id, IFeatureEntry entry) {
+
+ // write feature entry separator
+ w.println(""); //$NON-NLS-1$
+
+ // write out feature entry settings
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_ID, entry.getFeatureIdentifier()); //$NON-NLS-1$
+ if (entry.canBePrimary())
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_PRIMARY, "true"); //$NON-NLS-1$ //$NON-NLS-2$
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_VERSION, entry.getFeatureVersion()); //$NON-NLS-1$
+ if (entry.getFeatureVersion() != null && !entry.getFeatureVersion().equals(entry.getFeaturePluginVersion()))
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_PLUGIN_VERSION, entry.getFeaturePluginVersion()); //$NON-NLS-1$
+ if (entry.getFeatureIdentifier() != null && !entry.getFeatureIdentifier().equals(entry.getFeaturePluginIdentifier()))
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_PLUGIN_IDENTIFIER, entry.getFeaturePluginIdentifier()); //$NON-NLS-1$
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_APPLICATION, entry.getFeatureApplication()); //$NON-NLS-1$
+ URL[] roots = entry.getFeatureRootURLs();
+ for (int i = 0; i < roots.length; i++) {
+ // write our as individual attributes (is easier for Main.java to read)
+ writeAttribute(w, id + "." + CFG_FEATURE_ENTRY_ROOT + "." + i, roots[i].toExternalForm()); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ }
+
+ private void writeListAttribute(PrintWriter w, String id, String[] list) {
+ if (list == null || list.length == 0)
+ return;
+
+ String value = ""; //$NON-NLS-1$
+ int listLen = 0;
+ int listIndex = 0;
+ for (int i = 0; i < list.length; i++) {
+ if (listLen != 0)
+ value += ","; //$NON-NLS-1$
+ else
+ value = ""; //$NON-NLS-1$
+ value += list[i];
+
+ if (++listLen >= CFG_LIST_LENGTH) {
+ writeAttribute(w, id + "." + Integer.toString(listIndex++), value); //$NON-NLS-1$
+ listLen = 0;
+ }
+ }
+ if (listLen != 0)
+ writeAttribute(w, id + "." + Integer.toString(listIndex), value); //$NON-NLS-1$
+ }
+
+ private void writeAttribute(PrintWriter w, String id, String value) {
+ if (value == null || value.trim().equals("")) //$NON-NLS-1$
+ return;
+ w.println(id + "=" + escapedValue(value)); //$NON-NLS-1$
+ }
+
+ private String escapedValue(String value) {
+ // if required, escape property values as \\uXXXX
+ StringBuffer buf = new StringBuffer(value.length() * 2); // assume expansion by less than factor of 2
+ for (int i = 0; i < value.length(); i++) {
+ char character = value.charAt(i);
+ if (character == '\\' || character == '\t' || character == '\r' || character == '\n' || character == '\f') {
+ // handle characters requiring leading \
+ buf.append('\\');
+ buf.append(character);
+ } else if ((character < 0x0020) || (character > 0x007e)) {
+ // handle characters outside base range (encoded)
+ buf.append('\\');
+ buf.append('u');
+ buf.append(HEX[(character >> 12) & 0xF]); // first nibble
+ buf.append(HEX[(character >> 8) & 0xF]); // second nibble
+ buf.append(HEX[(character >> 4) & 0xF]); // third nibble
+ buf.append(HEX[character & 0xF]); // fourth nibble
+ } else {
+ // handle base characters
+ buf.append(character);
+ }
+ }
+ return buf.toString();
+ }
+
+ private static String[] checkForFeatureChanges(String[] args, PlatformConfiguration cfg) {
+ String original = cfg.getApplicationIdentifierInternal();
+ String actual = cfg.getApplicationIdentifier();
+
+ if (original.equals(actual))
+ // base startup of specified application
+ return args;
+ else {
+ // Will run reconciler.
+ // Re-insert -application argument with original app and optionally
+ // force "first use" processing
+ int newArgCnt = cmdFirstUse ? 3 : 2;
+ String[] newArgs = new String[args.length + newArgCnt];
+ newArgs[0] = CMD_APPLICATION;
+ newArgs[1] = original;
+ if (cmdFirstUse)
+ newArgs[2] = CMD_FIRSTUSE;
+ System.arraycopy(args, 0, newArgs, newArgCnt, args.length);
+ if (DEBUG)
+ debug("triggering reconciliation ..."); //$NON-NLS-1$
+ return newArgs;
+ }
+ }
+
+ private static String[] checkForNewUpdates(IPlatformConfiguration cfg, String[] args) {
+ try {
+ URL markerURL = new URL(cfg.getConfigurationLocation(), CHANGES_MARKER);
+ File marker = new File(markerURL.getFile());
+ if (!marker.exists())
+ return args;
+
+ // indicate -newUpdates
+ marker.delete();
+ String[] newArgs = new String[args.length + 1];
+ newArgs[0] = CMD_NEW_UPDATES;
+ System.arraycopy(args, 0, newArgs, 1, args.length);
+ return newArgs;
+ } catch (MalformedURLException e) {
+ return args;
+ }
+ }
+
+ private static String[] processCommandLine(String[] args) throws Exception {
+ int[] configArgs = new int[100];
+ configArgs[0] = -1; // need to initialize the first element to something that could not be an index.
+ int configArgIndex = 0;
+ for (int i = 0; i < args.length; i++) {
+ boolean found = false;
+
+ // check for args without parameters (i.e., a flag arg)
+
+ // look for forced "first use" processing (triggered by stale
+ // bootstrap information)
+ if (args[i].equalsIgnoreCase(CMD_FIRSTUSE)) {
+ cmdFirstUse = true;
+ found = true;
+ }
+
+ // look for the update flag
+ if (args[i].equalsIgnoreCase(CMD_UPDATE)) {
+ cmdUpdate = true;
+ found = true;
+ }
+
+ // look for the no-update flag
+ if (args[i].equalsIgnoreCase(CMD_NO_UPDATE)) {
+ cmdNoUpdate = true;
+ found = true;
+ }
+
+ // look for the initialization flag
+ if (args[i].equalsIgnoreCase(CMD_INITIALIZE)) {
+ cmdInitialize = true;
+ continue; // do not remove from command line
+ }
+
+ // look for the development mode flag ... triggers no-update
+ if (args[i].equalsIgnoreCase(CMD_DEV)) {
+ cmdDev = true;
+ continue; // do not remove from command line
+ }
+
+ if (found) {
+ configArgs[configArgIndex++] = i;
+ continue;
+ }
+
+ // check for args with parameters. If we are at the last argument or if the next one
+ // has a '-' as the first character, then we can't have an arg with a parm so continue.
+
+ if (i == args.length - 1 || args[i + 1].startsWith("-")) { //$NON-NLS-1$
+ continue;
+ }
+
+ String arg = args[++i];
+
+ // look for the platform configuration to use.
+ if (args[i - 1].equalsIgnoreCase(CMD_CONFIGURATION)) {
+ found = true;
+ cmdConfiguration = arg;
+ }
+
+ // look for the feature to use for customization.
+ if (args[i - 1].equalsIgnoreCase(CMD_FEATURE)) {
+ found = true;
+ cmdFeature = arg;
+ }
+
+ // look for the application to run. Only use the value from the
+ // command line if the application identifier was not explicitly
+ // passed on BootLoader.run(...) invocation.
+ if (args[i - 1].equalsIgnoreCase(CMD_APPLICATION)) {
+ found = true;
+ if (cmdApplication == null)
+ cmdApplication = arg;
+ }
+
+ // R1.0 compatibility
+ // look for the plugins location to use. Only use the value from the
+ // command line if the plugins location was not explicitly passed on
+ // BootLoader.run(...) or BootLoader.startup(...) invocation.
+ if (args[i - 1].equalsIgnoreCase(CMD_PLUGINS)) {
+ found = true;
+ // if the arg can be made into a URL use it. Otherwise assume that
+ // it is a file path so make a file URL.
+ try {
+ if (cmdPlugins == null)
+ cmdPlugins = new URL(arg);
+ } catch (MalformedURLException e) {
+ try {
+ cmdPlugins = new URL("file:" + arg.replace(File.separatorChar, '/')); //$NON-NLS-1$
+ } catch (MalformedURLException e2) {
+ throw e; // rethrow original exception
+ }
+ }
+ }
+
+ // done checking for args. Remember where an arg was found
+ if (found) {
+ configArgs[configArgIndex++] = i - 1;
+ configArgs[configArgIndex++] = i;
+ }
+ }
+
+ // remove all the arguments consumed by this argument parsing
+ if (configArgIndex == 0)
+ return args;
+ String[] passThruArgs = new String[args.length - configArgIndex];
+ configArgIndex = 0;
+ int j = 0;
+ for (int i = 0; i < args.length; i++) {
+ if (i == configArgs[configArgIndex])
+ configArgIndex++;
+ else
+ passThruArgs[j++] = args[i];
+ }
+ return passThruArgs;
+ }
+
+ private static int findEntrySeparator(String pathEntry, int cnt) {
+ for (int i = pathEntry.length() - 1; i >= 0; i--) {
+ if (pathEntry.charAt(i) == '/') {
+ if (--cnt == 0)
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ private static String[] stringListToArray(String prop, String separator) {
+ if (prop == null || prop.trim().equals("")) //$NON-NLS-1$
+ return new String[0];
+ ArrayList list = new ArrayList();
+ StringTokenizer tokens = new StringTokenizer(prop, separator);
+ while (tokens.hasMoreTokens()) {
+ String token = tokens.nextToken().trim();
+ if (!token.equals("")) //$NON-NLS-1$
+ list.add(token);
+ }
+ return list.isEmpty() ? new String[0] : (String[]) list.toArray(new String[0]);
+ }
+
+ private static boolean supportsDetection(URL url) {
+ String protocol = url.getProtocol();
+ if (protocol.equals("file")) //$NON-NLS-1$
+ return true;
+ else if (protocol.equals(PlatformURLHandler.PROTOCOL)) {
+ URL resolved = null;
+ try {
+ resolved = resolvePlatformURL(url); // 19536
+ } catch (IOException e) {
+ return false; // we tried but failed to resolve the platform URL
+ }
+ return resolved.getProtocol().equals("file"); //$NON-NLS-1$
+ } else
+ return false;
+ }
+
+ private static void verifyPath(URL url) {
+ String protocol = url.getProtocol();
+ String path = null;
+ if (protocol.equals("file")) //$NON-NLS-1$
+ path = url.getFile();
+ else if (protocol.equals(PlatformURLHandler.PROTOCOL)) {
+ URL resolved = null;
+ try {
+ resolved = resolvePlatformURL(url); // 19536
+ if (resolved.getProtocol().equals("file")) //$NON-NLS-1$
+ path = resolved.getFile();
+ } catch (IOException e) {
+ // continue ...
+ }
+ }
+
+ if (path != null) {
+ File dir = new File(path).getParentFile();
+ if (dir != null)
+ dir.mkdirs();
+ }
+ }
+
+ private static URL resolvePlatformURL(URL url) throws IOException {
+ // 19536
+ if (url.getProtocol().equals(PlatformURLHandler.PROTOCOL)) {
+ URLConnection connection = url.openConnection();
+ if (connection instanceof PlatformURLConnection) {
+ url = ((PlatformURLConnection) connection).getResolvedURL();
+ } else {
+ // connection = new PlatformURLBaseConnection(url);
+ // url = ((PlatformURLConnection)connection).getResolvedURL();
+ url = getInstallURL();
+ }
+ }
+ return url;
+ }
+
+ private static void debug(String s) {
+ System.out.println("PlatformConfig: " + s); //$NON-NLS-1$
+ }
+
+ private void resetUpdateManagerState(URL url) throws IOException {
+ // [20111]
+ if (!supportsDetection(url))
+ return; // can't do ...
+
+ // find directory where the platform configuration file is
+ URL resolved = resolvePlatformURL(url);
+ File initCfg = new File(resolved.getFile().replace('/', File.separatorChar));
+ File initDir = initCfg.getParentFile();
+
+ // Find the Update Manager State directory
+ if (initDir == null || !initDir.exists() || !initDir.isDirectory())
+ return;
+ String temp = initCfg.getName() + ".metadata"; //$NON-NLS-1$
+ File UMDir = new File(initDir, temp + '/');
+
+ // Attempt to rename it
+ if (UMDir == null || !UMDir.exists() || !UMDir.isDirectory())
+ return;
+ Date now = new Date();
+ boolean renamed = UMDir.renameTo(new File(initDir, temp + now.getTime() + '/'));
+
+ if (!renamed)
+ resetInitializationLocation(UMDir);
+ }
+
+ private static URL getInstallURL() {
+ return installURL;
+ }
+
+ private URL getDefaultStateLocation() throws IOException {
+ // 1) We store the config state relative to the 'eclipse' directory if possible
+ // 2) If this directory is read-only
+ // we store the state in <user.home>/.eclipse/<application-id>_<version> where <user.home>
+ // is unique for each local user, and <application-id> is the one
+ // defined in .eclipseproduct marker file. If .eclipseproduct does not
+ // exist, use "eclipse" as the application-id.
+
+ URL installURL = getInstallURL();
+ File installDir = new File(installURL.getFile());
+
+ if ("file".equals(installURL.getProtocol()) && installDir.canWrite()) { //$NON-NLS-1$
+ if (DEBUG)
+ debug("Using the installation directory."); //$NON-NLS-1$
+ return installURL;
+ } else {
+ if (DEBUG)
+ debug("Using the user.home location."); //$NON-NLS-1$
+ String appName = "." + ECLIPSE; //$NON-NLS-1$
+ File eclipseProduct = new File(installDir, PRODUCT_SITE_MARKER);
+ if (eclipseProduct.exists()) {
+ Properties props = new Properties();
+ props.load(new FileInputStream(eclipseProduct));
+ String appId = props.getProperty(PRODUCT_SITE_ID);
+ if (appId == null || appId.trim().length() == 0)
+ appId = ECLIPSE;
+ String appVersion = props.getProperty(PRODUCT_SITE_VERSION);
+ if (appVersion == null || appVersion.trim().length() == 0)
+ appVersion = ""; //$NON-NLS-1$
+ appName += File.separator + appId + "_" + appVersion; //$NON-NLS-1$
+ }
+
+ String userHome = System.getProperty("user.home"); //$NON-NLS-1$
+ File configDir = new File(userHome, appName);
+ configDir.mkdirs();
+ return configDir.toURL();
+ }
+ }
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfigurationFactory.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfigurationFactory.java
new file mode 100644
index 0000000..be9bc34
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/PlatformConfigurationFactory.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.IOException;
+import java.net.URL;
+
+
+public class PlatformConfigurationFactory implements IPlatformConfigurationFactory {
+ public IPlatformConfiguration getCurrentPlatformConfiguration() {
+ return PlatformConfiguration.getCurrent();
+ }
+ public IPlatformConfiguration getPlatformConfiguration(URL url) throws IOException {
+ return new PlatformConfiguration(url);
+ }
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Policy.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Policy.java
new file mode 100644
index 0000000..58bb52c
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Policy.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.text.MessageFormat;
+import java.util.*;
+
+public class Policy {
+ private static String bundleName = "org.eclipse.update.configurator.messages"; //$NON-NLS-1$
+ private static ResourceBundle bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault());
+
+ /**
+ * Lookup the message with the given ID in this catalog
+ */
+ public static String bind(String id) {
+ return bind(id, (String[]) null);
+ }
+ /**
+ * Lookup the message with the given ID in this catalog and bind its
+ * substitution locations with the given string.
+ */
+ public static String bind(String id, String binding) {
+ return bind(id, new String[] { binding });
+ }
+ /**
+ * Lookup the message with the given ID in this catalog and bind its
+ * substitution locations with the given strings.
+ */
+ public static String bind(String id, String binding1, String binding2) {
+ return bind(id, new String[] { binding1, binding2 });
+ }
+
+ /**
+ * Lookup the message with the given ID in this catalog and bind its
+ * substitution locations with the given string values.
+ */
+ public static String bind(String id, String[] bindings) {
+ if (id == null)
+ return "No message available"; //$NON-NLS-1$
+ String message = null;
+ try {
+ message = bundle.getString(id);
+ } catch (MissingResourceException e) {
+ // If we got an exception looking for the message, fail gracefully by just returning
+ // the id we were looking for. In most cases this is semi-informative so is not too bad.
+ return "Missing message: " + id + " in: " + bundleName; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if (bindings == null)
+ return message;
+ return MessageFormat.format(message, bindings);
+ }
+ /**
+ * Print a debug message to the console. If the given boolean is <code>true</code> then
+ * pre-pend the message with the current date.
+ */
+ public static void debug(boolean includeDate, String message) {
+ if (includeDate)
+ message = new Date(System.currentTimeMillis()).toString() + " - " + message; //$NON-NLS-1$
+ System.out.println(message);
+ }
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Utils.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Utils.java
new file mode 100644
index 0000000..6701051
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/Utils.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.*;
+import org.eclipse.core.internal.boot.PlatformURLBaseConnection;
+
+public class Utils {
+ private static final String PLUGIN_PATH = ".plugin-path"; //$NON-NLS-1$
+
+ /*
+ * This method is retained for R1.0 compatibility because it is defined as API.
+ * It's function matches the API description (returns <code>null</code> when
+ * argument URL is <code>null</code> or cannot be read).
+ */
+ public static URL[] getPluginPath(URL pluginPathLocation /*R1.0 compatibility*/
+ ) {
+ InputStream input = null;
+ // first try and see if the given plugin path location exists.
+ if (pluginPathLocation == null)
+ return null;
+ try {
+ input = pluginPathLocation.openStream();
+ } catch (IOException e) {
+ //fall through
+ }
+
+ // if the given path was null or did not exist, look for a plugin path
+ // definition in the install location.
+ if (input == null)
+ try {
+ URL url = new URL(PlatformURLBaseConnection.PLATFORM_URL_STRING + PLUGIN_PATH);
+ input = url.openStream();
+ } catch (MalformedURLException e) {
+ //fall through
+ } catch (IOException e) {
+ //fall through
+ }
+
+ // nothing was found at the supplied location or in the install location
+ if (input == null)
+ return null;
+ // if we found a plugin path definition somewhere so read it and close the location.
+ URL[] result = null;
+ try {
+ try {
+ result = readPluginPath(input);
+ } finally {
+ input.close();
+ }
+ } catch (IOException e) {
+ //let it return null on failure to read
+ }
+ return result;
+ }
+
+ private static URL[] readPluginPath(InputStream input) {
+ Properties ini = new Properties();
+ try {
+ ini.load(input);
+ } catch (IOException e) {
+ return null;
+ }
+ Vector result = new Vector(5);
+ for (Enumeration groups = ini.propertyNames(); groups.hasMoreElements();) {
+ String group = (String) groups.nextElement();
+ for (StringTokenizer entries = new StringTokenizer(ini.getProperty(group), ";"); entries.hasMoreElements();) { //$NON-NLS-1$
+ String entry = (String) entries.nextElement();
+ if (!entry.equals("")) //$NON-NLS-1$
+ try {
+ result.addElement(new URL(entry));
+ } catch (MalformedURLException e) {
+ //intentionally ignore bad URLs
+ System.err.println(Policy.bind("ignore.plugin", entry)); //$NON-NLS-1$
+ }
+ }
+ }
+ return (URL[]) result.toArray(new URL[result.size()]);
+ }
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/messages.properties b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/messages.properties
new file mode 100644
index 0000000..8dc04df
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/messages.properties
@@ -0,0 +1,43 @@
+###############################################################################
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+#
+# Contributors:
+# IBM Corporation - initial API and implementation
+###############################################################################
+### Boot plugin message catalog
+
+ok = OK
+
+### URL
+url.badVariant=Unsupported \"platform:\" protocol variation {0}
+url.invalidURL=Invalid "platform:" URL {0}
+url.createConnection=Unable to create connection {0}
+url.noaccess=Unable to access URL as local {0}.
+
+### Platform Configuration
+cfig.inUse=\nConfiguration file \"{0}\" is in use by another instance of the platform, \n\
+ or there was a failure in deleting the old lock file. If no other platform instances are running, \n\
+ delete file \"{1}\" and try starting the platform again.
+cfig.failCreateLock=Failed to create lock for configuration file \"{0}\"
+cfig.badUrlArg=Bad -configuration argument \"{0}\"
+cfig.unableToLoad.incomplete=Unable to load {0}
+cfig.unableToLoad.noURL=Configuration file location not specified
+cfig.unableToSave.noURL=Configuration file save location not specified
+cfig.unableToSave=Unable to save configuration file \"{0}\"
+cfig.badVersion=Unsupported configuration version \"{0}\"
+
+platform.running=The Platform is already running.
+platform.mustNotBeRunning=The Platform must not be running.
+platform.notRunning=The Platform is not running.
+
+ignore.plugin=Ignoring invalid plug-in location: {0}.
+application.notFound=Application not found: {0}.
+error.fatal=Fatal Error: Unable to determine platform installation URL {0}.
+error.boot=Fatal Error: Unable to locate boot.xml file for executing org.eclipse.core.boot.
+error.runtime=Fatal Error: Unable to locate matching org.eclipse.core.runtime plug-in.
+error.xerces=Fatal Error: Unable to locate matching org.apache.xerces plug-in.
+error.badNL=Bad value: \"{0}\" for NL. Using system default.
\ No newline at end of file
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/IPluginInfo.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/IPluginInfo.java
new file mode 100644
index 0000000..26170e5
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/IPluginInfo.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator.migration;
+
+import java.util.Map;
+import java.util.Set;
+
+public interface IPluginInfo {
+ public Map getLibraries();
+ public String[] getLibrariesName();
+ public String[] getRequires();
+ public String getMasterId();
+ public String getMasterVersion();
+ public String getPluginClass();
+ public String getUniqueId();
+ public String getVersion();
+ public boolean isFragment();
+ public Set getPackageFilters();
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginConverter.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginConverter.java
new file mode 100644
index 0000000..d009370
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginConverter.java
@@ -0,0 +1,435 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator.migration;
+
+import java.io.*;
+import java.util.*;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.eclipse.update.configurator.ConfigurationActivator;
+import org.eclipse.update.configurator.IPluginConverter;
+import org.osgi.framework.Constants;
+import org.xml.sax.SAXException;
+
+public class PluginConverter implements IPluginConverter {
+ private static final String LEGACY = "Legacy"; //$NON-NLS-1$
+ private static final String PLUGIN = "Plugin-Class"; //$NON-NLS-1$
+
+ protected String devPathSpec;
+ private IPluginInfo pluginInfo;
+ private File bundleManifestLocation;
+ private File pluginLocation;
+ private PrintWriter out;
+
+ private static final String[] ARCH_LIST = { org.eclipse.osgi.service.environment.Constants.ARCH_PA_RISC, org.eclipse.osgi.service.environment.Constants.ARCH_PPC, org.eclipse.osgi.service.environment.Constants.ARCH_SPARC, org.eclipse.osgi.service.environment.Constants.ARCH_X86 };
+ private static final String[] OS_LIST =
+ {
+ org.eclipse.osgi.service.environment.Constants.OS_AIX,
+ org.eclipse.osgi.service.environment.Constants.OS_HPUX,
+ org.eclipse.osgi.service.environment.Constants.OS_LINUX,
+ org.eclipse.osgi.service.environment.Constants.OS_MACOSX,
+ org.eclipse.osgi.service.environment.Constants.OS_QNX,
+ org.eclipse.osgi.service.environment.Constants.OS_SOLARIS,
+ org.eclipse.osgi.service.environment.Constants.OS_WIN32 };
+ private static final String[] WS_LIST =
+ { org.eclipse.osgi.service.environment.Constants.WS_CARBON, org.eclipse.osgi.service.environment.Constants.WS_GTK, org.eclipse.osgi.service.environment.Constants.WS_MOTIF, org.eclipse.osgi.service.environment.Constants.WS_PHOTON, org.eclipse.osgi.service.environment.Constants.WS_WIN32 };
+
+ public PluginConverter() {
+ super();
+ devPathSpec = System.getProperty("osgi.dev");
+ }
+
+ public void convertManifest(IPluginInfo pluginInfo, File pluginLocation, File bundleManifestLocation) {
+ this.pluginInfo = pluginInfo;
+ this.pluginLocation = pluginLocation;
+ this.bundleManifestLocation = bundleManifestLocation;
+ generate();
+ }
+
+ public boolean convertManifest(File pluginLocation, File bundleManifestLocation) {
+ /* parse the plugin manifest to find out:
+ * - the plug-in unique identifier
+ * - the plug-in version
+ * - runtime/libraries entries
+ * - the plug-in class
+ * - the master plugin (for a fragment)
+ */
+ this.pluginLocation = pluginLocation;
+ this.bundleManifestLocation = bundleManifestLocation;
+ File pluginManifestLocation = new File(pluginLocation, "plugin.xml");
+ if (!pluginManifestLocation.isFile()) {
+ pluginManifestLocation = new File(pluginLocation, "fragment.xml");
+ if (!pluginManifestLocation.isFile())
+ // location does not contain a plugin manifest
+ return false;
+ }
+ try {
+ pluginInfo = new PluginParser().parse(pluginManifestLocation.toString());
+ generate();
+ } catch (IOException e) {
+ //TODO: what to do here?
+ e.printStackTrace();
+ return false;
+ } catch (SAXException e) {
+ //TODO: what to do here?
+ e.printStackTrace();
+ return false;
+ }
+ return true;
+ }
+
+ protected void generate() {
+ openFile();
+ generateHeaders();
+ generateClasspath();
+ generateLegacy();
+ generateActivator();
+ generatePluginClass();
+ generateProvidePackage();
+ generateImports();
+ generateRequireBundle();
+ closeFile();
+ if (ConfigurationActivator.DEBUG_CONVERTER)
+ System.out.println("Generated manifest on-the-fly at: " + bundleManifestLocation);
+ }
+
+ private void generateRequireBundle() {
+ String[] requiredBundles = pluginInfo.getRequires();
+ if (requiredBundles == null && !pluginInfo.getUniqueId().equals("org.eclipse.core.runtime")) // to avoid cycles
+ requiredBundles = new String[] { "org.eclipse.core.runtime" };
+
+ writeEntry(Constants.REQUIRE_BUNDLE, requiredBundles);
+ }
+
+ private void generateLegacy() {
+ writeEntry(LEGACY, "true");
+ }
+
+ private void generateImports() {
+ // TODO We should not need DynamicImport-Package or Import-Package
+ // writeEntry(Constants.DYNAMICIMPORT_PACKAGE, "*");
+ }
+
+ private void openFile() {
+ try {
+ bundleManifestLocation.getParentFile().mkdirs();
+ bundleManifestLocation.createNewFile();
+ } catch (IOException e) {
+ System.err.println("error creating directory writing manifest for " + pluginInfo.getUniqueId());
+ return;
+ }
+ BufferedOutputStream outputFile = null;
+ try {
+ outputFile = new BufferedOutputStream(new FileOutputStream(bundleManifestLocation));
+ } catch (FileNotFoundException e) {
+ System.err.println("error writing manifest for " + pluginInfo.getUniqueId());
+ return;
+ }
+ out = new PrintWriter(outputFile);
+ // so it is easy to tell which ones are generated
+ out.println("Generated: true");
+ }
+
+ private void writeEntry(String key, Collection value) {
+ if (value == null || value.size() == 0)
+ return;
+ if (value.size() == 1) {
+ out.println(key + ": " + value.iterator().next());
+ return;
+ }
+ key = key + ": ";
+ out.println(key);
+ out.print(' ');
+ boolean first = true;
+ for (Iterator i = value.iterator(); i.hasNext();) {
+ if (first)
+ first = false;
+ else {
+ out.println(',');
+ out.print(' ');
+ }
+ out.print(i.next());
+ }
+ out.println();
+ }
+
+ private void writeEntry(String key, String[] value) {
+ if (value == null || value.length == 0)
+ return;
+ if (value.length == 1) {
+ out.println(key + ": " + value[0]);
+ return;
+ }
+ key = key + ": ";
+ out.println(key);
+ out.print(' ');
+ boolean first = true;
+ for (int i = 0; i < value.length; i++) {
+ if (first)
+ first = false;
+ else {
+ out.println(',');
+ out.print(' ');
+ }
+ out.print(value[i]);
+ }
+ out.println();
+ }
+
+ private void writeEntry(String key, String value) {
+ if (value != null && value.length() > 0)
+ out.println(key + ": " + value);
+ }
+
+ private void closeFile() {
+ out.close();
+ }
+
+ private void generateHeaders() {
+ writeEntry(Constants.BUNDLE_NAME, pluginInfo.getUniqueId());
+ writeEntry(Constants.BUNDLE_VERSION, pluginInfo.getVersion());
+ writeEntry(Constants.BUNDLE_GLOBALNAME, pluginInfo.getUniqueId());
+ }
+ private void generateProvidePackage() {
+ StringBuffer providePackage = new StringBuffer();
+ Set exports = getExports();
+ if (exports != null) {
+ Iterator iter = exports.iterator();
+ boolean firstPkg = true;
+ while (iter.hasNext()) {
+ String pkg = (String) iter.next();
+ if (firstPkg) {
+ providePackage.append("\n ");
+ firstPkg = false;
+ } else {
+ providePackage.append(",\n ");
+ }
+ providePackage.append(pkg);
+ }
+ writeEntry(Constants.PROVIDE_PACKAGE, providePackage.toString());
+ }
+
+ if (pluginInfo.isFragment()) {
+ StringBuffer hostBundle = new StringBuffer();
+
+ hostBundle.append(pluginInfo.getMasterId()).append("; ");
+ hostBundle.append(Constants.BUNDLE_VERSION_ATTRIBUTE).append("=");
+ hostBundle.append(pluginInfo.getMasterVersion());
+
+ writeEntry(Constants.HOST_BUNDLE, hostBundle.toString());
+ }
+ }
+
+ private ArrayList getLibrariesExpandingVariables(String libraryPath, boolean filter) {
+ String var = hasPrefix(libraryPath);
+ if (var == null) {
+ ArrayList returnValue = new ArrayList(1);
+ returnValue.add(libraryPath);
+ return returnValue;
+ }
+ if (var.equals("ws")) {
+ return findWSJars(pluginLocation, libraryPath, filter);
+ }
+ if (var.equals("os")) {
+ return findOSJars(pluginLocation, libraryPath, filter);
+ }
+ return new ArrayList(0);
+ }
+
+ private void generateClasspath() {
+ String[] libraries = pluginInfo.getLibrariesName();
+ ArrayList expandedPath = new ArrayList();
+ for (int i = 0; i < libraries.length; i++) {
+ expandedPath.addAll(getLibrariesExpandingVariables(libraries[i], true));
+ }
+ writeEntry(Constants.BUNDLE_CLASSPATH, expandedPath);
+ }
+
+ private ArrayList findWSJars(File pluginRoot, String path, boolean filter) {
+ path = path.substring(4);
+ ArrayList found = new ArrayList(0);
+ for (int i = 0; i < WS_LIST.length; i++) {
+ String searchedPath = "ws/" + WS_LIST[i] + path;
+ if (new File(pluginRoot, searchedPath).exists()) {
+ found.add(searchedPath + (filter ? ";(ws=" + WS_LIST[i] + ")" : ""));
+ }
+ }
+ return found;
+ }
+
+ private ArrayList findOSJars(File pluginRoot, String path, boolean filter) {
+ path = path.substring(4);
+ ArrayList found = new ArrayList(0);
+ for (int i = 0; i < OS_LIST.length; i++) {
+ //look for os/osname/path
+ String searchedPath = "os/" + OS_LIST[i] + "/" + path;
+ if (new File(pluginRoot, searchedPath).exists())
+ found.add(searchedPath + (filter ? ";(os=" + WS_LIST[i] + ")" : ""));
+
+ //look for os/osname/archname/path
+ for (int j = 0; j < ARCH_LIST.length; j++) {
+ searchedPath = "os/" + OS_LIST[i] + "/" + ARCH_LIST[j] + "/" + path;
+ if (new File(pluginRoot, searchedPath).exists()) {
+ found.add(searchedPath + (filter ? ";(& (os=" + WS_LIST[i] + ") (arch=" + ARCH_LIST[j] + ")" : ""));
+ }
+ }
+ }
+ return found;
+ }
+ //return a String representing the string found between the $s
+ private String hasPrefix(String libPath) {
+ if (libPath.startsWith("$ws$"))
+ return "ws";
+ if (libPath.startsWith("$os$"))
+ return "os";
+ if (libPath.startsWith("$nl$"))
+ return "nl";
+ return null;
+ }
+
+ private void generateActivator() {
+ if (!pluginInfo.isFragment())
+ writeEntry(Constants.BUNDLE_ACTIVATOR, "org.eclipse.core.runtime.compatibility.PluginActivator");
+ }
+
+ private void generatePluginClass() {
+ writeEntry(PLUGIN, pluginInfo.getPluginClass());
+ }
+
+ private Set filterExport(Collection exportToFilter, Collection filter) {
+ if (filter == null || filter.contains("*"))
+ return (Set) exportToFilter;
+
+ Set filteredExport = new HashSet(exportToFilter.size());
+ for (Iterator iter = exportToFilter.iterator(); iter.hasNext();) {
+ String anExport = (String) iter.next();
+
+ for (Iterator iter2 = filter.iterator(); iter2.hasNext();) {
+ String aFilter = (String) iter2.next();
+ if (anExport.startsWith(aFilter)) {
+ filteredExport.add(anExport);
+ }
+ }
+ }
+ return filteredExport;
+ }
+
+ private Set getExportsFromJAR(File jarFile) {
+ Set names = new HashSet();
+ JarFile file = null;
+ try {
+ file = new JarFile(jarFile);
+ } catch (IOException e) {
+ System.err.println("Ignore " + jarFile);
+ return names;
+ }
+
+ //Run through the entries
+ for (Enumeration enum = file.entries(); enum.hasMoreElements();) {
+ JarEntry entry = (JarEntry) enum.nextElement();
+ String name = entry.getName();
+
+ int lastSlash = name.lastIndexOf("/");
+ //Ignore folders that do not contain files
+ if (lastSlash != -1 && lastSlash != name.length() - 1) {
+ if (name.lastIndexOf(' ') == -1 && !name.equalsIgnoreCase("meta-inf/manifest.mf"))
+ names.add(name.substring(0, lastSlash).replace('/', '.'));
+ }
+ }
+ return names;
+ }
+
+ private Set getExportsFromDir(File location) {
+ return getExportsFromDir(location, "");
+ }
+
+ private Set getExportsFromDir(File location, String packageName) {
+ String prefix = (packageName.length() > 0) ? (packageName + '.') : "";
+ File[] files = location.listFiles();
+ Set exportedPaths = new HashSet();
+ boolean containsFile = false;
+ for (int i = 0; i < files.length; i++) {
+ if (files[i].isDirectory())
+ exportedPaths.addAll(getExportsFromDir(files[i], prefix + files[i].getName()));
+ else
+ containsFile = true;
+ }
+ if (containsFile && packageName.length() > 0)
+ exportedPaths.add(packageName);
+ return exportedPaths;
+ }
+
+ private Set getExports() {
+ Map libs = pluginInfo.getLibraries();
+ if (libs == null)
+ return null;
+
+ // Based on similar code from EclipseStarter
+ // Check the osgi.dev property to see if dev classpath entries have been defined.
+ // String osgiDev = System.getProperty("osgi.dev");
+ String[] devClassPath = null;
+ if (devPathSpec != null) {
+ // Add each dev classpath entry
+ Vector tokens = new Vector(6);
+ StringTokenizer t = new StringTokenizer(devPathSpec, ",");
+ while (t.hasMoreTokens()) {
+ String token = t.nextToken();
+ if (!token.equals("")) {
+ tokens.addElement(token);
+ }
+ }
+ devClassPath = new String[tokens.size()];
+ tokens.toArray(devClassPath);
+ }
+
+ // add the dev. time classpath entries
+ List starExport = new ArrayList(1);
+ starExport.add("*");
+ if (devClassPath != null) {
+ for (int i = 0; i < devClassPath.length; i++) {
+ libs.put(devClassPath[i], starExport);
+ }
+ }
+ Set result = new HashSet(7);
+ Set libEntries = libs.entrySet();
+ for (Iterator iter = libEntries.iterator(); iter.hasNext();) {
+ Map.Entry element = (Map.Entry) iter.next();
+ List filter = (List) element.getValue();
+ if (filter.size() == 0) //If the library is not exported, then ignore it
+ continue;
+
+ File libraryLocation = new File(pluginLocation, (String) element.getKey());
+ Set exports = null;
+ if (libraryLocation.exists()) {
+ if (libraryLocation.isFile())
+ exports = filterExport(getExportsFromJAR(libraryLocation), filter); //TODO Need to handle $xx$ variables
+ else if (libraryLocation.isDirectory())
+ exports = filterExport(getExportsFromDir(libraryLocation), filter);
+ } else {
+ ArrayList expandedLibs = getLibrariesExpandingVariables((String) element.getKey(), false);
+ exports = new HashSet();
+ for (Iterator iterator = expandedLibs.iterator(); iterator.hasNext();) {
+ String libName = (String) iterator.next();
+ File libFile = new File(pluginLocation, libName);
+ if (libFile.isFile()) {
+ exports.addAll(filterExport(getExportsFromJAR(libFile), filter));
+ }
+ }
+ }
+
+ if (exports != null) {
+ result.addAll(exports);
+ }
+ }
+ return result;
+ }
+
+}
diff --git a/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginParser.java b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginParser.java
new file mode 100644
index 0000000..8fb8a89
--- /dev/null
+++ b/update/org.eclipse.update.configurator/src/org/eclipse/update/configurator/migration/PluginParser.java
@@ -0,0 +1,253 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.update.configurator.migration;
+
+import java.io.IOException;
+import java.util.*;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParserFactory;
+import org.eclipse.update.configurator.ConfigurationActivator;
+import org.osgi.framework.Constants;
+import org.osgi.framework.ServiceReference;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+public class PluginParser extends DefaultHandler {
+ /**
+ * Manifest schema version from "eclipse" processing directive, or
+ * <code>null</code> if none.
+ * @since 3.0
+ */
+ private String schemaVersion = null;
+ private PluginInfo manifestInfo = new PluginInfo();
+ private List exportStatement;
+
+ // model parser
+ private ServiceReference parserReference;
+
+ public PluginParser() {
+ super();
+ }
+
+ public PluginInfo parse(String fileLocation) throws IOException, SAXException {
+ SAXParserFactory factory = acquireXMLParsing();
+ if (factory == null)
+ return null;
+ try {
+ factory.setNamespaceAware(true);
+ factory.setFeature("http://xml.org/sax/features/string-interning", true); //$NON-NLS-1$
+ factory.setValidating(false);
+ factory.newSAXParser().parse(fileLocation, this);
+ } catch (ParserConfigurationException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } finally {
+ releaseXMLParsing();
+ }
+ return manifestInfo;
+ }
+
+ public void startElement(String uri, String elementName, String qName, Attributes attributes) throws SAXException {
+ if (elementName.equals("plugin") || elementName.equals("fragment")) {
+ manifestInfo.pluginId = attributes.getValue("", "id");
+ manifestInfo.version = attributes.getValue("", "version");
+ manifestInfo.pluginClass = attributes.getValue("", "class");
+ manifestInfo.schemaVersion = schemaVersion;
+ if (elementName.equals("fragment")) {
+ manifestInfo.masterPluginId = attributes.getValue("", "plugin-id");
+ manifestInfo.masterVersion = attributes.getValue("", "plugin-version");
+ }
+ } else if (elementName.equals("library")) {
+ if (manifestInfo.libraries == null)
+ manifestInfo.libraries = new HashMap();
+ exportStatement = new ArrayList();
+ manifestInfo.libraries.put(attributes.getValue("", "name"), exportStatement);
+ } else if (elementName.equals("import")) {
+ if (manifestInfo.requires == null) {
+ manifestInfo.requires = new ArrayList();
+ // to avoid cycles
+ if (!manifestInfo.pluginId.equals("org.eclipse.core.runtime"))
+ manifestInfo.requires.add("org.eclipse.core.runtime");
+ }
+ String plugin = attributes.getValue("", "plugin");
+ if (plugin == null)
+ return;
+
+ if (plugin.equals("org.eclipse.core.boot") || plugin.equals("org.eclipse.core.runtime"))
+ return;
+
+ String version = attributes.getValue("", "version");
+ String export = attributes.getValue("", "export");
+ String optional = attributes.getValue("", "optional");
+ String match = attributes.getValue("", "match");
+ String modImport = plugin;
+ if (version != null) {
+ modImport += "; " + Constants.BUNDLE_VERSION_ATTRIBUTE + "=" + version;
+ }
+ if (export != null) {
+ modImport += "; " + Constants.PROVIDE_PACKAGES_ATTRIBUTE + "=" + export;
+ }
+ if (optional != null) {
+ modImport += ";" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true";
+ }
+ if (match != null) {
+ modImport += ";" + Constants.VERSION_MATCH_ATTRIBUTE + "=";
+ if (match.equalsIgnoreCase("perfect")) {
+ modImport += Constants.VERSION_MATCH_PERFECT;
+ } else if (match.equalsIgnoreCase("equivalent")) {
+ modImport += Constants.VERSION_MATCH_EQUIVALENT;
+ } else if (match.equalsIgnoreCase("compatible")) {
+ modImport += Constants.VERSION_MATCH_COMPATIBLE;
+ } else if (match.equalsIgnoreCase("greaterOrEqual")) {
+ modImport += Constants.VERSION_MATCH_GREATERTHANOREQUAL;
+ }
+ }
+ manifestInfo.requires.add(modImport);
+ } else if (elementName.equals("packages")) {
+ //packages filtering is done globally
+ if (manifestInfo.filters == null)
+ manifestInfo.filters = new HashSet(4);
+ String prefixString = attributes.getValue("", "prefixes");
+ StringTokenizer tok = new StringTokenizer(prefixString, ",");
+ while (tok.hasMoreTokens()) {
+ manifestInfo.filters.add(tok.nextToken().trim());
+ }
+ } else if (elementName.equals("export")) {
+ //Add the export to the last library encountered
+ String exportFilter = (String) attributes.getValue("", "name");
+ StringTokenizer tok = new StringTokenizer(exportFilter, ",");
+ while (tok.hasMoreTokens()) {
+ exportStatement.add(tok.nextToken().trim());
+ }
+ }
+ }
+
+ private SAXParserFactory acquireXMLParsing() {
+ parserReference = ConfigurationActivator.getBundleContext().getServiceReference("javax.xml.parsers.SAXParserFactory");
+ if (parserReference == null)
+ return null;
+ return (SAXParserFactory) ConfigurationActivator.getBundleContext().getService(parserReference);
+ }
+
+ private void releaseXMLParsing() {
+ if (parserReference != null)
+ ConfigurationActivator.getBundleContext().ungetService(parserReference);
+ }
+
+ public static void main(String[] args) throws Exception {
+ for (int i = 0; i < args.length; i++)
+ System.out.println(new PluginParser().parse(args[i]));
+ }
+
+ public class PluginInfo implements IPluginInfo {
+ private String schemaVersion;
+ private String pluginId;
+ private String version;
+ // TODO libraries and requires should be ordered.
+ private Map libraries; //represent the libraries and their export statement
+ private ArrayList requires;
+ private String pluginClass;
+ private String masterPluginId;
+ private String masterVersion;
+ private Set filters;
+
+ public boolean isFragment() {
+ return masterPluginId != null;
+ }
+ public String toString() {
+ return "plugin-id: " + pluginId + " version: " + version + " libraries: " + libraries + " class:" + pluginClass + " master: " + masterPluginId + " master-version: " + masterVersion + " requires: " + requires;
+ }
+ public Map getLibraries() {
+ if (libraries == null)
+ return new HashMap(0);
+ return libraries;
+ }
+
+ public String[] getRequires() {
+ if (requires == null)
+ return new String[] { "org.eclipse.core.runtime" };
+
+ if (schemaVersion == null) {
+ //Add elements on the requirement list of ui and help.
+ for (int i = 0; i < requires.size(); i++) {
+ if ("org.eclipse.ui".equals(requires.get(i))) { //$NON-NLS-1$
+ requires.add(i + 1, "org.eclipse.ui.workbench.texteditor;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ requires.add(i + 1, "org.eclipse.ui.jface.text;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ requires.add(i + 1, "org.eclipse.ui.editors;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ requires.add(i + 1, "org.eclipse.ui.views;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ requires.add(i + 1, "org.eclipse.ui.ide;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ } else if ("org.eclipse.help".equals(requires.get(i))) { //$NON-NLS-1$
+ requires.add(i + 1, "org.eclipse.help.base;" + Constants.OPTIONAL_ATTRIBUTE + "=" + "true");
+ }
+ }
+ }
+
+ String[] requireBundles = new String[requires.size()];
+ requires.toArray(requireBundles);
+ return requireBundles;
+ }
+
+ public String getMasterId() {
+ return masterPluginId;
+ }
+ public String getMasterVersion() {
+ return masterVersion;
+ }
+ public String getPluginClass() {
+ return pluginClass;
+ }
+ public String getUniqueId() {
+ return pluginId;
+ }
+ public String getVersion() {
+ return version;
+ }
+ public Set getPackageFilters() {
+ return filters;
+ }
+ public String[] getLibrariesName() {
+ if (libraries == null)
+ return new String[0];
+ Set names = libraries.keySet();
+ return (String[]) names.toArray(new String[names.size()]);
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see org.xml.sax.ContentHandler#processingInstruction
+ * @since 3.0
+ */
+ public void processingInstruction(String target, String data) throws SAXException {
+ // Since 3.0, a processing instruction of the form <?eclipse version="3.0"?> at
+ // the start of the manifest file is used to indicate the plug-in manifest
+ // schema version in effect. Pre-3.0 (i.e., 2.1) plug-in manifest files do not
+ // have one of these, and this is how we can distinguish the manifest of a
+ // pre-3.0 plug-in from a post-3.0 one (for compatibility tranformations).
+ if (target.equalsIgnoreCase("eclipse")) { //$NON-NLS-1$
+ // just the presence of this processing instruction indicates that this
+ // plug-in is at least 3.0
+ schemaVersion = "3.0"; //$NON-NLS-1$
+ StringTokenizer tokenizer = new StringTokenizer(data, "=\""); //$NON-NLS-1$
+ while (tokenizer.hasMoreTokens()) {
+ String token = tokenizer.nextToken();
+ if (token.equalsIgnoreCase("version")) { //$NON-NLS-1$
+ if (!tokenizer.hasMoreTokens()) {
+ break;
+ }
+ schemaVersion = tokenizer.nextToken();
+ break;
+ }
+ }
+ }
+ }
+}
