| /******************************************************************************* |
| * Copyright (c) 2011 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.indigo.tests; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.jar.JarEntry; |
| import java.util.jar.JarFile; |
| import java.util.zip.ZipFile; |
| |
| import org.apache.tools.ant.BuildException; |
| import org.eclipse.osgi.util.ManifestElement; |
| import org.osgi.framework.BundleException; |
| |
| /** |
| * Test to check MANIFEST.MF files in jars in a repository for presence of |
| * Eclipse-SourceReferences. |
| * |
| * @since 3.7 |
| */ |
| public class ESTest { |
| |
| private static final Object PROPERTY_ECLIPSE_SOURCEREFERENCES = "Eclipse-SourceReferences"; |
| private static final FullJarNameParser nameParser = new FullJarNameParser(); |
| private static final String outputFilename = "esdata.txt"; |
| private String bundleDirectory = null; |
| |
| public static void main(String[] args) { |
| |
| ESTest testlayout = new ESTest(); |
| testlayout.setDirectoryToCheck("/home/files/buildzips/indigoRC2/eclipseJEE/"); |
| try { |
| testlayout.testESSettingRule(); |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| private String directoryToCheck; |
| private String tempWorkingDir; |
| private String outputDirectory; |
| |
| |
| public String getDirectoryToCheck() { |
| return directoryToCheck; |
| } |
| |
| public void setDirectoryToCheck(String bundleDirToCheck) { |
| this.directoryToCheck = bundleDirToCheck; |
| } |
| |
| public boolean testESSettingRule() throws IOException { |
| |
| File inputdir = new File(getBundleDirectory()); |
| if (!(inputdir.exists() && inputdir.isDirectory())) { |
| throw new BuildException("bundle direcotry (" + getBundleDirectory() + ") must be an existing directory."); |
| } |
| |
| boolean failuresOccured; |
| |
| failuresOccured = checkBundleES(inputdir); |
| |
| return failuresOccured; |
| } |
| |
| private boolean checkBundleES(File inputdir) throws IOException { |
| // reset/initialize errors |
| InputStream propertyStream = this.getClass().getResourceAsStream("exceptions.properties"); |
| Properties esExceptionProperties = new Properties(); |
| String esExceptions = ""; |
| try { |
| esExceptionProperties.load(propertyStream); |
| esExceptions = esExceptionProperties.getProperty("esExceptions"); |
| if (esExceptions == null) { |
| esExceptions = ""; |
| } |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| finally { |
| if (propertyStream != null) { |
| try { |
| propertyStream.close(); |
| } |
| catch (IOException e) { |
| // would be unusual to get here? |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
| Map withEs = new HashMap(); |
| List withoutEs = new ArrayList(); |
| boolean failuresOccured = false; |
| File[] children = inputdir.listFiles(new JARFileNameFilter()); |
| int totalsize = children.length; |
| int checked = 0; |
| int nProjectTags = 0; |
| for (int i = 0; i < totalsize; i++) { |
| File child = children[i]; |
| String name = child.getName(); |
| |
| String bundleName = getBundleName(name); |
| if ((bundleName != null) && !esExceptions.contains(bundleName)) { |
| checked++; |
| String es = getESFromJAR(child); |
| if ((es != null) && es.contains("project=")) { |
| nProjectTags++; |
| } |
| if ((es != null) && (es.length() > 0)) { |
| // has ES |
| incrementCounts(withEs, es); |
| } |
| else { |
| // no ES |
| trackOmissions(withoutEs, child); |
| } |
| } |
| } |
| printreport(withEs, withoutEs, totalsize, checked, nProjectTags); |
| |
| return failuresOccured; |
| } |
| |
| private void printreport(Map withEs, List withoutESs, int totalsize, int checked, int nProjectTags) throws IOException { |
| |
| |
| ReportWriter reportWriter = new ReportWriter(getOutputDirectory(), outputFilename); |
| try { |
| reportWriter.writeln(); |
| reportWriter.writeln(" Directory checked: " + getBundleDirectory()); |
| reportWriter.writeln(" Checked " + checked + " of " + totalsize + " jars."); |
| reportWriter.writeln(); |
| reportWriter.writeln(); |
| reportWriter.writeln(" Number of bundles with an Eclipse-SourceReferences: " + totalCount(withEs)); |
| reportWriter.writeln(" Number of those with 'project=': " + nProjectTags + " attribute."); |
| reportWriter.writeln(" Number of bundles without an Eclipse-SourceReferences: " + withoutESs.size()); |
| reportWriter.writeln(); |
| reportWriter.writeln(); |
| reportWriter.writeln(" Bundles with Eclipse-SourceReferences (total: " + totalCount(withEs) + ")"); |
| reportWriter.writeln(); |
| Collection allESs = withEs.keySet(); |
| List allESList = new ArrayList(allESs); |
| Collections.sort(allESList); |
| for (Object object : allESList) { |
| //Integer count = (Integer) withEs.get(object); |
| //reportWriter.writeln(" " + count.intValue() + " " + object); |
| reportWriter.writeln(" " + object); |
| } |
| reportWriter.writeln(); |
| reportWriter.writeln(); |
| reportWriter.writeln(" Bundles without an Eclipse-SourceReferences (total: " + withoutESs.size() + ")"); |
| Collections.sort(withoutESs); |
| for (Object object : withoutESs) { |
| reportWriter.writeln(" " + object); |
| } |
| reportWriter.writeln(); |
| } |
| finally { |
| reportWriter.close(); |
| } |
| } |
| |
| public String getOutputDirectory() { |
| if (outputDirectory == null) { |
| outputDirectory = System.getProperty("user.dir"); |
| } |
| return outputDirectory; |
| } |
| |
| private int totalCount(Map bundlesWithEs) { |
| |
| Collection allCounts = bundlesWithEs.values(); |
| int total = 0; |
| for (Iterator iterator = allCounts.iterator(); iterator.hasNext();) { |
| Integer count = (Integer) iterator.next(); |
| total = total + count.intValue(); |
| } |
| return total; |
| } |
| |
| private void trackOmissions(List bundlesWithoutEs, File child) { |
| bundlesWithoutEs.add(child.getName()); |
| |
| } |
| |
| |
| private void incrementCounts(Map esMap, String es) { |
| Integer count = (Integer) esMap.get(es); |
| if (count == null) { |
| esMap.put(es, new Integer(1)); |
| } |
| else { |
| esMap.put(es, increment(count)); |
| } |
| |
| } |
| |
| private Integer increment(Integer count) { |
| return new Integer(count.intValue() + 1); |
| } |
| |
| |
| |
| private String getBundleName(String fullname) { |
| String result = null; |
| boolean parsable = nameParser.parse(fullname); |
| if (parsable) { |
| result = nameParser.getProjectString(); |
| } |
| return result; |
| } |
| |
| /* |
| * Return the bundle id from the manifest pointed to by the given input |
| * stream. |
| */ |
| private String getESFromManifest(InputStream input, String path) { |
| String es = null; |
| try { |
| Map attributes = ManifestElement.parseBundleManifest(input, null); |
| es = (String) attributes.get(PROPERTY_ECLIPSE_SOURCEREFERENCES); |
| } |
| catch (BundleException e) { |
| e.printStackTrace(); |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| finally { |
| if (input != null) { |
| try { |
| input.close(); |
| } |
| catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| |
| return es; |
| } |
| |
| public String getTempWorkingDir() { |
| return tempWorkingDir; |
| } |
| |
| public void setTempWorkingDir(String tempWorkingDir) { |
| this.tempWorkingDir = tempWorkingDir; |
| } |
| |
| /* |
| * The given file points to a bundle contained in an archive. Look into |
| * the bundle manifest file to find the bundle identifier. |
| */ |
| private String getESFromJAR(File file) { |
| InputStream input = null; |
| JarFile jar = null; |
| try { |
| jar = new JarFile(file, false, ZipFile.OPEN_READ); |
| JarEntry entry = jar.getJarEntry(JarFile.MANIFEST_NAME); |
| if (entry == null) { |
| // addError("Bundle does not contain a MANIFEST.MF file: " + |
| // file.getAbsolutePath()); |
| return null; |
| } |
| input = jar.getInputStream(entry); |
| return getESFromManifest(input, file.getAbsolutePath()); |
| } |
| catch (IOException e) { |
| System.out.println(e.getMessage()); |
| // addError(e.getMessage()); |
| return null; |
| } |
| finally { |
| if (input != null) { |
| try { |
| input.close(); |
| } |
| catch (IOException e) { |
| // ignore |
| } |
| } |
| if (jar != null) { |
| try { |
| jar.close(); |
| } |
| catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| } |
| |
| public void setOutputDirectory(String outputDirectory) { |
| this.outputDirectory = outputDirectory; |
| } |
| |
| private String getBundleDirectory() { |
| if (bundleDirectory == null) { |
| String property = getDirectoryToCheck(); |
| if (property == null) { |
| throw new BuildException("Need to set input directory to check against."); |
| } |
| if (property.endsWith("/")) { |
| bundleDirectory = property + "aggregate/plugins"; |
| } |
| else { |
| bundleDirectory = property + "/aggregate/plugins"; |
| } |
| } |
| return bundleDirectory; |
| } |
| |
| } |