Attachment #38421 for bug #127375

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2006 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

package org.eclipse.update.core;

import java.io.*;
import java.net.URL;
import java.util.*;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.*;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.model.*;

	private static final String DOT_PERMISSIONS = "permissions.properties"; //$NON-NLS-1$
	private static final String EXECUTABLES = "permissions.executable"; //$NON-NLS-1$

	// lock
	private final static Object lock = new Object();

	// hashtable of locks
	private static Hashtable locks = new Hashtable();

	/**
	 * Feature content provider constructor
	 * 

		// is still copying into it
		File localFile = null;
		FileFragment localFileFragment = null;
		Object keyLock = LockManager.getLock(key);
		synchronized (lock) {
			if (locks.get(key) == null)
				locks.put(key, key);
			keyLock = locks.get(key);
		}

		synchronized (keyLock) {
			localFile = Utilities.lookupLocalFile(key);
			if (localFile != null) {

				if (monitor != null)
					monitor.restoreState();
			}
			LockManager.returnLock(key);
		} // end lock
		ContentReference reference =
			ref.createContentReference(ref.getIdentifier(), localFile);




/*******************************************************************************
 * Copyright (c) 2000, 2006 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

 *******************************************************************************/
package org.eclipse.update.internal.core;
import java.io.*;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.CoreException;
import java.util.List;

import org.eclipse.core.runtime.*;
import org.eclipse.osgi.internal.provisional.verifier.CertificateVerifierFactory;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.*;
import org.eclipse.update.internal.jarprocessor.JarProcessor;
import org.eclipse.update.internal.security.JarVerifier;
import org.eclipse.update.internal.verifier.CertVerifier;


	private ContentReference localManifest = null;
	private ContentReference[] localFeatureFiles = new ContentReference[0];
	private IVerifier jarVerifier = null;
	private ExtendedSite siteModel = null;
	/*
	 * filter for file with .jar
	 */

		return jarVerifier;
	}

	public void setFeature(IFeature feature) {
		super.setFeature(feature);
		ISite featureSite = feature.getSite();
		if(featureSite instanceof ExtendedSite){
			siteModel = (ExtendedSite) featureSite;
		}
	}
	/*
	 * @see IFeatureContentProvider#getFeatureManifestReference()
	 */

		URL url = (siteContentProvider == null) ? null : siteContentProvider.getArchiveReference(archiveID);

		try {
			references[0] = retrieveLocalJar(new JarContentReference(archiveID, url), monitor);
		} catch (IOException e) {
			throw errorRetrieving(archiveID, references[0], e);
		}
		return references;
	}

	private ContentReference retrieveLocalJar(JarContentReference reference, InstallMonitor monitor) throws IOException, CoreException {
		//If the site does not support pack200, just get the jar as normal
		if(siteModel == null || !siteModel.supportsPack200() || !JarProcessor.canPerformUnpack()) {
			return asLocalReference(reference, monitor);
		}
		
		ContentReference packedRef = null;
		String key = reference.toString();
		Object jarLock = LockManager.getLock(key);
		synchronized (jarLock) {
			//do we have this jar already?
			File localFile = Utilities.lookupLocalFile(key);
			if (localFile != null) {
				// check if the cached file is still valid (no newer version on server)
				if (UpdateManagerUtils.isSameTimestamp(reference.asURL(), localFile.lastModified())) {
					LockManager.returnLock(key);
					return reference.createContentReference(reference.getIdentifier(), localFile);
				}
			}

			try {
				//don't have jar, check for pack.gz
				URL packGZURL = new URL(reference.asURL().toExternalForm() + ".pack.gz"); //$NON-NLS-1$
				packedRef = asLocalReference(new JarContentReference(reference.getIdentifier(), packGZURL), monitor);
			} catch (IOException e) {
				//no pack.gz
			}
		}
		
		if (packedRef == null) {
			//no pack.gz on server, get normal jar
			return asLocalReference(reference, monitor);
		}

		synchronized (jarLock) {
			String packed = packedRef.toString();
			Object packedLock = LockManager.getLock(packed);
			synchronized (packedLock) {
				try {
					File tempFile = packedRef.asFile();
					long timeStamp = tempFile.lastModified();
	
					JarProcessor processor = JarProcessor.getUnpackProcessor(null);
					processor.setWorkingDirectory(tempFile.getParent());
	
					File packedFile = new File(tempFile.toString() + ".pack.gz"); //$NON-NLS-1$
					tempFile.renameTo(packedFile);
					//unpacking the jar will strip the ".pack.gz" and leave us back with the original filename
					processor.processJar(packedFile);
	
					tempFile.setLastModified(timeStamp);
					Utilities.mapLocalFile(key, tempFile);
				} finally {
					LockManager.returnLock(packed);
					LockManager.returnLock(key);
				}
			}
		}
		return packedRef;
	}
	/*
	 * @see IFeatureContentProvider#getNonPluginEntryArchiveReferences(INonPluginEntry)
	 */

Lines 1-3 Link Here

(-)src/org/eclipse/update/internal/core/ExtendedSite.java (-1 / +30 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2006 IBM Corporation and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* IBM - Initial API and implementation
		10	*******************************************************************************/
1	package org.eclipse.update.internal.core;	11	package org.eclipse.update.internal.core;
2		12
3	import java.util.ArrayList;	13	import java.util.ArrayList;
Lines 12-18 Link Here
12	private String[] availableLocals;	22	private String[] availableLocals;
13	private String digestURL;	23	private String digestURL;
14	private LiteFeature[] liteFeatures;	24	private LiteFeature[] liteFeatures;
15		25	private boolean pack200 = false;
16		26
17	public String getDigestURL() {	27	public String getDigestURL() {
18	return digestURL;	28	return digestURL;
Lines 55-60 Link Here
55	this.liteFeatures = liteFeatures;	65	this.liteFeatures = liteFeatures;
56	}	66	}
57		67
		68
		69	/**
		70	* Get whether or not this site may contain jars packed with pack200.
		71	* The packed version of foo.jar, is expected to be foo.jar.pack.gz
		72	* @return
		73	*/
		74	public boolean supportsPack200() {
		75	return pack200;
		76	}
		77
		78	/**
		79	* Set whether or not this site may contain jars packed with pack200
		80	* The packed version of foo.jar is expected to be foo.jar.pack.gz
		81	* @param pack
		82	*/
		83	public void setSupportsPack200(boolean pack){
		84	pack200 = pack;
		85	}
		86
58	/*	87	/*
59	* Method filterFeatures.	88	* Method filterFeatures.
60	* Also implemented in Feature	89	* Also implemented in Feature

Lines 1-5 Link Here

(-)src/org/eclipse/update/core/model/DefaultSiteParser.java (-1 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 514-519 Link Here
514	site.setMirrorsURLString(mirrorsURL);	514	site.setMirrorsURLString(mirrorsURL);
515	}	515	}
516		516
		517	String pack200 = attributes.getValue("pack200"); //$NON-NLS-1$
		518	if(site instanceof ExtendedSite && pack200 != null && new Boolean(pack200).booleanValue()){
		519	((ExtendedSite) site).setSupportsPack200(true);
		520	}
		521
517	if ( (site instanceof ExtendedSite) && (attributes.getValue("digestURL") != null)) { //$NON-NLS-1$	522	if ( (site instanceof ExtendedSite) && (attributes.getValue("digestURL") != null)) { //$NON-NLS-1$
518	ExtendedSite extendedSite = (ExtendedSite) site;	523	ExtendedSite extendedSite = (ExtendedSite) site;
519	extendedSite.setDigestExist(true);	524	extendedSite.setDigestExist(true);




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.File;
import java.io.IOException;
import java.util.*;

public class PackStep extends CommandStep {

	protected static String packCommand = null;
	private static Boolean canPack = null;

	private Set exclusions = Collections.EMPTY_SET;

	public static boolean canPack() {
		if (canPack != null)
			return canPack.booleanValue();

		String[] locations = Utils.getPack200Commands("pack200"); //$NON-NLS-1$
		if (locations == null) {
			canPack = Boolean.FALSE;
			packCommand = null;
			return false;
		}

		int result;
		for (int i = 0; i < locations.length; i++) {
			if (locations[i] == null)
				continue;
			try {
				result = execute(new String[] {locations[i], "-V"}); //$NON-NLS-1$
				if (result == 0) {
					packCommand = locations[i];
					canPack = Boolean.TRUE;
					return true;
				}
			} catch (IOException e) {
				//no good
			}
		}

		canPack = Boolean.FALSE;
		return false;
	}

	public PackStep(Properties options) {
		super(options, null, null);
		exclusions = Utils.getPackExclusions(options);
	}

	public String recursionEffect(String entryName) {
		if (canPack() && entryName.endsWith(".jar") && !exclusions.contains(entryName)) { //$NON-NLS-1$
			return entryName + Utils.PACKED_SUFFIX;
		}
		return null;
	}

	public File preProcess(File input, File workingDirectory) {
		return null;
	}

	public File postProcess(File input, File workingDirectory) {
		if (canPack() && packCommand != null) {
			File outputFile = new File(workingDirectory, input.getName() + Utils.PACKED_SUFFIX);
			try {
				String[] cmd = getCommand(input, outputFile);
				execute(cmd);
			} catch (IOException e) {
				//didn't work
				return null;
			}
			return outputFile;
		}
		return null;
	}

	protected String[] getCommand(File input, File outputFile) throws IOException {
		String[] cmd = null;
		String arguments = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$
		if (arguments != null) {
			String[] args = arguments.split(",\\s*"); //$NON-NLS-1$
			cmd = new String[3 + args.length];
			cmd[0] = packCommand;
			System.arraycopy(args, 0, cmd, 1, args.length);
			cmd[cmd.length - 2] = outputFile.getCanonicalPath();
			cmd[cmd.length - 1] = input.getCanonicalPath();
		} else {
			cmd = new String[] {packCommand, outputFile.getCanonicalPath(), input.getCanonicalPath()};
		}
		return cmd;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.*;
import java.util.*;
import java.util.jar.*;

/**
 * @author aniefer
 *
 */
public class SignCommandStep extends CommandStep {
	private Set exclusions = null;

	public SignCommandStep(Properties options, String command) {
		super(options, command, ".jar"); //$NON-NLS-1$
		exclusions = Utils.getSignExclusions(options);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#recursionEffect(java.lang.String)
	 */
	public String recursionEffect(String entryName) {
		if (entryName.endsWith(extension) && !exclusions.contains(entryName))
			return entryName;
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)
	 */
	public File preProcess(File input, File workingDirectory) {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
	 */
	public File postProcess(File input, File workingDirectory) {
		if (command != null) {
			try {
				String[] cmd = new String[] {command, input.getCanonicalPath()};
				int result = execute(cmd);
				if (result == 0) {
					normalize(input, workingDirectory);
					return input;
				}
			} catch (IOException e) {
				//boo
				e.printStackTrace();
			}
		}
		return null;
	}

	private void normalize(File input, File workingDirectory) {
		try {
			File tempJar = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$
			JarFile jar = new JarFile(input);
			JarOutputStream jarOut = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(tempJar)));
			InputStream in = null;
			try {
				Enumeration entries = jar.entries();
				for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
					JarEntry newEntry = new JarEntry(entry.getName());
					newEntry.setTime(entry.getTime());
					in = new BufferedInputStream(jar.getInputStream(entry));
					jarOut.putNextEntry(newEntry);
					Utils.transferStreams(in, jarOut, false);
					jarOut.closeEntry();
					in.close();
				}
			} finally {
				Utils.close(jarOut);
				Utils.close(jar);
				Utils.close(in);
			}
			tempJar.setLastModified(input.lastModified());
			input.delete();
			tempJar.renameTo(input);
		} catch (IOException e) {
			//boo
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.core;

import java.util.Hashtable;

/**
 * @author aniefer
 *
 */
public class LockManager {
	// lock
	private final static Object lock = new Object();

	// hashtable of locks
	private static Hashtable locks = new Hashtable();
	
	public static Object getLock(String key) {
		synchronized (lock) {
			if (locks.get(key) == null)
				locks.put(key, key);
			return locks.get(key);
		}
	}
	
	public static void returnLock(String key) {
		synchronized (lock) {
			locks.remove(key);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.IOException;
import java.util.Properties;

/**
 * @author aniefer
 *
 */
public abstract class CommandStep implements IProcessStep {
	protected String command = null;
	protected String extension = null;
	private  Properties options = null;
	
	public CommandStep(Properties options, String command, String extension) {
		this.command = command;
		this.extension = extension;
		this.options = options;
	}

	protected static int execute(String[] cmd) throws IOException {
		Runtime runtime = Runtime.getRuntime();
		Process proc = runtime.exec(cmd);
		try {
			int result = proc.waitFor();
			return result;
		} catch (InterruptedException e) {
			//ignore
		}
		return -1;
	}
	
	public Properties getOptions() {
		if(options == null)
			options = new Properties();
		return options;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.*;
import java.util.zip.ZipException;

/**
 * @author aniefer
 *
 */
public class Main {

	public static class Options {
		public String outputDir = "."; //$NON-NLS-1$
		public String signCommand = null;
		public boolean pack = false;
		public boolean repack = false;
		public boolean unpack = false;
		public File input = null;
	}

	private static void printUsage() {
		System.out.println("[-option ...]... input"); //$NON-NLS-1$
		System.out.println("The following options are supported:"); //$NON-NLS-1$
		System.out.println("-repack         normalize jars "); //$NON-NLS-1$
		System.out.println("-sign <command> sign jars using <command>"); //$NON-NLS-1$
		System.out.println("-pack           pack the jars.  pack and repack are redundant unless"); //$NON-NLS-1$
		System.out.println("                sign is also specified."); //$NON-NLS-1$
		System.out.println("-unpack         unpack pack.gz files. Unpack is mutually exclusive"); //$NON-NLS-1$
		System.out.println("                with repack, sign and pack."); //$NON-NLS-1$
		System.out.println();
		System.out.println("-outputDir <dir>  the output directory"); //$NON-NLS-1$
	}

	public static Options processArguments(String[] args) {
		if (args.length == 0) {
			printUsage();
			return null;
		}

		Options options = new Options();
		int i = 0;
		for (; i < args.length - 1; i++) {
			if (args[i].equals("-pack")) {//$NON-NLS-1$
				options.pack = true;
			} else if (args[i].equals("-unpack")) { //$NON-NLS-1$
				options.unpack = true;
			} else if (args[i].equals("-sign") && i < args.length - 2) { //$NON-NLS-1$
				if (args[i + 1].startsWith("-")) { //$NON-NLS-1$
					printUsage();
					return null;
				}
				options.signCommand = args[++i];
			} else if (args[i].equals("-repack")) { //$NON-NLS-1$
				options.repack = true;
			} else if (args[i].equals("-outputDir") && i < args.length - 2) { //$NON-NLS-1$
				if (args[i + 1].startsWith("-")) { //$NON-NLS-1$
					printUsage();
					return null;
				}
				options.outputDir = args[++i];
			}
		}

		options.input = new File(args[i]);

		String problemMessage = null;
		if (options.unpack) {
			if (!JarProcessor.canPerformUnpack()) {
				problemMessage = "The unpack200 command cannot be found."; //$NON-NLS-1$
			} else 	if (options.input.isFile() && !args[i].endsWith(".zip") && !args[i].endsWith(".pack.gz")) { //$NON-NLS-1$ //$NON-NLS-2$
				problemMessage = "Input file is not a pack.gz file."; //$NON-NLS-1$
			} else 	if (options.pack || options.repack || options.signCommand != null) {
				problemMessage = "Pack, repack or sign cannot be specified with unpack."; //$NON-NLS-1$
			}
		} else {
			if (options.input.isFile() && !args[i].endsWith(".zip") && !args[i].endsWith(".jar")) { //$NON-NLS-1$ //$NON-NLS-2$
				problemMessage = "Input file is not a jar file."; //$NON-NLS-1$
			} else	if ((options.pack || options.repack) && !JarProcessor.canPerformPack()) {
				problemMessage = "The pack200 command can not be found."; //$NON-NLS-1$
			}
		}
		if(problemMessage != null){
			System.out.println(problemMessage);
			System.out.println();
			printUsage();
			return null;
		}

		return options;
	}

	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) {
		Options options = processArguments(args);
		if (options == null)
			return;

		if (options.input.getName().endsWith(".zip")) { //$NON-NLS-1$
			ZipProcessor processor = new ZipProcessor();
			processor.setWorkingDirectory(options.outputDir);
			processor.setSignCommand(options.signCommand);
			processor.setPack(options.pack);
			processor.setRepack(options.repack || (options.pack && options.signCommand != null));
			processor.setUnpack(options.unpack);
			try {
				processor.processZip(options.input);
			} catch (ZipException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			JarProcessor processor = new JarProcessor();
			processor.setWorkingDirectory(options.outputDir);

			if (options.repack || (options.pack && options.signCommand != null))
				processor.addProcessStep(new PackUnpackStep(null));

			if (options.signCommand != null)
				processor.addProcessStep(new SignCommandStep(null, options.signCommand));

			if (options.pack)
				processor.addProcessStep(new PackStep(null));
			else if (options.unpack)
				processor.addProcessStep(new UnpackStep(null));

			try {
				processor.process(options.input, options.unpack ? Utils.PACK_GZ_FILTER : Utils.JAR_FILTER);
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}




<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
  <title>Eclipse update packing tool readme</title>
</head>
<body>
<h1>Eclipse update packing tool</h1>

<h3>Overview</h3>
The update packing tool processes a hierarchy of arbitrarily nested
JARs and ZIP files.  It is a generic utility that performs a depth first traversal of 
a nested hierarchy of ZIPs and JARs, performs various commands on
each of the JARs in the hierarchy, and then rebuilds the same hierarchy
of ZIPs and JARs again.  Currently its main functions are:
<ul>
	<li>Packing JARs using the Java 1.5 <a href="http://java.sun.com/j2se/1.5.0/docs/tooldocs/share/pack200.html">pack200</a>
	 command.</li>
	 <li>Unpacking PACK.GZs using the Java 1.5 <a href="http://java.sun.com/j2se/1.5.0/docs/tooldocs/share/unpack200.html">unpack200</a>
	 command.</li>
	 <li>Normalizing JARs for future compression by pack200. This is accomplished
	 by running the pack200 command with the <tt>--repack</tt> command line argument.</li>
	 <li>Signing JARs to allow for authentication of the origin of JARs. This is accomplished by
	 running a supplied command (typically the command will just be a wrapper around
	 the Java <a href="http://java.sun.com/j2se/1.3/docs/tooldocs/win32/jarsigner.html">jarsigner</a> tool).</li>
</ul>
The packing tool is used in the following contexts:
<ul>
	<li>During a PDE build, to prepare JARs for uploading to an Eclipse
	update site.  In this usage, it is used to both nomalize JAR contents
	(pack200 -repack), and sign JARs.</li>
	<li>On an update site, to convert traditional JAR content into the 
	compressed pack200 format.</li>
	<li>From an Eclipse client application during update, to convert
	compressed pack200 format content into executable JAR files.</li>
</ul>
<h3>Tool usage</h3>
To run the packing tool, you need a 1.5 JRE installed. The tool is run
by invoking Java as follows:

<pre>
	java jarprocessor.jar [options] input
</pre>

Where <tt>input</tt> is either a zip file, a directory, or a JAR (or a pack.gz file). All files ending 
in ".jar" or ".pack.gz" in the provided zip or directory hierarchy
will be processed. 
The following additional command line arguments are supported:
<ul>
<li>-repack : Normalize the jars using pack200 <tt>--repack</tt></li>
<li>-sign &lt;cmd&gt; : signs the jars by executing the provided command.  
The command will be provided a single argument that will be the full path of the JAR to process.
</li>
<li>-pack : for each input in JAR form, produce a corresponding output
in packed form.  For an input "a.jar", the output is a.jar.pack.gz.  
</li>
<li>-unpack : for each input in packed form, produce a corresponding output
in unpacked form.  For an input "a.jar.pack.gz", the output is "a.jar". -unpack is mutually exclusive with -repack, -pack and -sign.</li>
<li>-outputDir &lt;dir&gt; : The directory to put the tool's output into.  If the input was a zip file, then an output zip file will be
created containg all the output files.  If the input was a directory, for each input file there is a corresponding output file in the output directory. By default the current working directory is used.  If the input is in the same
directory as the output, the input files may be overwritten.</li>
</ul>

Additionally, when the input is a zip file, it may contain a file called
<tt>pack.properties</tt>.  The pack.properties file supports the following values:
<ul>
<li>pack.excludes =  jarName[, jarName]* : A comma-delimited list of JARs that should not be packed or repacked.
</li>
<li>sign.excludes =  jarName[, jarName]* : A comma-delimited list of JARs that should not be signed.
</li>
<li>&lt;jarname&gt;.pack.args = option[, option]* : A comma-delimited list of additional arguments that should
be passed to pack200 when packing any jar with name &lt;jarname&gt;.
</ul>
</p>
<p>
<font size=-1>
Copyright (c) IBM Corporation and others 2006. All rights reserved. This program and the accompanying materials
are made available under the terms of the 
<a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License v1.0</a>.
</font>
</body>
</html>




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.*;
import java.util.*;
import java.util.jar.JarFile;

/**
 * @author aniefer
 *
 */
public class Utils {
	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$
	public static final String JRE = "@jre"; //$NON-NLS-1$
	public static final String PATH = "@path"; //$NON-NLS-1$
	public static final String NONE = "@none"; //$NON-NLS-1$

	public static final String PACKED_SUFFIX = ".pack.gz"; //$NON-NLS-1$
	public static final String JAR_SUFFIX = ".jar"; //$NON-NLS-1$

	public static final FileFilter JAR_FILTER = new FileFilter() {
		public boolean accept(File pathname) {
			return pathname.isFile() && pathname.getName().endsWith(".jar"); //$NON-NLS-1$
		}
	};

	public static final FileFilter PACK_GZ_FILTER = new FileFilter() {
		public boolean accept(File pathname) {
			return pathname.isFile() && pathname.getName().endsWith(PACKED_SUFFIX);
		}
	};

	public static void close(Object stream) {
		if (stream != null) {
			try {
				if (stream instanceof InputStream)
					((InputStream) stream).close();
				else if (stream instanceof OutputStream)
					((OutputStream) stream).close();
				else if (stream instanceof JarFile)
					((JarFile) stream).close();
			} catch (IOException e) {
				//ignore
			}
		}
	}

	/**
	 * get the set of commands to try to execute pack/unpack 
	 * @param cmd, the command, either "pack200" or "unpack200"
	 * @return String [] or null
	 */
	public static String[] getPack200Commands(String cmd) {
		String[] locations = null;
		String prop = System.getProperty(PACK200_PROPERTY);
		String javaHome = System.getProperty("java.home"); //$NON-NLS-1$
		if (NONE.equals(prop)) {
			return null;
		} else if (JRE.equals(prop)) {
			locations = new String[] {javaHome + "/bin/" + cmd}; //$NON-NLS-1$
		} else if (PATH.equals(prop)) {
			locations = new String[] {cmd};
		} else if (prop == null) {
			locations = new String[] {javaHome + "/bin/" + cmd, cmd}; //$NON-NLS-1$ 
		} else {
			locations = new String[] {prop + "/" + cmd}; //$NON-NLS-1$
		}
		return locations;
	}

	/**
	 * Transfers all available bytes from the given input stream to the given
	 * output stream. Closes both streams if close == true, regardless of failure. 
	 * Flushes the destination stream if close == false
	 * 
	 * @param source
	 * @param destination
	 * @param close 
	 * @throws IOException
	 */
	public static void transferStreams(InputStream source, OutputStream destination, boolean close) throws IOException {
		source = new BufferedInputStream(source);
		destination = new BufferedOutputStream(destination);
		try {
			byte[] buffer = new byte[8192];
			while (true) {
				int bytesRead = -1;
				if ((bytesRead = source.read(buffer)) == -1)
					break;
				destination.write(buffer, 0, bytesRead);
			}
		} finally {
			if (close) {
				close(source);
				close(destination);
			} else {
				destination.flush();
			}
		}
	}

	/**
	 * Deletes all the files and directories from the given root down (inclusive).
	 * Returns false if we could not delete some file or an exception occurred
	 * at any point in the deletion.
	 * Even if an exception occurs, a best effort is made to continue deleting.
	 */
	public static boolean clear(java.io.File root) {
		boolean result = clearChildren(root);
		try {
			if (root.exists())
				result &= root.delete();
		} catch (Exception e) {
			result = false;
		}
		return result;
	}

	/**
	 * Deletes all the files and directories from the given root down, except for 
	 * the root itself.
	 * Returns false if we could not delete some file or an exception occurred
	 * at any point in the deletion.
	 * Even if an exception occurs, a best effort is made to continue deleting.
	 */
	public static boolean clearChildren(java.io.File root) {
		boolean result = true;
		if (root.isDirectory()) {
			String[] list = root.list();
			// for some unknown reason, list() can return null.  
			// Just skip the children If it does.
			if (list != null)
				for (int i = 0; i < list.length; i++)
					result &= clear(new java.io.File(root, list[i]));
		}
		return result;
	}

	public static Set getPackExclusions(Properties properties) {
		if (properties == null)
			return Collections.EMPTY_SET;

		String packExcludes = properties.getProperty("pack.excludes"); //$NON-NLS-1$
		if (packExcludes != null) {
			String[] excludes = packExcludes.split(",\\s*"); //$NON-NLS-1$
			Set packExclusions = new HashSet();
			for (int i = 0; i < excludes.length; i++) {
				packExclusions.add(excludes[i]);
			}
			return packExclusions;
		}
		return Collections.EMPTY_SET;
	}

	public static Set getSignExclusions(Properties properties) {
		if (properties == null)
			return Collections.EMPTY_SET;
		String signExcludes = properties.getProperty("sign.excludes"); //$NON-NLS-1$
		if (signExcludes != null) {
			String[] excludes = signExcludes.split(",\\s*"); //$NON-NLS-1$
			Set signExclusions = new HashSet();
			for (int i = 0; i < excludes.length; i++) {
				signExclusions.add(excludes[i]);
			}
			return signExclusions;
		}
		return Collections.EMPTY_SET;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.File;
import java.io.IOException;
import java.util.Properties;

/**
 * @author aniefer
 *
 */
public class UnpackStep extends CommandStep {
	public static final String UNPACKER_PROPERTY = "org.eclipse.update.jarprocessor.Unpacker"; //$NON-NLS-1$
	private static Boolean canUnpack = null;
	private static String unpackCommand = null;

	public static boolean canUnpack() {
		if (canUnpack != null)
			return canUnpack.booleanValue();

		String[] locations = Utils.getPack200Commands("unpack200"); //$NON-NLS-1$
		if (locations == null) {
			canUnpack = Boolean.FALSE;
			unpackCommand = null;
			return false;
		}

		int result;
		for (int i = 0; i < locations.length; i++) {
			if (locations[i] == null)
				continue;
			try {
				result = execute(new String[] {locations[i], "-V"}); //$NON-NLS-1$
				if (result == 0) {
					unpackCommand = locations[i];
					canUnpack = Boolean.TRUE;
					return true;
				}
			} catch (IOException e) {
				//no good
			}
		}

		canUnpack = Boolean.FALSE;
		return false;
	}

	public UnpackStep(Properties options) {
		super(options, null, null);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#recursionEffect(java.lang.String)
	 */
	public String recursionEffect(String entryName) {
		if (canUnpack() && entryName.endsWith(Utils.PACKED_SUFFIX)) {
			return entryName.substring(0, entryName.length() - Utils.PACKED_SUFFIX.length());
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)
	 */
	public File preProcess(File input, File workingDirectory) {
		if (canUnpack() && unpackCommand != null) {
			String name = input.getName();
			if (name.endsWith(Utils.PACKED_SUFFIX)) {
				name = name.substring(0, name.length() - Utils.PACKED_SUFFIX.length());

				File unpacked = new File(workingDirectory, name);
				File parent = unpacked.getParentFile();
				if (!parent.exists())
					parent.mkdirs();
				try {
					String options = getOptions().getProperty(input.getName() + ".unpack.args"); //$NON-NLS-1$
					String[] cmd = null;
					if (options != null) {
						cmd = new String[] {unpackCommand, options, input.getCanonicalPath(), unpacked.getCanonicalPath()};
					} else {
						cmd = new String[] {unpackCommand, input.getCanonicalPath(), unpacked.getCanonicalPath()};
					}
					execute(cmd);
				} catch (IOException e) {
					//didn't work
					return null;
				}
				return unpacked;
			}
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
	 */
	public File postProcess(File input, File workingDirectory) {
		return null;
	}
}




<?xml version="1.0" encoding="UTF-8"?>
<jardesc>
    <jar path="org.eclipse.update.core/jarprocessor.jar"/>
    <options overwrite="false" compress="true" exportErrors="true" exportWarnings="true" saveDescription="false" descriptionLocation="/org.eclipse.update.core/src/org/eclipse/update/internal/jarprocessor/jarprocessor.jardesc" useSourceFolders="false" buildIfNeeded="true" includeDirectoryEntries="false" storeRefactorings="false"/>
    <refactoring structuralOnly="false" deprecationInfo="true"/>
    <selectedProjects>
        <project name="org.eclipse.update.core"/>
    </selectedProjects>
    <manifest manifestVersion="1.0" usesManifest="true" reuseManifest="false" saveManifest="false" generateManifest="true" manifestLocation="" mainClassHandleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{Main.java[Main">
        <sealing sealJar="false">
            <packagesToSeal/>
            <packagesToUnSeal/>
        </sealing>
    </manifest>
    <selectedElements exportClassFiles="true" exportOutputFolder="false" exportJavaFiles="true">
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{JarProcessor.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{PackUnpackStep.java"/>
        <file path="/org.eclipse.update.core/src/org/eclipse/update/internal/jarprocessor/pack-readme.html"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{CommandStep.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{IProcessStep.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{ZipProcessor.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{Main.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{Utils.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{UnpackStep.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{PackStep.java"/>
        <javaElement handleIdentifier="=org.eclipse.update.core/src&lt;org.eclipse.update.internal.jarprocessor{SignCommandStep.java"/>
    </selectedElements>
</jardesc>




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.File;

/**
 * @author aniefer
 *
 */
public interface IProcessStep {
	
	/**
	 * The effect of this processing step if the JarProcessor was to recurse on this entry.
	 * Return null if this step will not do anything with this entry.
	 * Return the new entryName if this step will modify this entry on recursion.
	 * @param entryName
	 * @return
	 */
	String recursionEffect(String entryName);
	
	/**
	 * Perform some processing on the input file before the JarProcessor considers the entries for recursion.
	 *  return the file containing the result of the processing
	 * @param input
	 * @param workingDirectory
	 * @return
	 */
	File preProcess(File input, File workingDirectory);
	
	/**
	 * Perform some processing on the input file after the JarProcessor returns from recursion
	 * return the file containing the result of the processing
	 * @param input
	 * @param workingDirectory
	 * @return
	 */
	File postProcess(File input, File workingDirectory);
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.*;
import java.util.*;
import java.util.jar.*;

/**
 * @author aniefer
 *
 */
public class JarProcessor {
	private List steps = new ArrayList();
	private String workingDirectory = ""; //$NON-NLS-1$
	private int depth = -1;

	static public JarProcessor getUnpackProcessor(Properties properties) {
		if (!canPerformUnpack())
			throw new UnsupportedOperationException();
		JarProcessor processor = new JarProcessor();
		processor.addProcessStep(new UnpackStep(properties));
		return processor;
	}

	static public JarProcessor getPackProcessor(Properties properties) {
		if (!canPerformPack())
			throw new UnsupportedOperationException();
		JarProcessor processor = new JarProcessor();
		processor.addProcessStep(new PackStep(properties));
		return processor;
	}

	static public boolean canPerformPack() {
		return PackStep.canPack();
	}

	static public boolean canPerformUnpack() {
		return UnpackStep.canUnpack();
	}

	public String getWorkingDirectory() {
		return workingDirectory;
	}

	public void setWorkingDirectory(String dir) {
		workingDirectory = dir;
	}

	public void addProcessStep(IProcessStep step) {
		steps.add(step);
	}

	public void clearProcessSteps() {
		steps.clear();
	}

	public void process(File input, FileFilter filter) throws FileNotFoundException {
		if (!input.exists())
			throw new FileNotFoundException();

		File[] files = null;
		if (input.isDirectory()) {
			files = input.listFiles();
		} else if (filter.accept(input)) {
			files = new File[] {input};
		}
		for (int i = 0; i < files.length; i++) {
			System.out.println("Processing " + files[i].getName()); //$NON-NLS-1$
			if (files[i].isDirectory()) {
				String dir = getWorkingDirectory();
				setWorkingDirectory(dir + "/" + files[i].getName()); //$NON-NLS-1$
				process(files[i], filter);
				setWorkingDirectory(dir);
			} else if (filter.accept(files[i])) {
				try {
					processJar(files[i]);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * Recreate a jar file.  The replacements map specifies entry names to be replaced, the replacements are
	 * expected to be found in directory.
	 * 
	 * @param jar - The input jar
	 * @param outputJar - the output
	 * @param replacements - map of entryName -> new entryName
	 * @param directory - location to find file for new entryName
	 * @throws IOException
	 */
	private void recreateJar(JarFile jar, JarOutputStream outputJar, Map replacements, File directory) throws IOException {
		InputStream in = null;
		try {
			Enumeration entries = jar.entries();
			for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
				File replacement = null;
				JarEntry newEntry = null;
				if (replacements.containsKey(entry.getName())) {
					String name = (String) replacements.get(entry.getName());
					replacement = new File(directory, name);
					in = new BufferedInputStream(new FileInputStream(replacement));
					newEntry = new JarEntry(name);
				} else {
					in = new BufferedInputStream(jar.getInputStream(entry));
					newEntry = new JarEntry(entry.getName());
				}
				newEntry.setTime(entry.getTime());
				outputJar.putNextEntry(newEntry);
				Utils.transferStreams(in, outputJar, false);
				outputJar.closeEntry();
				in.close();

				//delete the nested jar file
				if (replacement != null) {
					replacement.delete();
				}
			}
		} finally {
			Utils.close(outputJar);
			Utils.close(jar);
			Utils.close(in);
		}
	}

	private String recursionEffect(String entryName) {
		String result = null;
		for (Iterator iter = steps.iterator(); iter.hasNext();) {
			IProcessStep step = (IProcessStep) iter.next();

			result = step.recursionEffect(entryName);
			if (result != null)
				entryName = result;
		}
		return result;
	}

	private void extractEntries(JarFile jar, File tempDir, Map data) throws IOException {
		Enumeration entries = jar.entries();
		if (entries.hasMoreElements()) {
			for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
				String name = entry.getName();
				String newName = recursionEffect(name);
				if (newName != null) {
					//extract entry to temp directory
					File extracted = new File(tempDir, name);
					File parentDir = extracted.getParentFile();
					if (!parentDir.exists())
						parentDir.mkdirs();

					InputStream in = null;
					OutputStream out = null;
					try {
						in = jar.getInputStream(entry);
						out = new BufferedOutputStream(new FileOutputStream(extracted));
						Utils.transferStreams(in, out, true); //this will close both streams
					} finally {
						Utils.close(in);
						Utils.close(out);
					}
					extracted.setLastModified(entry.getTime());
					data.put(name, newName);

					//recurse
					String dir = getWorkingDirectory();
					setWorkingDirectory(parentDir.getCanonicalPath());
					processJar(extracted);
					setWorkingDirectory(dir);

					//delete the extracted item leaving the recursion result
					if (!name.equals(newName))
						extracted.delete();
				}
			}
		}
	}

	private File preProcess(File input, File tempDir) {
		File result = null;
		for (Iterator iter = steps.iterator(); iter.hasNext();) {
			IProcessStep step = (IProcessStep) iter.next();
			result = step.preProcess(input, tempDir);
			if (result != null)
				input = result;
		}
		return input;
	}

	private File postProcess(File input, File tempDir) {
		File result = null;
		for (Iterator iter = steps.iterator(); iter.hasNext();) {
			IProcessStep step = (IProcessStep) iter.next();
			result = step.postProcess(input, tempDir);
			if (result != null)
				input = result;
		}
		return input;
	}

	public void processJar(File input) throws IOException {
		++depth;
		long lastModified = input.lastModified();
		File workingDir = new File(getWorkingDirectory());
		if (!workingDir.exists())
			workingDir.mkdirs();

		//pre
		File workingFile = preProcess(input, workingDir);

		//Extract entries from jar and recurse on them
		File tempDir = null;
		if (depth == 0) {
			tempDir = new File(workingDir, "temp." + workingFile.getName()); //$NON-NLS-1$
		} else {
			File parent = workingDir.getParentFile();
			tempDir = new File(parent, "temp_" + depth + '_' + workingFile.getName()); //$NON-NLS-1$
		}

		JarFile jar = new JarFile(workingFile, false);
		Map replacements = new HashMap();
		extractEntries(jar, tempDir, replacements);

		//Recreate the jar with replacements.  This also has the effect of normalizing the jar, so we want to do this even if
		//we aren't actually replacing anything
		File tempJar = null;
		tempJar = new File(tempDir, workingFile.getName());
		File parent = tempJar.getParentFile();
		if (!parent.exists())
			parent.mkdirs();
		JarOutputStream jarOut = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(tempJar)));
		recreateJar(jar, jarOut, replacements, tempDir);

		jar.close();
		if (tempJar != null) {
			if (!workingFile.equals(input)) {
				workingFile.delete();
			}
			workingFile = tempJar;
		}

		//post
		File result = postProcess(workingFile, workingDir);
		if (!result.equals(workingFile) && !workingFile.equals(input))
			workingFile.delete();
		if (!result.getParentFile().equals(workingDir)) {
			File finalFile = new File(workingDir, result.getName());
			if (finalFile.exists())
				finalFile.delete();
			result.renameTo(finalFile);
		}

		if (tempDir.exists())
			Utils.clear(tempDir);

		result.setLastModified(lastModified);
		--depth;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.File;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * @author aniefer
 *
 */
public class PackUnpackStep extends PackStep {
	private Set exclusions = null;
	
	public PackUnpackStep(Properties options) {
		super(options);
		exclusions = Utils.getPackExclusions(options);
	}

	public String recursionEffect(String entryName) {
		if (canPack() && entryName.endsWith(".jar") &&  !exclusions.contains(entryName)) { //$NON-NLS-1$
			return entryName;
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)
	 */
	public File postProcess(File input, File workingDirectory) {
		if (canPack() && packCommand != null) {
			File tempFile = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$
			try {
				String[] tmp = getCommand(input, tempFile);
				String[] cmd = new String[tmp.length + 1];
				cmd[0] = tmp[0];
				cmd[1] = "-r"; //$NON-NLS-1$
				System.arraycopy(tmp, 1, cmd, 2, tmp.length - 1);

				int result = execute(cmd);
				if (result == 0 && tempFile.exists()) {
					File finalFile = new File(workingDirectory, input.getName());
					if(finalFile.exists())
						finalFile.delete();
					tempFile.renameTo(finalFile);
					return finalFile;
				}
			} catch (IOException e) {
				//didn't work
				return null;
			}
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
	 */
	public File preProcess(File input, File workingDirectory) {
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2006 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 - Initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.*;
import java.util.*;
import java.util.zip.*;

/**
 * @author aniefer
 *
 */
public class ZipProcessor {

	private IProcessStep signStep = null;
	private IProcessStep packStep = null;
	private IProcessStep packUnpackStep = null;
	private IProcessStep unpackStep = null;

	private String workingDirectory = null;
	private Properties properties = null;
	private Set packExclusions = null;
	private Set signExclusions = null;
	private String command = null;
	private boolean packing = false;
	private boolean signing = false;
	private boolean repacking = false;
	private boolean unpacking = false;

	public void setWorkingDirectory(String dir) {
		workingDirectory = dir;
	}

	public String getWorkingDirectory() {
		if (workingDirectory == null)
			workingDirectory = "."; //$NON-NLS-1$
		return workingDirectory;
	}

	public void setSignCommand(String command) {
		this.command = command;
		this.signing = (command != null);
	}

	public void setPack(boolean pack) {
		this.packing = pack;
	}

	public void setRepack(boolean repack) {
		this.repacking = repack;
	}

	public void setUnpack(boolean unpack) {
		this.unpacking = unpack;
	}

	public void processZip(File zipFile) throws ZipException, IOException {
		ZipFile zip = new ZipFile(zipFile);
		initialize(zip);

		String extension = unpacking ? "pack.gz" : ".jar"; //$NON-NLS-1$ //$NON-NLS-2$
		File tempDir = new File(getWorkingDirectory(), "temp_" + zipFile.getName()); //$NON-NLS-1$
		JarProcessor processor = new JarProcessor();
		processor.setWorkingDirectory(tempDir.getCanonicalPath());
		if (unpacking) {
			processor.addProcessStep(unpackStep);
		}

		File outputFile = new File(getWorkingDirectory(), zipFile.getName() + ".temp"); //$NON-NLS-1$
		File parent = outputFile.getParentFile();
		if (!parent.exists())
			parent.mkdirs();
		ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(outputFile));
		Enumeration entries = zip.entries();
		if (entries.hasMoreElements()) {
			for (ZipEntry entry = (ZipEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (ZipEntry) entries.nextElement() : null) {
				String name = entry.getName();

				InputStream entryStream = zip.getInputStream(entry);

				boolean pack = packing && !packExclusions.contains(name);
				boolean sign = signing && !signExclusions.contains(name);
				boolean repack = repacking && !packExclusions.contains(name);

				File extractedFile = null;

				if (entry.getName().endsWith(extension) && (pack || sign || repack || unpacking)) {
					extractedFile = new File(tempDir, name);
					parent = extractedFile.getParentFile();
					if (!parent.exists())
						parent.mkdirs();
					FileOutputStream extracted = new FileOutputStream(extractedFile);
					Utils.transferStreams(entryStream, extracted, true);

					if (unpacking) {
						processor.processJar(extractedFile);
						name = name.substring(0, name.length() - Utils.PACKED_SUFFIX.length());
						extractedFile = new File(tempDir, name);
					} else {
						processor.clearProcessSteps();
						if (repack)
							processor.addProcessStep(packUnpackStep);
						if (sign)
							processor.addProcessStep(signStep);
						processor.processJar(extractedFile);
						extractedFile = new File(tempDir, extractedFile.getName());
						if (pack) {
							processor.clearProcessSteps();
							processor.addProcessStep(packStep);
							processor.processJar(extractedFile);

							File modifiedFile = new File(tempDir, extractedFile.getName() + Utils.PACKED_SUFFIX);
							ZipEntry zipEntry = new ZipEntry(name + Utils.PACKED_SUFFIX);
							entryStream = new FileInputStream(modifiedFile);
							zipOut.putNextEntry(zipEntry);
							Utils.transferStreams(entryStream, zipOut, false);
							entryStream.close();
							Utils.clear(modifiedFile);
						}
					}
					entryStream = new FileInputStream(extractedFile);
				}
				ZipEntry newEntry = new ZipEntry(name);
				zipOut.putNextEntry(newEntry);
				Utils.transferStreams(entryStream, zipOut, false);
				zipOut.closeEntry();
				entryStream.close();

				if (extractedFile != null)
					Utils.clear(extractedFile);
			}

		}
		zipOut.close();
		zip.close();

		File finalFile = new File(getWorkingDirectory(), zipFile.getName());
		if (finalFile.exists())
			finalFile.delete();
		outputFile.renameTo(finalFile);
		Utils.clear(tempDir);
	}

	private void initialize(ZipFile zip) {
		ZipEntry entry = zip.getEntry("pack.properties"); //$NON-NLS-1$
		properties = new Properties();
		if (entry != null) {
			InputStream stream = null;
			try {
				stream = zip.getInputStream(entry);
				properties.load(stream);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				Utils.close(stream);
			}
		}

		packExclusions = Utils.getPackExclusions(properties);
		signExclusions = Utils.getSignExclusions(properties);

		packUnpackStep = new PackUnpackStep(properties);
		packStep = new PackStep(properties);
		signStep = new SignCommandStep(properties, command);
		unpackStep = new UnpackStep(properties);
	}
}

Return to bug 127375

Lines 1-5 Link Here

(-)src/org/eclipse/update/core/FeatureContentProvider.java (-25 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-26 Link Here
11	package org.eclipse.update.core;	11	package org.eclipse.update.core;
12		12
13	import java.io.*;	13	import java.io.*;
14	import java.net.*;	14	import java.net.URL;
15	import java.util.Date;	15	import java.util.*;
16	import java.util.HashMap;
17	import java.util.Hashtable;
18	import java.util.Iterator;
19	import java.util.Map;
20	import java.util.Properties;
21	import java.util.Set;
22	import java.util.StringTokenizer;
23
24	import org.eclipse.core.runtime.*;	16	import org.eclipse.core.runtime.*;
25	import org.eclipse.osgi.util.NLS;	17	import org.eclipse.osgi.util.NLS;
26	import org.eclipse.update.core.model.*;	18	import org.eclipse.update.core.model.*;
Lines 111-122 Link Here
111	private static final String DOT_PERMISSIONS = "permissions.properties"; //$NON-NLS-1$	103	private static final String DOT_PERMISSIONS = "permissions.properties"; //$NON-NLS-1$
112	private static final String EXECUTABLES = "permissions.executable"; //$NON-NLS-1$	104	private static final String EXECUTABLES = "permissions.executable"; //$NON-NLS-1$
113		105
114	// lock
115	private final static Object lock = new Object();
116
117	// hashtable of locks
118	private static Hashtable locks = new Hashtable();
119
120	/**	106	/**
121	* Feature content provider constructor	107	* Feature content provider constructor
122	*	108	*
Lines 186-198 Link Here
186	// is still copying into it	172	// is still copying into it
187	File localFile = null;	173	File localFile = null;
188	FileFragment localFileFragment = null;	174	FileFragment localFileFragment = null;
189	Object keyLock = null;	175	Object keyLock = LockManager.getLock(key);
190	synchronized (lock) {
191	if (locks.get(key) == null)
192	locks.put(key, key);
193	keyLock = locks.get(key);
194	}
195
196	synchronized (keyLock) {	176	synchronized (keyLock) {
197	localFile = Utilities.lookupLocalFile(key);	177	localFile = Utilities.lookupLocalFile(key);
198	if (localFile != null) {	178	if (localFile != null) {
Lines 351-357 Link Here
351	if (monitor != null)	331	if (monitor != null)
352	monitor.restoreState();	332	monitor.restoreState();
353	}	333	}
354	locks.remove(key);	334	LockManager.returnLock(key);
355	} // end lock	335	} // end lock
356	ContentReference reference =	336	ContentReference reference =
357	ref.createContentReference(ref.getIdentifier(), localFile);	337	ref.createContentReference(ref.getIdentifier(), localFile);

Added Link Here

(-)src/org/eclipse/update/internal/jarprocessor/PackStep.java (+101 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.update.internal.jarprocessor;
12
13	import java.io.File;
14	import java.io.IOException;
15	import java.util.*;
16
17	public class PackStep extends CommandStep {
18
19	protected static String packCommand = null;
20	private static Boolean canPack = null;
21
22	private Set exclusions = Collections.EMPTY_SET;
23
24	public static boolean canPack() {
25	if (canPack != null)
26	return canPack.booleanValue();
27
28	String[] locations = Utils.getPack200Commands("pack200"); //$NON-NLS-1$
29	if (locations == null) {
30	canPack = Boolean.FALSE;
31	packCommand = null;
32	return false;
33	}
34
35	int result;
36	for (int i = 0; i < locations.length; i++) {
37	if (locations[i] == null)
38	continue;
39	try {
40	result = execute(new String[] {locations[i], "-V"}); //$NON-NLS-1$
41	if (result == 0) {
42	packCommand = locations[i];
43	canPack = Boolean.TRUE;
44	return true;
45	}
46	} catch (IOException e) {
47	//no good
48	}
49	}
50
51	canPack = Boolean.FALSE;
52	return false;
53	}
54
55	public PackStep(Properties options) {
56	super(options, null, null);
57	exclusions = Utils.getPackExclusions(options);
58	}
59
60	public String recursionEffect(String entryName) {
61	if (canPack() && entryName.endsWith(".jar") && !exclusions.contains(entryName)) { //$NON-NLS-1$
62	return entryName + Utils.PACKED_SUFFIX;
63	}
64	return null;
65	}
66
67	public File preProcess(File input, File workingDirectory) {
68	return null;
69	}
70
71	public File postProcess(File input, File workingDirectory) {
72	if (canPack() && packCommand != null) {
73	File outputFile = new File(workingDirectory, input.getName() + Utils.PACKED_SUFFIX);
74	try {
75	String[] cmd = getCommand(input, outputFile);
76	execute(cmd);
77	} catch (IOException e) {
78	//didn't work
79	return null;
80	}
81	return outputFile;
82	}
83	return null;
84	}
85
86	protected String[] getCommand(File input, File outputFile) throws IOException {
87	String[] cmd = null;
88	String arguments = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$
89	if (arguments != null) {
90	String[] args = arguments.split(",\\s*"); //$NON-NLS-1$
91	cmd = new String[3 + args.length];
92	cmd[0] = packCommand;
93	System.arraycopy(args, 0, cmd, 1, args.length);
94	cmd[cmd.length - 2] = outputFile.getCanonicalPath();
95	cmd[cmd.length - 1] = input.getCanonicalPath();
96	} else {
97	cmd = new String[] {packCommand, outputFile.getCanonicalPath(), input.getCanonicalPath()};
98	}
99	return cmd;
100	}
101	}

Added Link Here

(-)src/org/eclipse/update/internal/jarprocessor/pack-readme.html (+82 lines)
1	<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
2	<html>
3	<head>
4	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
5	<title>Eclipse update packing tool readme</title>
6	</head>
7	<body>
8	<h1>Eclipse update packing tool</h1>
9
10	<h3>Overview</h3>
11	The update packing tool processes a hierarchy of arbitrarily nested
12	JARs and ZIP files. It is a generic utility that performs a depth first traversal of
13	a nested hierarchy of ZIPs and JARs, performs various commands on
14	each of the JARs in the hierarchy, and then rebuilds the same hierarchy
15	of ZIPs and JARs again. Currently its main functions are:
16	<ul>
17	<li>Packing JARs using the Java 1.5 <a href="http://java.sun.com/j2se/1.5.0/docs/tooldocs/share/pack200.html">pack200</a>
18	command.</li>
19	<li>Unpacking PACK.GZs using the Java 1.5 <a href="http://java.sun.com/j2se/1.5.0/docs/tooldocs/share/unpack200.html">unpack200</a>
20	command.</li>
21	<li>Normalizing JARs for future compression by pack200. This is accomplished
22	by running the pack200 command with the <tt>--repack</tt> command line argument.</li>
23	<li>Signing JARs to allow for authentication of the origin of JARs. This is accomplished by
24	running a supplied command (typically the command will just be a wrapper around
25	the Java <a href="http://java.sun.com/j2se/1.3/docs/tooldocs/win32/jarsigner.html">jarsigner</a> tool).</li>
26	</ul>
27	The packing tool is used in the following contexts:
28	<ul>
29	<li>During a PDE build, to prepare JARs for uploading to an Eclipse
30	update site. In this usage, it is used to both nomalize JAR contents
31	(pack200 -repack), and sign JARs.</li>
32	<li>On an update site, to convert traditional JAR content into the
33	compressed pack200 format.</li>
34	<li>From an Eclipse client application during update, to convert
35	compressed pack200 format content into executable JAR files.</li>
36	</ul>
37	<h3>Tool usage</h3>
38	To run the packing tool, you need a 1.5 JRE installed. The tool is run
39	by invoking Java as follows:
40
41	<pre>
42	java jarprocessor.jar [options] input
43	</pre>
44
45	Where <tt>input</tt> is either a zip file, a directory, or a JAR (or a pack.gz file). All files ending
46	in ".jar" or ".pack.gz" in the provided zip or directory hierarchy
47	will be processed.
48	The following additional command line arguments are supported:
49	<ul>
50	<li>-repack : Normalize the jars using pack200 <tt>--repack</tt></li>
51	<li>-sign <cmd> : signs the jars by executing the provided command.
52	The command will be provided a single argument that will be the full path of the JAR to process.
53	</li>
54	<li>-pack : for each input in JAR form, produce a corresponding output
55	in packed form. For an input "a.jar", the output is a.jar.pack.gz.
56	</li>
57	<li>-unpack : for each input in packed form, produce a corresponding output
58	in unpacked form. For an input "a.jar.pack.gz", the output is "a.jar". -unpack is mutually exclusive with -repack, -pack and -sign.</li>
59	<li>-outputDir <dir> : The directory to put the tool's output into. If the input was a zip file, then an output zip file will be
60	created containg all the output files. If the input was a directory, for each input file there is a corresponding output file in the output directory. By default the current working directory is used. If the input is in the same
61	directory as the output, the input files may be overwritten.</li>
62	</ul>
63
64	Additionally, when the input is a zip file, it may contain a file called
65	<tt>pack.properties</tt>. The pack.properties file supports the following values:
66	<ul>
67	<li>pack.excludes = jarName[, jarName]* : A comma-delimited list of JARs that should not be packed or repacked.
68	</li>
69	<li>sign.excludes = jarName[, jarName]* : A comma-delimited list of JARs that should not be signed.
70	</li>
71	<li><jarname>.pack.args = option[, option]* : A comma-delimited list of additional arguments that should
72	be passed to pack200 when packing any jar with name <jarname>.
73	</ul>
74	</p>
75	<p>
76	<font size=-1>
77	Copyright (c) IBM Corporation and others 2006. All rights reserved. This program and the accompanying materials
78	are made available under the terms of the
79	<a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License v1.0</a>.
80	</font>
81	</body>
82	</html>

Added Link Here

(-)src/org/eclipse/update/internal/jarprocessor/jarprocessor.jardesc (+28 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<jardesc>
3	<jar path="org.eclipse.update.core/jarprocessor.jar"/>
4	<options overwrite="false" compress="true" exportErrors="true" exportWarnings="true" saveDescription="false" descriptionLocation="/org.eclipse.update.core/src/org/eclipse/update/internal/jarprocessor/jarprocessor.jardesc" useSourceFolders="false" buildIfNeeded="true" includeDirectoryEntries="false" storeRefactorings="false"/>
5	<refactoring structuralOnly="false" deprecationInfo="true"/>
6	<selectedProjects>
7	<project name="org.eclipse.update.core"/>
8	</selectedProjects>
9	<manifest manifestVersion="1.0" usesManifest="true" reuseManifest="false" saveManifest="false" generateManifest="true" manifestLocation="" mainClassHandleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{Main.java[Main">
10	<sealing sealJar="false">
11	<packagesToSeal/>
12	<packagesToUnSeal/>
13	</sealing>
14	</manifest>
15	<selectedElements exportClassFiles="true" exportOutputFolder="false" exportJavaFiles="true">
16	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{JarProcessor.java"/>
17	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{PackUnpackStep.java"/>
18	<file path="/org.eclipse.update.core/src/org/eclipse/update/internal/jarprocessor/pack-readme.html"/>
19	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{CommandStep.java"/>
20	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{IProcessStep.java"/>
21	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{ZipProcessor.java"/>
22	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{Main.java"/>
23	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{Utils.java"/>
24	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{UnpackStep.java"/>
25	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{PackStep.java"/>
26	<javaElement handleIdentifier="=org.eclipse.update.core/src<org.eclipse.update.internal.jarprocessor{SignCommandStep.java"/>
27	</selectedElements>
28	</jardesc>