| /******************************************************************************* |
| * Copyright (c) 2006, 2007 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 |
| * Chris Aniszczyk (IBM Corp.) - NL-enabled the site optimizer |
| *******************************************************************************/ |
| package org.eclipse.update.internal.provisional; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.jar.JarFile; |
| import java.util.jar.JarOutputStream; |
| import java.util.zip.ZipEntry; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPlatformRunnable; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.update.core.IIncludedFeatureReference; |
| import org.eclipse.update.core.IncludedFeatureReference; |
| import org.eclipse.update.core.model.DefaultSiteParser; |
| import org.eclipse.update.core.model.FeatureModel; |
| import org.eclipse.update.core.model.FeatureModelFactory; |
| import org.eclipse.update.core.model.FeatureReferenceModel; |
| import org.eclipse.update.core.model.ImportModel; |
| import org.eclipse.update.core.model.PluginEntryModel; |
| import org.eclipse.update.core.model.SiteModel; |
| import org.eclipse.update.core.model.URLEntryModel; |
| import org.eclipse.update.internal.core.ExtendedSiteURLFactory; |
| import org.eclipse.update.internal.core.Messages; |
| import org.eclipse.update.internal.core.UpdateCore; |
| import org.eclipse.update.internal.core.UpdateManagerUtils; |
| import org.eclipse.update.internal.jarprocessor.JarProcessor; |
| import org.eclipse.update.internal.jarprocessor.JarProcessorExecutor; |
| import org.eclipse.update.internal.jarprocessor.Main; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * The application class used to perform update site optimizations. |
| * <p> |
| * This class can only be referenced from <code>org.eclipse.runtime.applications</code> |
| * extension point. It should not be extended or instantiated. |
| * <p> |
| * <b>Note:</b> This class/interface is part of an interim API that is still |
| * under development and expected to change significantly before reaching |
| * stability. It is being made available at this early stage to solicit feedback |
| * from pioneering adopters on the understanding that any code that uses this |
| * API will almost certainly be broken (repeatedly) as the API evolves. |
| * </p> |
| * |
| * @since 3.2 |
| */ |
| public class SiteOptimizerApplication implements IPlatformRunnable { |
| public final static Integer EXIT_ERROR = new Integer(1); |
| |
| public final static String JAR_PROCESSOR = "-jarProcessor"; //$NON-NLS-1$ |
| |
| public final static String DIGEST_BUILDER = "-digestBuilder"; //$NON-NLS-1$ |
| |
| public final static String INPUT = "input"; //$NON-NLS-1$ |
| |
| public final static String OUTPUT_DIR = "-outputDir"; //$NON-NLS-1$ |
| |
| public final static String VERBOSE = "-verbose"; //$NON-NLS-1$ |
| |
| public final static String JAR_PROCESSOR_PACK = "-pack"; //$NON-NLS-1$ |
| |
| public final static String JAR_PROCESSOR_UNPACK = "-unpack"; //$NON-NLS-1$ |
| |
| public final static String JAR_PROCESSOR_REPACK = "-repack"; //$NON-NLS-1$ |
| |
| public final static String JAR_PROCESSOR_SIGN = "-sign"; //$NON-NLS-1$ |
| |
| public final static String JAR_PROCESSOR_PROCESS_ALL = "-processAll"; //$NON-NLS-1$ |
| |
| public final static String SITE_XML = "-siteXML"; //$NON-NLS-1$ |
| |
| public final static String SITE_ATTRIBUTES_FILE = "siteAttributes.txt"; //$NON-NLS-1$ |
| |
| public final static String DIGEST_OUTPUT_DIR = "-digestOutputDir"; //$NON-NLS-1$ |
| |
| /* |
| * private final static String DESCRIPTION = "DESCRIPTION"; private final |
| * static String LICENCE = "LICENCE"; private final static String COPYRIGHT = |
| * "COPYRIGHT"; private final static String FEATURE_LABEL = "FEATURE_LABEL"; |
| */ |
| |
| /** |
| * Parses the command line in the form: [-key [value]]* [inputvalue] If the |
| * last argument does not start with a "-" then it is taken as the input |
| * value and not the value for a preceding -key |
| * |
| * @param args |
| * @return |
| */ |
| private Map parseCmdLine(String[] args) { |
| Map cmds = new HashMap(); |
| for (int i = 0; i < args.length; i++) { |
| if (i == args.length - 1 && !args[i].startsWith("-")) { //$NON-NLS-1$ |
| cmds.put(INPUT, args[i]); |
| } else { |
| String key = args[i]; |
| String val = null; |
| if (i < args.length - 2 && !args[i + 1].startsWith("-")) { //$NON-NLS-1$ |
| val = args[++i]; |
| } |
| |
| if (key.startsWith(SITE_XML)) { |
| // System.out.println(val.indexOf(":null")); |
| val = key.substring(key.indexOf("=") + 1); //$NON-NLS-1$ |
| // System.out.println(key + ":" + val); |
| cmds.put(SITE_XML, val); |
| } else if (key.startsWith(DIGEST_OUTPUT_DIR)) { |
| val = key.substring(key.indexOf("=") + 1); //$NON-NLS-1$ |
| // System.out.println(key + ":" + val); |
| cmds.put(DIGEST_OUTPUT_DIR, val); |
| } else { |
| |
| // System.out.println(key + ":" + val); |
| cmds.put(key, val); |
| } |
| } |
| } |
| return cmds; |
| } |
| |
| private boolean runJarProcessor(Map params) { |
| Main.Options options = new Main.Options(); |
| options.pack = params.containsKey(JAR_PROCESSOR_PACK); |
| options.unpack = params.containsKey(JAR_PROCESSOR_UNPACK); |
| options.repack = params.containsKey(JAR_PROCESSOR_REPACK); |
| options.processAll = params.containsKey(JAR_PROCESSOR_PROCESS_ALL); |
| options.verbose = params.containsKey(VERBOSE); |
| options.signCommand = (String) params.get(JAR_PROCESSOR_SIGN); |
| options.outputDir = (String) params.get(OUTPUT_DIR); |
| |
| String problem = null; |
| |
| String input = (String) params.get(INPUT); |
| if (input == null) |
| problem = Messages.SiteOptimizer_inputNotSpecified; |
| else { |
| File inputFile = new File(input); |
| if (inputFile.exists()) |
| options.input = inputFile; |
| else |
| problem = NLS.bind(Messages.SiteOptimizer_inputFileNotFound, |
| new String[] { input }); |
| } |
| |
| if (options.unpack) { |
| if (!JarProcessor.canPerformUnpack()) { |
| problem = Messages.JarProcessor_unpackNotFound; |
| } else if (options.pack || options.repack |
| || options.signCommand != null) { |
| problem = Messages.JarProcessor_noPackUnpack; |
| } |
| } else if ((options.pack || options.repack) |
| && !JarProcessor.canPerformPack()) { |
| problem = Messages.JarProcessor_packNotFound; |
| } |
| |
| if (problem != null) { |
| System.out.println(problem); |
| return false; |
| } |
| |
| new JarProcessorExecutor().runJarProcessor(options); |
| return true; |
| } |
| |
| private boolean runDigestBuilder(Map params) { |
| |
| List featureList = getFeatureList(params); |
| |
| if ((featureList == null) || featureList.isEmpty()) { |
| System.out.println("no features to process"); //$NON-NLS-1$ |
| return false; |
| } |
| Map perFeatureLocales = new HashMap(); |
| Map availableLocales = getAvailableLocales(featureList, |
| perFeatureLocales); |
| try { |
| openInputStremas(availableLocales); |
| } catch (IOException e1) { |
| e1.printStackTrace(); |
| System.out.println("Can not create file in output direcotry"); //$NON-NLS-1$ |
| return false; |
| } |
| |
| for(int i = 0; i < featureList.size(); i++) { |
| |
| String featureJarFileName = (String) featureList.get(i); |
| |
| if (featureJarFileName.endsWith("jar")) { //$NON-NLS-1$ |
| System.out.println("Processing... " + featureJarFileName); //$NON-NLS-1$ |
| } else { |
| System.out.println("Skipping... " + featureJarFileName); //$NON-NLS-1$ |
| continue; |
| } |
| |
| JarFile featureJar = null; |
| try { |
| featureJar = new JarFile(featureJarFileName); |
| } catch (IOException e) { |
| System.out.println("Problem with opening jar: " //$NON-NLS-1$ |
| + featureJarFileName); |
| e.printStackTrace(); |
| return false; |
| } |
| FeatureModelFactory fmf = new FeatureModelFactory(); |
| |
| try { |
| ZipEntry featureXMLEntry = featureJar.getEntry("feature.xml"); //$NON-NLS-1$ |
| Map featureProperties = loadProperties(featureJar, |
| featureJarFileName, perFeatureLocales); |
| |
| FeatureModel featureModel = fmf.parseFeature(featureJar |
| .getInputStream(featureXMLEntry)); |
| |
| featureList = addFeaturesToList( (String) params.get(SITE_XML), featureList, featureModel.getFeatureIncluded(), availableLocales, perFeatureLocales); |
| |
| Iterator availableLocalesIterator = availableLocales.values() |
| .iterator(); |
| while (availableLocalesIterator.hasNext()) { |
| ((AvailableLocale) availableLocalesIterator.next()) |
| .writeFeatureDigests(featureModel, |
| featureProperties); |
| } |
| |
| } catch (SAXException e) { |
| e.printStackTrace(); |
| return false; |
| } catch (IOException e) { |
| e.printStackTrace(); |
| return false; |
| } catch (CoreException e) { |
| e.printStackTrace(); |
| return false; |
| } |
| } |
| Iterator availableLocalesIterator = availableLocales.values() |
| .iterator(); |
| String outputDirectory = (String) params.get(DIGEST_OUTPUT_DIR); |
| |
| outputDirectory = outputDirectory.substring(outputDirectory |
| .indexOf("=") + 1); //$NON-NLS-1$ |
| if (!outputDirectory.endsWith(File.separator)) { |
| outputDirectory = outputDirectory + File.separator; |
| } |
| while (availableLocalesIterator.hasNext()) { |
| try { |
| ((AvailableLocale) availableLocalesIterator.next()) |
| .finishDigest(outputDirectory); |
| } catch (IOException e) { |
| System.out.println("Can not write in digest output directory: " //$NON-NLS-1$ |
| + outputDirectory); |
| e.printStackTrace(); |
| return false; |
| } |
| } |
| System.out.println("Done"); //$NON-NLS-1$ |
| return true; |
| } |
| |
| private List addFeaturesToList( String siteXML, List featureList, IIncludedFeatureReference[] iIncludedFeatureReferences, Map availableLocales, Map perFeatureLocales ) throws CoreException { |
| |
| String directoryName = (new File(siteXML)).getParent(); |
| if (!directoryName.endsWith(File.separator)) { |
| directoryName = directoryName + File.separator; |
| } |
| directoryName = directoryName + "features" + File.separator; //$NON-NLS-1$ |
| |
| for (int i = 0; i < iIncludedFeatureReferences.length; i++) { |
| String featureURL = directoryName + iIncludedFeatureReferences[i].getVersionedIdentifier() + ".jar"; //$NON-NLS-1$ |
| if (!(isFeatureAlreadyInList(featureList, featureURL))) { |
| try { |
| System.out.println("Extracting locales from included feature " + featureURL); //$NON-NLS-1$ |
| processLocalesInJar(availableLocales, featureURL, perFeatureLocales, true); |
| } catch (IOException e) { |
| if (iIncludedFeatureReferences[i].isOptional()) |
| continue; |
| System.out.println("Error while extracting locales from included feature " + featureURL);//$NON-NLS-1$ |
| e.printStackTrace(); |
| throw new CoreException( new Status( IStatus.ERROR, UpdateCore.getPlugin().getBundle().getSymbolicName(), IStatus.OK, "Error while extracting locales from included feature " + featureURL, e)); //$NON-NLS-1$ |
| } |
| featureList.add(featureURL); |
| } |
| } |
| |
| return featureList; |
| } |
| |
| private boolean isFeatureAlreadyInList(List featureList, String featureURL) { |
| for (int i = 0; i < featureList.size(); i++) { |
| String currentFeatureURL = (String)featureList.get(i); |
| if (currentFeatureURL.equals(featureURL)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private Map loadProperties(JarFile featureJar, String featureJarFileName, |
| Map perFeatureLocales) { |
| // System.out.println( |
| // ((List)perFeatureLocales.get(featureJarFileName)).size()); |
| Iterator it = ((List) perFeatureLocales.get(featureJarFileName)) |
| .iterator(); |
| Map result = new HashMap(); |
| while (it.hasNext()) { |
| String propertyFileName = (String) it.next(); |
| |
| ZipEntry featurePropertiesEntry = featureJar |
| .getEntry(propertyFileName); |
| Properties featureProperties = new Properties(); |
| if (featurePropertiesEntry != null) { |
| try { |
| featureProperties.load(featureJar |
| .getInputStream(featurePropertiesEntry)); |
| String localeString = null; |
| if (propertyFileName.endsWith("feature.properties")) { //$NON-NLS-1$ |
| localeString = ""; //$NON-NLS-1$ |
| } else { |
| localeString = propertyFileName.substring(8, |
| propertyFileName.indexOf('.')); |
| } |
| result.put(localeString, featureProperties); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private void openInputStremas(Map availableLocales) throws IOException { |
| Iterator locales = availableLocales.values().iterator(); |
| while (locales.hasNext()) { |
| AvailableLocale availableLocale = (AvailableLocale) locales.next(); |
| availableLocale.openLocalizedOutputStream(); |
| } |
| } |
| |
| private Map getAvailableLocales(List featureList, Map perFeatureLocales) { |
| Iterator features = featureList.iterator(); |
| Map locales = new HashMap(); |
| while (features.hasNext()) { |
| String feature = (String) features.next(); |
| try { |
| System.out.println("Extracting locales from " + feature); //$NON-NLS-1$ |
| processLocalesInJar(locales, feature, perFeatureLocales, false); |
| } catch (IOException e) { |
| System.out.println("Error while extracting locales from " //$NON-NLS-1$ |
| + feature); |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| return locales; |
| } |
| |
| private void processLocalesInJar(Map locales, String feature, |
| Map perFeatureLocales, boolean ignoreNewLocales) throws IOException { |
| |
| JarFile jar = new JarFile(feature); |
| // System.out.println(feature); |
| Enumeration files = jar.entries(); |
| |
| List localesTemp = new ArrayList(); |
| perFeatureLocales.put(feature, localesTemp); |
| |
| while (files.hasMoreElements()) { |
| ZipEntry file = (ZipEntry) files.nextElement(); |
| String localeString = null; |
| String name = file.getName(); |
| // System.out.println("processLocalesInJar:"+name); |
| if (name.startsWith("feature") && name.endsWith(".properties")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| // System.out.println(name); |
| localesTemp.add(name); |
| // System.out.println(name); |
| if (name.endsWith("feature.properties")) { //$NON-NLS-1$ |
| localeString = ""; //$NON-NLS-1$ |
| } else { |
| localeString = name.substring(8, name.indexOf('.')); |
| } |
| // System.out.println(name +"::::\"" + localeString + "\""); |
| if ( !ignoreNewLocales && !locales.containsKey(localeString)) { |
| locales.put(localeString, new AvailableLocale(localeString)); |
| } |
| if (locales.containsKey(localeString)) { |
| AvailableLocale currentLocale = (AvailableLocale) locales.get(localeString); |
| currentLocale.addFeatures(feature); |
| } |
| } |
| } |
| |
| } |
| |
| private List getFeatureList(Map params) { |
| if (params.containsKey(SITE_XML) |
| && (fileExists((String) params.get(SITE_XML)))) { |
| return getFeatureListFromSiteXML((String) params.get(SITE_XML)); |
| } else if (params.containsKey(INPUT) |
| && isDirectory((String) params |
| .get(SiteOptimizerApplication.INPUT))) { |
| return getFeatureListFromDirectory((String) params.get(INPUT)); |
| } |
| return null; |
| } |
| |
| private boolean fileExists(String fileName) { |
| // System.out.println("fileExists:"+fileName); |
| File file = new File(fileName); |
| if ((file != null) && file.exists()) |
| return true; |
| return false; |
| } |
| |
| private List getFeatureListFromDirectory(String directoryName) { |
| List featuresURLs = new ArrayList(); |
| File directory = new File(directoryName); |
| String[] featureJarFileNames = directory.list(); |
| for (int i = 0; i < featureJarFileNames.length; i++) { |
| featuresURLs.add(directoryName + File.separator |
| + featureJarFileNames[i]); |
| } |
| return featuresURLs; |
| } |
| |
| private boolean isDirectory(String fileName) { |
| |
| File directory = new File(fileName); |
| if ((directory != null) && directory.exists() |
| && directory.isDirectory()) |
| return true; |
| return false; |
| } |
| |
| private List getFeatureListFromSiteXML(String siteXML) { |
| |
| List featuresURLs = new ArrayList(); |
| String directoryName = (new File(siteXML)).getParent(); |
| if (!directoryName.endsWith(File.separator)) { |
| directoryName = directoryName + File.separator; |
| } |
| |
| DefaultSiteParser siteParser = new DefaultSiteParser(); |
| siteParser.init(new ExtendedSiteURLFactory()); |
| |
| try { |
| SiteModel site = siteParser.parse(new FileInputStream(siteXML)); |
| if(site.getFeatureReferenceModels().length > 0) { |
| site.getFeatureReferenceModels()[0].getURLString(); |
| FeatureReferenceModel[] featureReferenceModel = site |
| .getFeatureReferenceModels(); |
| for (int i = 0; i < featureReferenceModel.length; i++) { |
| featuresURLs.add(directoryName |
| + featureReferenceModel[i].getURLString()); |
| } |
| } |
| return featuresURLs; |
| } catch (FileNotFoundException e) { |
| System.out.println("File not found: " + e.getMessage()); //$NON-NLS-1$ |
| e.printStackTrace(); |
| } catch (SAXException e) { |
| System.out.println("Parsing problem: " + e.getMessage()); //$NON-NLS-1$ |
| e.printStackTrace(); |
| } catch (IOException e) { |
| System.out.println("Problem while parsing: " + e.getMessage()); //$NON-NLS-1$ |
| e.printStackTrace(); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.runtime.IPlatformRunnable#run(java.lang.Object) |
| */ |
| public Object run(Object args) throws Exception { |
| Platform.endSplash(); |
| if (args == null) |
| return EXIT_ERROR; |
| if (args instanceof String[]) { |
| Map params = parseCmdLine((String[]) args); |
| if (params.containsKey(JAR_PROCESSOR)) { |
| if (!runJarProcessor(params)) |
| return EXIT_ERROR; |
| } |
| |
| if (params.containsKey(DIGEST_BUILDER)) { |
| if (!runDigestBuilder(params)) |
| return EXIT_ERROR; |
| } |
| } |
| return IPlatformRunnable.EXIT_OK; |
| } |
| |
| private class AvailableLocale { |
| |
| private String PREFIX = "temp"; //$NON-NLS-1$ |
| |
| private String locale; |
| |
| private Map /* VersionedIdentifier */features = new HashMap(); |
| |
| private PrintWriter localizedPrintWriter; |
| |
| private File tempDigestDirectory; |
| |
| public void finishDigest(String outputDirectory) throws IOException { |
| localizedPrintWriter.println("</digest>"); //$NON-NLS-1$ |
| if (localizedPrintWriter != null) { |
| localizedPrintWriter.close(); |
| } |
| |
| File digest = new File(outputDirectory + File.separator + "digest" //$NON-NLS-1$ |
| + (locale == null || locale.equals("") ? "" : "_"+locale) + ".zip"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| System.out.println(digest.getAbsolutePath()); |
| System.out.println(digest.getName()); |
| if (digest.exists()) { |
| digest.delete(); |
| } |
| digest.createNewFile(); |
| OutputStream os = new FileOutputStream(digest); |
| JarOutputStream jos = new JarOutputStream(os); |
| jos.putNextEntry(new ZipEntry("digest.xml")); //$NON-NLS-1$ |
| InputStream is = new FileInputStream(tempDigestDirectory); |
| byte[] b = new byte[4096]; |
| int bytesRead = 0; |
| do { |
| bytesRead = is.read(b); |
| if (bytesRead > 0) { |
| jos.write(b, 0, bytesRead); |
| } |
| } while (bytesRead > 0); |
| |
| jos.closeEntry(); |
| jos.close(); |
| os.close(); |
| is.close(); |
| tempDigestDirectory.delete(); |
| |
| } |
| |
| public AvailableLocale(String locale) { |
| this.locale = locale; |
| } |
| |
| public void addFeatures(String feature) { |
| features.put(feature, feature); |
| } |
| |
| public void openLocalizedOutputStream() throws IOException { |
| tempDigestDirectory = File.createTempFile(PREFIX, null); |
| FileOutputStream fstream = new FileOutputStream(tempDigestDirectory); |
| localizedPrintWriter = new PrintWriter(new OutputStreamWriter(fstream, "UTF-8")); //$NON-NLS-1$ |
| localizedPrintWriter |
| .println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <digest>"); //$NON-NLS-1$ |
| tempDigestDirectory.deleteOnExit(); |
| } |
| |
| public int hashCode() { |
| return locale.hashCode(); |
| } |
| |
| public boolean equals(Object obj) { |
| |
| if (this == obj) |
| return true; |
| if (obj == null) |
| return false; |
| if (getClass() != obj.getClass()) |
| return false; |
| final AvailableLocale other = (AvailableLocale) obj; |
| if (locale == null) { |
| if (other.locale != null) |
| return false; |
| } else if (!locale.equals(other.locale)) |
| return false; |
| return true; |
| } |
| |
| public void writeFeatureDigests(FeatureModel featureModel, |
| Map featureProperties) { |
| |
| if (this.locale.equals("")) { //$NON-NLS-1$ |
| writeFeatureDigest(localizedPrintWriter, featureModel, |
| (Properties) featureProperties.get("")); //$NON-NLS-1$ |
| return; |
| } |
| Properties temp = new Properties(); |
| if (locale.indexOf("_") < 0) { //$NON-NLS-1$ |
| temp = combineProperties( |
| (Properties) featureProperties.get(""), //$NON-NLS-1$ |
| (Properties) featureProperties.get(locale), null); |
| writeFeatureDigest(localizedPrintWriter, featureModel, temp); |
| } else { |
| temp = combineProperties( |
| (Properties) featureProperties.get(""), //$NON-NLS-1$ |
| (Properties) featureProperties.get(locale.substring(0, locale.indexOf("_"))), //$NON-NLS-1$ |
| (Properties) featureProperties.get(locale) ); |
| writeFeatureDigest(localizedPrintWriter, featureModel, temp); |
| } |
| |
| } |
| |
| /** |
| * @param defaults Should be lang_country |
| * @param secondary Should be lang |
| * @param preferred Should be default |
| * @return |
| */ |
| |
| private Properties combineProperties(Properties defaults, |
| Properties secondary, Properties preferred) { |
| return new CombinedProperties(preferred, secondary, defaults); |
| |
| } |
| |
| } |
| |
| public static void writeFeatureDigest(PrintWriter digest, |
| FeatureModel featureModel, Properties featureProperties) { |
| |
| String label = null; |
| String provider = null; |
| String description = null; |
| String license = null; |
| String copyright = null; |
| |
| if ((featureProperties != null) |
| && featureModel.getLabel().startsWith("%")) { //$NON-NLS-1$ |
| label = featureProperties.getProperty(featureModel.getLabel() |
| .substring(1)); |
| } else { |
| label = featureModel.getLabel(); |
| } |
| if ((featureProperties != null) |
| && (featureModel.getDescriptionModel() != null) |
| && (featureModel.getDescriptionModel().getAnnotation() != null) |
| && featureModel.getDescriptionModel().getAnnotation() |
| .startsWith("%")) { //$NON-NLS-1$ |
| // System.out.println(featureProperties.getProperty(featureModel.getDescriptionModel().getAnnotation().substring(1))); |
| description = featureProperties.getProperty(featureModel |
| .getDescriptionModel().getAnnotation().substring(1)); |
| } else { |
| URLEntryModel descriptionModel = featureModel.getDescriptionModel(); |
| if( descriptionModel == null ) |
| description = ""; |
| else |
| description = descriptionModel.getAnnotation(); |
| } |
| String pvalue = featureModel.getProvider(); |
| if ((featureProperties != null) |
| && pvalue!=null && pvalue.startsWith("%")) { //$NON-NLS-1$ |
| provider = featureProperties.getProperty(featureModel.getProvider() |
| .substring(1)); |
| } else { |
| provider = pvalue; |
| } |
| if (provider==null) provider = ""; |
| |
| if (((featureProperties != null) && featureModel.getCopyrightModel() != null) |
| && featureModel.getCopyrightModel().getAnnotation().startsWith( |
| "%")) { //$NON-NLS-1$ |
| copyright = featureProperties.getProperty(featureModel |
| .getCopyrightModel().getAnnotation().substring(1)); |
| } else { |
| if (featureModel.getCopyrightModel() != null) { |
| copyright = featureModel.getCopyrightModel().getAnnotation(); |
| } else { |
| copyright = null; |
| } |
| } |
| |
| if ((featureProperties != null) |
| && (featureModel.getLicenseModel() != null) |
| && featureModel.getLicenseModel().getAnnotation().startsWith( |
| "%")) { //$NON-NLS-1$ |
| license = featureProperties.getProperty(featureModel |
| .getLicenseModel().getAnnotation().substring(1)); |
| } else { |
| license = featureModel.getLicenseModel().getAnnotation(); |
| } |
| |
| digest.print("<feature "); //$NON-NLS-1$ |
| digest.print("label=\"" + getUTF8String(label) + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| digest.print("provider-name=\"" + getUTF8String(provider) + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| digest.print("id=\"" + featureModel.getFeatureIdentifier() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| digest.print("version=\"" + featureModel.getFeatureVersion() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (featureModel.getOS() != null) |
| digest.print("os=\"" + featureModel.getOS() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (featureModel.getNL() != null) |
| digest.print("nl=\"" + featureModel.getNL() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (featureModel.getWS() != null) |
| digest.print("ws=\"" + featureModel.getWS() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (featureModel.getOSArch() != null) |
| digest.print("arch=\"" + featureModel.getOSArch() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (featureModel.isExclusive()) |
| digest.print("exclusive=\"" + featureModel.isExclusive() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| |
| if (((featureModel.getImportModels() == null) || (featureModel |
| .getImportModels().length == 0)) |
| && ((featureModel.getDescriptionModel() == null) |
| || (featureModel.getDescriptionModel().getAnnotation() == null) || (featureModel |
| .getDescriptionModel().getAnnotation().trim().length() == 0)) |
| && ((featureModel.getCopyrightModel() == null) |
| || (featureModel.getCopyrightModel().getAnnotation() == null) || (featureModel |
| .getCopyrightModel().getAnnotation().trim().length() == 0)) |
| && ((featureModel.getLicenseModel() == null) |
| || (featureModel.getLicenseModel().getAnnotation() == null) || (featureModel |
| .getLicenseModel().getAnnotation().trim().length() == 0)) |
| && ((featureModel.getFeatureIncluded() == null) || (featureModel |
| .getFeatureIncluded().length == 0))){ |
| digest.println("/> "); //$NON-NLS-1$ |
| } else { |
| digest.println("> "); //$NON-NLS-1$ |
| if (featureModel.getImportModels().length > 0) { |
| |
| digest.println("\t<requires> "); //$NON-NLS-1$ |
| ImportModel[] imports = featureModel.getImportModels(); |
| for (int j = 0; j < imports.length; j++) { |
| digest.print("\t\t<import "); //$NON-NLS-1$ |
| if (imports[j].isFeatureImport()) { |
| digest.print("feature=\""); //$NON-NLS-1$ |
| } else { |
| digest.print("plugin=\""); //$NON-NLS-1$ |
| } |
| digest.print(imports[j].getIdentifier() + "\" "); //$NON-NLS-1$ |
| digest.print("version=\""); //$NON-NLS-1$ |
| digest.print(imports[j].getVersion() + "\" "); //$NON-NLS-1$ |
| digest.print("match=\""); //$NON-NLS-1$ |
| digest.print(imports[j].getMatchingRuleName() + "\" "); //$NON-NLS-1$ |
| if (imports[j].isPatch()) { |
| digest.print("patch=\"true\" "); //$NON-NLS-1$ |
| } |
| digest.println(" />"); //$NON-NLS-1$ |
| } |
| |
| digest.println("\t</requires>"); //$NON-NLS-1$ |
| |
| } |
| |
| if ((featureModel.getDescriptionModel() != null) |
| && (featureModel.getDescriptionModel().getAnnotation() != null) |
| && (featureModel.getDescriptionModel().getAnnotation() |
| .trim().length() != 0)) { |
| digest.println("\t<description>"); //$NON-NLS-1$ |
| digest.println("\t\t" + UpdateManagerUtils.getWritableXMLString(description)); //$NON-NLS-1$ |
| digest.println("\t</description>"); //$NON-NLS-1$ |
| } |
| |
| if (featureModel.getCopyrightModel() != null) { |
| if (featureModel.getCopyrightModel().getAnnotation() != null) { |
| // if |
| // (featureModel.getDescriptionModel().getAnnotation().length() |
| // != 0) { |
| digest.println("\t<copyright>"); //$NON-NLS-1$ |
| digest.println("\t\t" + UpdateManagerUtils.getWritableXMLString(copyright)); //$NON-NLS-1$ |
| digest.println("\t</copyright>"); //$NON-NLS-1$ |
| // } |
| } |
| } |
| |
| if ((featureModel.getLicenseModel() != null) |
| && (featureModel.getLicenseModel().getAnnotation() != null) |
| && (featureModel.getLicenseModel().getAnnotation() |
| .trim().length() != 0)) { |
| digest.println("\t<license>"); //$NON-NLS-1$ |
| digest.println("\t\t" + UpdateManagerUtils.getWritableXMLString(license)); //$NON-NLS-1$ |
| digest.println("\t</license>"); //$NON-NLS-1$ |
| } |
| |
| PluginEntryModel[] plugins = featureModel.getPluginEntryModels(); |
| if ((plugins != null) && (plugins.length != 0)) { |
| for (int i = 0; i < plugins.length; i++) { |
| digest.print("\t<plugin "); //$NON-NLS-1$ |
| digest.print("id=\"" + plugins[i].getPluginIdentifier() //$NON-NLS-1$ |
| + "\" "); //$NON-NLS-1$ |
| digest.print("version=\"" + plugins[i].getPluginVersion() //$NON-NLS-1$ |
| + "\" "); //$NON-NLS-1$ |
| if (plugins[i].getOS() != null) |
| digest.print("os=\"" + plugins[i].getOS() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (plugins[i].getNL() != null) |
| digest.print("nl=\"" + plugins[i].getNL() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (plugins[i].getWS() != null) |
| digest.print("ws=\"" + plugins[i].getWS() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (plugins[i].getOSArch() != null) |
| digest |
| .print("arch=\"" + plugins[i].getOSArch() //$NON-NLS-1$ |
| + "\" "); //$NON-NLS-1$ |
| if (plugins[i].getDownloadSize() > 0) |
| digest.print("download-size=\"" //$NON-NLS-1$ |
| + plugins[i].getDownloadSize() + "\" "); //$NON-NLS-1$ |
| if (plugins[i].getInstallSize() > 0) |
| digest.print("install-size=\"" //$NON-NLS-1$ |
| + plugins[i].getInstallSize() + "\" "); //$NON-NLS-1$ |
| if (!plugins[i].isUnpack()) |
| digest.print("unpack=\"" + plugins[i].isUnpack() //$NON-NLS-1$ |
| + "\" "); //$NON-NLS-1$ |
| |
| digest.println("/> "); //$NON-NLS-1$ |
| } |
| } |
| |
| IIncludedFeatureReference[] includedFeatures = featureModel.getFeatureIncluded(); |
| |
| if ((includedFeatures != null) && (includedFeatures.length != 0)) { |
| for (int i = 0; i < includedFeatures.length; i++) { |
| try { |
| digest.print("\t<includes "); //$NON-NLS-1$ |
| |
| digest.print("id=\"" + includedFeatures[i].getVersionedIdentifier().getIdentifier() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| digest.print("version=\"" + includedFeatures[i].getVersionedIdentifier().getVersion() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (includedFeatures[i].getOS() != null) |
| digest.print("os=\"" + includedFeatures[i].getOS() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (includedFeatures[i].getNL() != null) |
| digest.print("nl=\"" + includedFeatures[i].getNL() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (includedFeatures[i].getWS() != null) |
| digest.print("ws=\"" + includedFeatures[i].getWS() + "\" "); //$NON-NLS-1$//$NON-NLS-2$ |
| if (includedFeatures[i].getOSArch() != null) |
| digest.print("arch=\"" + includedFeatures[i].getOSArch() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if ( (includedFeatures[i] instanceof IncludedFeatureReference) && (((IncludedFeatureReference)includedFeatures[i]).getLabel() != null)) |
| digest.print("name=\"" + includedFeatures[i].getName() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (includedFeatures[i].isOptional()) |
| digest.print("optional=\"true\" "); //$NON-NLS-1$ |
| digest.print("search-location=\"" + includedFeatures[i].getSearchLocation() + "\" "); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| digest.println("/> "); //$NON-NLS-1$ |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| digest.println("</feature>"); //$NON-NLS-1$ |
| } |
| } |
| |
| private class CombinedProperties extends Properties { |
| |
| private Properties properties1; |
| |
| private Properties properties2; |
| |
| private Properties properties3; |
| |
| /** |
| * @param preferred preferred, such as lang_country |
| * @param secondary secondary, such as lang |
| * @param defaults default, |
| */ |
| public CombinedProperties(Properties preferred, |
| Properties secondary, Properties defaults) { |
| this.properties1 = preferred; |
| this.properties2 = secondary; |
| this.properties3 = defaults; |
| } |
| |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 1L; |
| |
| public String getProperty(String key) { |
| String result = null; |
| if (properties3 != null && properties3.containsKey(key)) |
| result = properties3.getProperty(key); |
| if (properties2 != null && properties2.containsKey(key)) |
| result = properties2.getProperty(key); |
| if (properties1 != null && properties1.containsKey(key)) |
| result = properties1.getProperty(key); |
| return result; |
| } |
| |
| } |
| |
| public static final String getUTF8String(String s) { |
| if(s == null) |
| return ""; |
| return UpdateManagerUtils.getWritableXMLString(s); |
| } |
| |
| } |
