| /******************************************************************************* |
| * Copyright (c) 2007, 2008 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.equinox.internal.p2.publisher; |
| |
| import java.io.*; |
| import java.util.*; |
| import java.util.jar.JarFile; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipFile; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.equinox.internal.p2.core.helpers.LogHelper; |
| import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper; |
| import org.eclipse.osgi.service.pluginconversion.PluginConversionException; |
| import org.eclipse.osgi.service.pluginconversion.PluginConverter; |
| import org.eclipse.osgi.service.resolver.*; |
| import org.eclipse.osgi.util.ManifestElement; |
| import org.eclipse.osgi.util.NLS; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.BundleException; |
| |
| public class BundleDescriptionFactory { |
| public static final String DIR = "dir"; //$NON-NLS-1$ |
| public static final String JAR = "jar"; //$NON-NLS-1$ |
| private static final String FEATURE_FILENAME_DESCRIPTOR = "feature.xml"; //$NON-NLS-1$ |
| private static final String PLUGIN_FILENAME_DESCRIPTOR = "plugin.xml"; //$NON-NLS-1$ |
| private static final String FRAGMENT_FILENAME_DESCRIPTOR = "fragment.xml"; //$NON-NLS-1$ |
| |
| public static String BUNDLE_SHAPE = "Eclipse-BundleShape"; //$NON-NLS-1$ |
| |
| // static final String DEFAULT_BUNDLE_LOCALIZATION = "plugin"; //$NON-NLS-1$ |
| // static final String PROPERTIES_FILE_EXTENSION = ".properties"; //$NON-NLS-1$ |
| // static final String MANIFEST_LOCALIZATIONS = "eclipse.p2.manifest.localizations"; //$NON-NLS-1$ |
| // |
| // static final Locale DEFAULT_LOCALE = new Locale("df", "LT"); //$NON-NLS-1$//$NON-NLS-2$ |
| // static final Locale PSEUDO_LOCALE = new Locale("zz", "ZZ"); //$NON-NLS-1$//$NON-NLS-2$ |
| |
| StateObjectFactory factory; |
| State state; |
| |
| public static BundleDescriptionFactory getBundleDescriptionFactory(BundleContext context) { |
| PlatformAdmin platformAdmin = (PlatformAdmin) ServiceHelper.getService(context, PlatformAdmin.class.getName()); |
| if (platformAdmin == null) |
| throw new IllegalStateException("PlatformAdmin not registered."); //$NON-NLS-1$ |
| return new BundleDescriptionFactory(platformAdmin.getFactory(), null); |
| } |
| |
| public BundleDescriptionFactory(StateObjectFactory factory, State state) { |
| this.factory = factory; |
| this.state = state; |
| //TODO find a state and a factory when not provided |
| } |
| |
| private static PluginConverter acquirePluginConverter() { |
| return (PluginConverter) ServiceHelper.getService(Activator.getContext(), PluginConverter.class.getName()); |
| } |
| |
| private static Dictionary convertPluginManifest(File bundleLocation, boolean logConversionException) { |
| PluginConverter converter; |
| try { |
| converter = acquirePluginConverter(); |
| if (converter == null) { |
| LogHelper.log(new Status(IStatus.ERROR, Activator.ID, "Unable to aquire PluginConverter service during generation for: " + bundleLocation)); |
| return null; |
| } |
| return converter.convertManifest(bundleLocation, false, null, true, null); |
| } catch (PluginConversionException convertException) { |
| // only log the exception if we had a plugin.xml or fragment.xml and we failed conversion |
| if (bundleLocation.getName().equals(FEATURE_FILENAME_DESCRIPTOR)) |
| return null; |
| if (!new File(bundleLocation, PLUGIN_FILENAME_DESCRIPTOR).exists() && !new File(bundleLocation, FRAGMENT_FILENAME_DESCRIPTOR).exists()) |
| return null; |
| if (logConversionException) { |
| IStatus status = new Status(IStatus.WARNING, Activator.ID, 0, NLS.bind(Messages.exception_errorConverting, bundleLocation.getAbsolutePath()), convertException); |
| LogHelper.log(status); |
| } |
| return null; |
| } |
| } |
| |
| public BundleDescription getBundleDescription(Dictionary enhancedManifest, File bundleLocation) { |
| try { |
| BundleDescription descriptor = factory.createBundleDescription(state, enhancedManifest, bundleLocation != null ? bundleLocation.getAbsolutePath() : null, 1); //TODO Do we need to have a real bundle id |
| descriptor.setUserObject(enhancedManifest); |
| return descriptor; |
| } catch (BundleException e) { |
| String message = NLS.bind(Messages.exception_stateAddition, bundleLocation == null ? null : bundleLocation.getAbsoluteFile()); |
| IStatus status = new Status(IStatus.WARNING, Activator.ID, message, e); |
| LogHelper.log(status); |
| return null; |
| } |
| } |
| |
| public BundleDescription getBundleDescription(File bundleLocation) { |
| Dictionary manifest = loadManifest(bundleLocation); |
| if (manifest == null) |
| return null; |
| return getBundleDescription(manifest, bundleLocation); |
| } |
| |
| public BundleDescription getBundleDescription(InputStream manifestStream, File bundleLocation) { |
| Hashtable entries = new Hashtable(); |
| try { |
| ManifestElement.parseBundleManifest(manifestStream, entries); |
| return getBundleDescription(entries, bundleLocation); |
| } catch (IOException e) { |
| String message = "An error occurred while reading the bundle description."; |
| IStatus status = new Status(IStatus.ERROR, Activator.ID, message, e); |
| LogHelper.log(status); |
| } catch (BundleException e) { |
| String message = "An error occurred while reading the bundle description."; |
| IStatus status = new Status(IStatus.ERROR, Activator.ID, message, e); |
| LogHelper.log(status); |
| } |
| return null; |
| } |
| |
| public static Dictionary loadManifest(File bundleLocation) { |
| InputStream manifestStream = null; |
| ZipFile jarFile = null; |
| try { |
| if ("jar".equalsIgnoreCase(new Path(bundleLocation.getName()).getFileExtension()) && bundleLocation.isFile()) { //$NON-NLS-1$ |
| jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ); |
| ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME); |
| if (manifestEntry != null) { |
| manifestStream = jarFile.getInputStream(manifestEntry); |
| } |
| } else { |
| File manifestFile = new File(bundleLocation, JarFile.MANIFEST_NAME); |
| if (manifestFile.exists()) |
| manifestStream = new BufferedInputStream(new FileInputStream(manifestFile)); |
| } |
| } catch (IOException e) { |
| //ignore but log |
| LogHelper.log(new Status(IStatus.WARNING, Activator.ID, "An error occurred while loading the bundle manifest.", e)); |
| } |
| |
| Dictionary manifest = null; |
| if (manifestStream != null) { |
| try { |
| Map manifestMap = ManifestElement.parseBundleManifest(manifestStream, null); |
| // TODO temporary hack. We are reading a Map but everyone wants a Dictionary so convert. |
| // real answer is to have people expect a Map but that is a wider change. |
| manifest = new Hashtable(manifestMap); |
| } catch (IOException e) { |
| LogHelper.log(new Status(IStatus.ERROR, Activator.ID, "An error occurred while loading the bundle manifest.", e)); |
| return null; |
| } catch (BundleException e) { |
| LogHelper.log(new Status(IStatus.ERROR, Activator.ID, "An error occurred while loading the bundle manifest.", e)); |
| return null; |
| } finally { |
| try { |
| if (jarFile != null) |
| jarFile.close(); |
| } catch (IOException e2) { |
| //Ignore |
| } |
| } |
| } else { |
| manifest = convertPluginManifest(bundleLocation, true); |
| } |
| |
| if (manifest == null) |
| return null; |
| |
| //Deal with the pre-3.0 plug-in shape who have a default jar manifest.mf |
| if (manifest.get(org.osgi.framework.Constants.BUNDLE_SYMBOLICNAME) == null) |
| manifest = convertPluginManifest(bundleLocation, true); |
| |
| if (manifest == null) |
| return null; |
| // if the bundle itself does not define its shape, infer the shape from the current form |
| if (manifest.get(BUNDLE_SHAPE) == null) |
| manifest.put(BUNDLE_SHAPE, bundleLocation.isDirectory() ? DIR : JAR); |
| getManifestLocalizations(manifest, bundleLocation); |
| // localizeManifest(manifest, bundleLocation); |
| return manifest; |
| } |
| |
| // private Properties loadProperties(File bundleLocation, String localizationFile) throws IOException { |
| // Properties result = new Properties(); |
| // InputStream propertyStream = null; |
| // try { |
| // try { |
| // if (bundleLocation.isDirectory()) |
| // propertyStream = new FileInputStream(new File(bundleLocation, localizationFile)); |
| // else { |
| // URLConnection connection = new URL("jar:" + bundleLocation.toURL().toExternalForm() + "!/" + localizationFile).openConnection(); //$NON-NLS-1$ //$NON-NLS-2$ |
| // connection.setUseCaches(false); |
| // propertyStream = connection.getInputStream(); |
| // } |
| // } catch (FileNotFoundException e) { |
| // // if there is no messages file then just return; |
| // return result; |
| // } |
| // result.load(propertyStream); |
| // } finally { |
| // if (propertyStream != null) |
| // propertyStream.close(); |
| // } |
| // return result; |
| // } |
| |
| // Collect the manifest localizations from the bundle directory |
| // and store them in the manifest. |
| private static void getManifestLocalizations(Dictionary manifest, File bundleLocation) { |
| // Map localizations; |
| // Locale defaultLocale = null; // = Locale.ENGLISH; // TODO: get this from GeneratorInfo |
| // String bundleLocalization = (String) manifest.get(Constants.BUNDLE_LOCALIZATION); |
| // if (bundleLocalization == null || bundleLocalization.trim().length() == 0) |
| // bundleLocalization = DEFAULT_BUNDLE_LOCALIZATION; |
| // |
| // if ("jar".equalsIgnoreCase(new Path(bundleLocation.getName()).getFileExtension()) && //$NON-NLS-1$ |
| // bundleLocation.isFile()) { |
| // localizations = getJarManifestLocalization(bundleLocation, bundleLocalization, manifest, defaultLocale); |
| // } else { |
| // localizations = getDirManifestLocalization(bundleLocation, bundleLocalization, manifest, defaultLocale); |
| // } |
| // |
| // if (localizations.size() > 0) { |
| // manifest.put(MANIFEST_LOCALIZATIONS, localizations); |
| // } |
| } |
| |
| // private Map getJarManifestLocalization(File bundleLocation, String bundleLocalization, Dictionary manifest, Locale defaultLocale) { |
| // ZipFile jarFile = null; |
| // Map localizations = new HashMap(4); |
| // try { |
| // jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ); |
| // for (Enumeration entries = jarFile.entries(); entries.hasMoreElements();) { |
| // ZipEntry nextEntry = (ZipEntry) entries.nextElement(); |
| // String nextName = nextEntry.getName(); |
| // String localeString = getLocaleString(nextName, bundleLocalization); |
| // |
| // if (!nextEntry.isDirectory() && localeString != null) { |
| // Locale nextLocale = getLocale(localeString); |
| // InputStream stream = null; |
| // try { |
| // stream = jarFile.getInputStream(nextEntry); |
| // Properties properties = new Properties(); |
| // properties.load(stream); |
| // Properties localizedStrings = getLocalizedProperties(manifest, properties); |
| // if (localizedStrings.size() > 0) { |
| // localizations.put(nextLocale, localizedStrings); |
| // if (DEFAULT_LOCALE.equals(nextLocale) && defaultLocale != null) { |
| // localizations.put(nextLocale, localizedStrings); |
| // } |
| // } |
| // } finally { |
| // if (stream != null) |
| // stream.close(); |
| // } |
| // } |
| // } |
| // } catch (IOException ioe) { |
| // ioe.printStackTrace(); |
| // } finally { |
| // if (jarFile != null) { |
| // try { |
| // jarFile.close(); |
| // } catch (IOException ioe) { |
| // // do nothing |
| // } |
| // } |
| // } |
| // |
| // return localizations; |
| // } |
| // |
| // private Map getDirManifestLocalization(File bundleLocation, String bundleLocalization, Dictionary manifest, Locale defaultLocale) { |
| // File localizationPath = new File(bundleLocation, bundleLocalization); |
| // File localizationDir = localizationPath.getParentFile(); |
| // String localizationFile = localizationPath.getName(); |
| // String[] localizationFiles = localizationDir.list(new LocalizationFileFilter(localizationFile)); |
| // |
| // HashMap localizations = null; |
| // |
| // if (localizationFiles != null) { |
| // localizations = new HashMap(localizationFiles.length); |
| // for (int i = 0; i < localizationFiles.length; i++) { |
| // String nextFile = localizationFiles[i]; |
| // Locale nextLocale = getLocale(getLocaleString(nextFile, localizationFile)); |
| // |
| // try { |
| // Properties properties = loadProperties(bundleLocation, nextFile); |
| // Properties localizedStrings = getLocalizedProperties(manifest, properties); |
| // if (localizedStrings.size() > 0) { |
| // localizations.put(nextLocale, localizedStrings); |
| // if (DEFAULT_LOCALE.equals(nextLocale) && defaultLocale != null) { |
| // localizations.put(nextLocale, localizedStrings); |
| // } |
| // } |
| // } catch (IOException ioe) { |
| // ioe.printStackTrace(); |
| // } |
| // } |
| // } |
| // |
| // return localizations; |
| // } |
| |
| // private class LocalizationFileFilter implements FilenameFilter { |
| // |
| // String filenamePrefix; |
| // |
| // public LocalizationFileFilter(String filenamePrefix) { |
| // this.filenamePrefix = filenamePrefix; |
| // } |
| // |
| // /* (non-Javadoc) |
| // * @see java.io.FilenameFilter#accept(java.io.File, java.lang.String) |
| // */ |
| // public boolean accept(File directory, String filename) { |
| // return (getLocaleString(filename, filenamePrefix) != null ? true : false); |
| // } |
| // } |
| |
| // static public String getLocaleString(String filename, String filenamePrefix) { |
| // String localeString = null; |
| // if (filename.startsWith(filenamePrefix) && filename.endsWith(PROPERTIES_FILE_EXTENSION)) { |
| // if (filename.length() > filenamePrefix.length() + PROPERTIES_FILE_EXTENSION.length()) { |
| // localeString = filename.substring(filenamePrefix.length() + 1, filename.length() - PROPERTIES_FILE_EXTENSION.length()); |
| // } else { |
| // localeString = ""; //$NON-NLS-1$ |
| // } |
| // } |
| // return localeString; |
| // } |
| |
| // static private Locale getLocale(String localeString) { |
| // Locale locale = DEFAULT_LOCALE; |
| // if (localeString.length() == 5 && localeString.indexOf('_') == 2) { |
| // locale = new Locale(localeString.substring(0, 2), localeString.substring(3, 5)); |
| // } else if (localeString.length() == 2) { |
| // locale = new Locale(localeString.substring(0, 2)); |
| // } |
| // return locale; |
| // } |
| // |
| // static private Properties getLocalizedProperties(Dictionary manifest, Properties properties) { |
| // // Walk over the manifest and find all %xxx with the string value |
| // // in the properties file and copy them to the localized properties. |
| // Properties localizedProperties = new Properties(); |
| // for (Enumeration e = manifest.keys(); e.hasMoreElements();) { |
| // String key = (String) e.nextElement(); |
| // Object value = manifest.get(key); |
| // if (value instanceof String) { |
| // String stringValue = (String) value; |
| // if (stringValue.startsWith("%")) { //$NON-NLS-1$ |
| // String newValue = properties.getProperty(stringValue.substring(1)); |
| // if (newValue != null) |
| // localizedProperties.put(key, newValue); |
| // } |
| // } |
| // } |
| // return localizedProperties; |
| // } |
| |
| } |
