Attachment #52167 for bug #159028

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

Lines 19-34 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/Utils.java (-12 / +47 lines)
19	*	19	*
20	*/	20	*/
21	public class Utils {	21	public class Utils {
		22	public static final String MARK_FILE_NAME = "META-INF/eclipse.inf"; //$NON-NLS-1$
		23
		24	/*
		25	* Properties found in outer pack.properties file
		26	*/
		27	//comma separated list of jars to exclude from sigining
22	public static final String SIGN_EXCLUDES = "sign.excludes"; //$NON-NLS-1$	28	public static final String SIGN_EXCLUDES = "sign.excludes"; //$NON-NLS-1$
		29	//comma separated list of jars to exlclude from packing
23	public static final String PACK_EXCLUDES = "pack.excludes"; //$NON-NLS-1$	30	public static final String PACK_EXCLUDES = "pack.excludes"; //$NON-NLS-1$
24	public static final String MARK_FILE_NAME = "META-INF/eclipse.inf"; //$NON-NLS-1$	31	//Suffix used when specifying arguments to use when running pack200 on a jar
		32	public static final String PACK_ARGS_SUFFIX = ".pack.args"; //$NON-NLS-1$
		33
		34	/*
		35	* Properties found in both pack.properties and eclipse.inf
		36	*/
		37	// Default arguments to use when running pack200.
		38	// Affects all jars when specified in pack.properties, affects children when specified in eclipse.inf
		39	public static final String DEFAULT_PACK_ARGS = "pack200.default.args"; //$NON-NLS-1$
		40
		41	/*
		42	* Properties found in eclipse.inf file
		43	*/
		44	//This jar has been conditioned with pack200
25	public static final String MARK_PROPERTY = "pack200.conditioned"; //$NON-NLS-1$	45	public static final String MARK_PROPERTY = "pack200.conditioned"; //$NON-NLS-1$
		46	//Exclude this jar from processing
26	public static final String MARK_EXCLUDE = "jarprocessor.exclude"; //$NON-NLS-1$	47	public static final String MARK_EXCLUDE = "jarprocessor.exclude"; //$NON-NLS-1$
		48	//Exclude this jar from pack200
27	public static final String MARK_EXCLUDE_PACK = "jarprocessor.exclude.pack"; //$NON-NLS-1$	49	public static final String MARK_EXCLUDE_PACK = "jarprocessor.exclude.pack"; //$NON-NLS-1$
		50	//Exclude this jar from signing
28	public static final String MARK_EXCLUDE_SIGN = "jarprocessor.exclude.sign"; //$NON-NLS-1$	51	public static final String MARK_EXCLUDE_SIGN = "jarprocessor.exclude.sign"; //$NON-NLS-1$
29	public static final String MARK_JARPROCESSOR_VERSION = "jarprocessor.version"; //$NON-NLS-1$	52	//Exclude this jar's children from processing
		53	public static final String MARK_EXCLUDE_CHILDREN = "jarprocessor.exclude.children";
		54	//Exclude this jar's children from pack200
		55	public static final String MARK_EXCLUDE_CHILDREN_PACK = "jarprocessor.exclude.children.pack";
		56	//Exclude this jar's children from signing
		57	public static final String MARK_EXCLUDE_CHILDREN_SIGN = "jarprocessor.exclude.children.sign";
		58	//Arguments used in pack200 for this jar
30	public static final String PACK_ARGS = "pack200.args"; //$NON-NLS-1$	59	public static final String PACK_ARGS = "pack200.args"; //$NON-NLS-1$
31		60
32	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$	61	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$
33	public static final String JRE = "@jre"; //$NON-NLS-1$	62	public static final String JRE = "@jre"; //$NON-NLS-1$
34	public static final String PATH = "@path"; //$NON-NLS-1$	63	public static final String PATH = "@path"; //$NON-NLS-1$
Lines 185-195 Link Here
185	}	214	}
186	return Collections.EMPTY_SET;	215	return Collections.EMPTY_SET;
187	}	216	}
188		217
189	public static String concat(String [] array){	218	public static String concat(String[] array) {
190	StringBuffer buffer = new StringBuffer();	219	StringBuffer buffer = new StringBuffer();
191	for (int i = 0; i < array.length; i++) {	220	for (int i = 0; i < array.length; i++) {
192	if( i > 0 )	221	if (i > 0)
193	buffer.append(' ');	222	buffer.append(' ');
194	buffer.append(array[i]);	223	buffer.append(array[i]);
195	}	224	}
Lines 210-221 Link Here
210	* Get the properties from the eclipse.inf file from the given jar. If the file is not a jar, null is returned.	239	* Get the properties from the eclipse.inf file from the given jar. If the file is not a jar, null is returned.
211	* If the file is a jar, but does not contain an eclipse.inf file, an empty Properties object is returned.	240	* If the file is a jar, but does not contain an eclipse.inf file, an empty Properties object is returned.
212	* @param jarFile	241	* @param jarFile
213	* @return	242	* @return The eclipse.inf properties for the given jar file
214	*/	243	*/
215	public static Properties getEclipseInf(File jarFile) {	244	public static Properties getEclipseInf(File jarFile, boolean verbose) {
216	if (jarFile == null \|\| !jarFile.exists())	245	if (jarFile == null \|\| !jarFile.exists()) {
		246	if (verbose)
		247	System.out.println("Failed to obtain eclipse.inf due to missing jar file: " + jarFile);
217	return null;	248	return null;
218		249	}
219	JarFile jar = null;	250	JarFile jar = null;
220	try {	251	try {
221	jar = new JarFile(jarFile, false);	252	jar = new JarFile(jarFile, false);
Lines 229-243 Link Here
229	}	260	}
230	return new Properties();	261	return new Properties();
231	} catch (IOException e) {	262	} catch (IOException e) {
		263	if (verbose) {
		264	System.out.println("Failed to obtain eclipse.inf due to IOException: " + jarFile);
		265	e.printStackTrace();
		266	}
232	//not a jar	267	//not a jar
		268	return null;
233	} finally {	269	} finally {
234	close(jar);	270	close(jar);
235	}	271	}
236	return null;
237	}	272	}
238		273
239	public static boolean shouldSkipJar(File input, boolean processAll, boolean verbose) {	274	public static boolean shouldSkipJar(File input, boolean processAll, boolean verbose) {
240	Properties inf = getEclipseInf(input);	275	Properties inf = getEclipseInf(input, verbose);
241	if (inf == null) {	276	if (inf == null) {
242	//not a jar, could be a pack.gz	277	//not a jar, could be a pack.gz
243	return false;	278	return false;





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


	}

	/* (non-Javadoc)
	 * @see org.eclipse.update.internal.jarprocessor.PackStep#postProcess(java.io.File, java.io.File, java.util.LinkedList)
	 */
	public File postProcess(File input, File workingDirectory, List containers) {
		if (canPack() && packCommand != null) {
			Properties inf = Utils.getEclipseInf(input, verbose);
			if (!shouldPack(input, containers, inf))
				if (verbose)
					System.out.println("Excluding " + input.getName() + " from " + getStepName()); //$NON-NLS-1$ //$NON-NLS-2$
				return null;
			}
			File tempFile = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$
			try {
				String[] tmp = getCommand(input, tempFile, inf, containers);
				String[] cmd = new String[tmp.length + 1];
				cmd[0] = tmp[0];
				cmd[1] = "-r"; //$NON-NLS-1$

	}

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






import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;

public class PackStep extends CommandStep {

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

	private String arguments = null;
	private Set exclusions = Collections.EMPTY_SET;

	public static boolean canPack() {

		return null;
	}

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

	public File postProcess(File input, File workingDirectory, List containers) {
		if (canPack() && packCommand != null) {
			Properties inf = Utils.getEclipseInf(input, verbose);
			if (!shouldPack(input, containers, inf))
				if(verbose)
					System.out.println("Excluding " + input.getName() + " from " + getStepName()); //$NON-NLS-1$ //$NON-NLS-2$
				return null;
			}
			File outputFile = new File(workingDirectory, input.getName() + Utils.PACKED_SUFFIX);
			try {
				String[] cmd = getCommand(input, outputFile, inf, containers);
				int result = execute(cmd, verbose);
				if (result != 0 && verbose)
					System.out.println("Error: " + result + " was returned from command: " + Utils.concat(cmd)); //$NON-NLS-1$ //$NON-NLS-2$

		return null;
	}

	protected boolean shouldPack(File input, List containers, Properties inf) {
		//1: exclude by containers
		// innermost jar is first on the list, it can override outer jars
		for (Iterator iterator = containers.iterator(); iterator.hasNext();) {
			Properties container = (Properties) iterator.next();
			if (container.containsKey(Utils.MARK_EXCLUDE_CHILDREN_PACK)) {
				if (Boolean.valueOf(container.getProperty(Utils.MARK_EXCLUDE_CHILDREN_PACK)).booleanValue()) {
					if (verbose)
						System.out.println(input.getName() + "is excluded from pack200 by its containers.");
					return false;
				}
				break;
			}
		}

		//2: excluded by self
		if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_PACK) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_PACK)).booleanValue()) {
			if (verbose)
				System.out.println("Excluding " + input.getName() + " from " + getStepName()); //$NON-NLS-1$ //$NON-NLS-2$
			return false;
		}

		return true;
	}

	protected String[] getCommand(File input, File outputFile, Properties inf, List containers) throws IOException {
		String[] cmd = null;
		String arguments = getArguments(input, inf, containers);
		if (arguments != null && arguments.length() > 0) {
			String[] args = Utils.toStringArray(arguments, ","); //$NON-NLS-1$
			cmd = new String[3 + args.length];

		return cmd;
	}

	protected String getArguments(File input, Properties inf, List containers) {
		if (arguments != null)
			return arguments;
		//1: Explicitly marked in our .inf file
		if (inf != null && inf.containsKey(Utils.PACK_ARGS)) {
			arguments = inf.getProperty(Utils.PACK_ARGS);
			return arguments;
		}

		//2: Defaults set in one of our containing jars
		for (Iterator iterator = containers.iterator(); iterator.hasNext();) {
			Properties container = (Properties) iterator.next();
			if (container.containsKey(Utils.DEFAULT_PACK_ARGS)) {
				arguments = container.getProperty(Utils.DEFAULT_PACK_ARGS);
				return arguments;
			}
		}

		//3: Set by name in outside pack.properties file
		Properties options = getOptions();
		String argsKey = input.getName() + Utils.PACK_ARGS_SUFFIX;
		if (options.containsKey(argsKey)) {
			arguments = options.getProperty(argsKey);
			return arguments;
		}

		//4: Set by default in outside pack.properties file
		if (options.containsKey(Utils.DEFAULT_PACK_ARGS)) {
			arguments = options.getProperty(Utils.DEFAULT_PACK_ARGS);
			return arguments;
		}

		if (arguments == null)
			arguments = "";
		return arguments;
	}

	public String getStepName() {
		return "Pack"; //$NON-NLS-1$
	}

	public void adjustInf(File input, Properties inf, List containers) {
		if (input == null || inf == null)
			return;

		//don't be verbose to check if we should mark the inf
		boolean v = verbose;
		verbose = false;
		if (!shouldPack(input, containers, inf)) {
			verbose = v;
			return;
		}

		//mark as conditioned
		inf.put(Utils.MARK_PROPERTY, "true"); //$NON-NLS-1$

		//record arguments used
		String arguments = inf.getProperty(Utils.PACK_ARGS);
		if (arguments == null) {
			arguments = getArguments(input, inf, containers);
			if (arguments != null && arguments.length() > 0)
				inf.put(Utils.PACK_ARGS, arguments);
		}
	}




package org.eclipse.update.internal.jarprocessor;

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

/**

	}

	public static void runJarProcessor(Options options) {
		if (options.input.isFile() && options.input.getName().endsWith(".zip")) { //$NON-NLS-1$
			ZipProcessor processor = new ZipProcessor();
			processor.setWorkingDirectory(options.outputDir);
			processor.setSignCommand(options.signCommand);

			processor.setProcessAll(options.processAll);
			processor.setVerbose(options.verbose);

			//load options file
			Properties properties = null;
			if(options.input.isDirectory()){
				File packProperties  = new File(options.input, "pack.properties");
				if(packProperties.exists() && packProperties.isFile()){
					InputStream in = null;
					try {
						in = new BufferedInputStream( new FileInputStream(packProperties));
						properties.load(in);
					} catch (IOException e) {
						if(options.verbose)
							e.printStackTrace();
					} finally {
						Utils.close(in);
					}
				}
			}
			
			if (options.repack || (options.pack && options.signCommand != null))
				processor.addProcessStep(new PackUnpackStep(properties, options.verbose));

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

			if (options.pack)
				processor.addProcessStep(new PackStep(properties, options.verbose));
			else if (options.unpack)
				processor.addProcessStep(new UnpackStep(properties, options.verbose));

			try {
				processor.process(options.input, options.unpack ? Utils.PACK_GZ_FILTER : Utils.JAR_FILTER);




	private int depth = -1;
	private boolean verbose = false;
	private boolean processAll = false;
	private LinkedList containingInfs = new LinkedList();

	static public JarProcessor getUnpackProcessor(Properties properties) {
		if (!canPerformUnpack())

	}

	public void setWorkingDirectory(String dir) {
		if(dir != null)
			workingDirectory = dir;
	}
	
	public void setVerbose(boolean verbose) {

		return result;
	}

	private void extractEntries(JarFile jar, File tempDir, Map data, Properties inf) throws IOException {
		if(inf != null ) {
			//skip if excluding children
			if(inf.containsKey(Utils.MARK_EXCLUDE_CHILDREN)){
				String excludeChildren = inf.getProperty(Utils.MARK_EXCLUDE_CHILDREN);
				if( Boolean.valueOf(excludeChildren).booleanValue() )
					if(verbose){
						for(int i = 0; i <= depth; i++)
							System.out.print("  "); //$NON-NLS-1$
						System.out.println("Children of " + jar.getName() + "are excluded from processing.");
					}
					return;
			}
		}
		
		Enumeration entries = jar.entries();
		if (entries.hasMoreElements()) {
			for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {

					data.put(name, newName);

					//recurse
					containingInfs.addFirst(inf);
					String dir = getWorkingDirectory();
					setWorkingDirectory(parentDir.getCanonicalPath());
					processJar(extracted);
					setWorkingDirectory(dir);
					containingInfs.removeFirst();

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

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

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

	private void adjustInf(File input, Properties inf) {
		for (Iterator iter = steps.iterator(); iter.hasNext();) {
			IProcessStep step = (IProcessStep) iter.next();
			step.adjustInf(input, inf, containingInfs);
		}
	}



		JarFile jar = new JarFile(workingFile, false);
		Map replacements = new HashMap();
		Properties inf = Utils.getEclipseInf(workingFile, verbose);
		extractEntries(jar, tempDir, replacements, inf);

		Properties inf = Utils.getEclipseInf(workingFile);
		if (inf != null)
			adjustInf(workingFile, inf);


Lines 11-16 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/CommandStep.java (-1 / +2 lines)
11	package org.eclipse.update.internal.jarprocessor;	11	package org.eclipse.update.internal.jarprocessor;
12		12
13	import java.io.File;	13	import java.io.File;
		14	import java.util.List;
14	import java.util.Properties;	15	import java.util.Properties;
15		16
16	/**	17	/**
Lines 62-68 Link Here
62	return options;	63	return options;
63	}	64	}
64		65
65	public void adjustInf(File input, Properties inf) {	66	public void adjustInf(File input, Properties inf, List containers) {
66	//nothing	67	//nothing
67	}	68	}
68	}	69	}





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

/**

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

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





 *******************************************************************************/
package org.eclipse.update.internal.jarprocessor;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;

/**
 * @author aniefer@ca.ibm.com

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

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
	 */
	public File postProcess(File input, File workingDirectory, List containers) {
		if (command != null && shouldSign(input, containers)) {
			Properties inf = Utils.getEclipseInf(input);
			if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_SIGN) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_SIGN)).booleanValue()) {
				if(verbose)
					System.out.println("Excluding " + input.getName() + " from signing."); //$NON-NLS-1$ //$NON-NLS-2$
				return null;
			}
			try {
				String[] cmd = new String[] {command, input.getCanonicalPath()};
				int result = execute(cmd, verbose);

		return null;
	}

	private boolean shouldSign(File input, List containers) {
		Properties inf = null;

		//1: Are we excluded from signing by our parents?
		//innermost jar is first on the list, it overrides outer jars
		for (Iterator iterator = containers.iterator(); iterator.hasNext();) {
			inf = (Properties) iterator.next();
			if (inf.containsKey(Utils.MARK_EXCLUDE_CHILDREN_SIGN)){
				if(Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_CHILDREN_SIGN)).booleanValue()) {
					if (verbose)
						System.out.println(input.getName() + "is excluded from signing by its containers."); //$NON-NLS-1$ //$NON-NLS-2$
					return false;
				}
				break;
			}
		}

		//2: Is this jar itself marked as exclude?
		inf = Utils.getEclipseInf(input, verbose);
		if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_SIGN) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_SIGN)).booleanValue()) {
			if (verbose)
				System.out.println("Excluding " + input.getName() + " from signing."); //$NON-NLS-1$ //$NON-NLS-2$
			return false;
		}
		return true;
	}

	private void normalize(File input, File workingDirectory) {
		try {
			File tempJar = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$




package org.eclipse.update.internal.jarprocessor;

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

/**

	 *  return the file containing the result of the processing
	 * @param input
	 * @param workingDirectory
	 * @param containers: inf properties for containing jars, innermost jar is first on the list
	 * @return
	 */
	public File preProcess(File input, File workingDirectory, List containers);
	
	/**
	 * 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
	 * @param containers: inf properties for containing jars, innermost jar is first on the list
	 * @return
	 */
	public File postProcess(File input, File workingDirectory, List containers);
	
	/**
	 * Return the name of this process step

	 * Adjust any properties in the eclipse.inf as appropriate for this step
	 * @param input
	 * @param inf
	 * @param containers: inf properties for containing jars, innermost jar is first on the list
	 */
	public void adjustInf(File input, Properties inf, List containers);
}

Return to bug 159028

Lines 11-16 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/Main.java (-5 / +24 lines)
11	package org.eclipse.update.internal.jarprocessor;	11	package org.eclipse.update.internal.jarprocessor;
12		12
13	import java.io.*;	13	import java.io.*;
		14	import java.util.Properties;
14	import java.util.zip.ZipException;	15	import java.util.zip.ZipException;
15		16
16	/**	17	/**
Lines 110-116 Link Here
110	}	111	}
111		112
112	public static void runJarProcessor(Options options) {	113	public static void runJarProcessor(Options options) {
113	if (options.input.getName().endsWith(".zip")) { //$NON-NLS-1$	114	if (options.input.isFile() && options.input.getName().endsWith(".zip")) { //$NON-NLS-1$
114	ZipProcessor processor = new ZipProcessor();	115	ZipProcessor processor = new ZipProcessor();
115	processor.setWorkingDirectory(options.outputDir);	116	processor.setWorkingDirectory(options.outputDir);
116	processor.setSignCommand(options.signCommand);	117	processor.setSignCommand(options.signCommand);
Lines 134-149 Link Here
134	processor.setProcessAll(options.processAll);	135	processor.setProcessAll(options.processAll);
135	processor.setVerbose(options.verbose);	136	processor.setVerbose(options.verbose);
136		137
		138	//load options file
		139	Properties properties = null;
		140	if(options.input.isDirectory()){
		141	File packProperties = new File(options.input, "pack.properties");
		142	if(packProperties.exists() && packProperties.isFile()){
		143	InputStream in = null;
		144	try {
		145	in = new BufferedInputStream( new FileInputStream(packProperties));
		146	properties.load(in);
		147	} catch (IOException e) {
		148	if(options.verbose)
		149	e.printStackTrace();
		150	} finally {
		151	Utils.close(in);
		152	}
		153	}
		154	}
		155
137	if (options.repack \|\| (options.pack && options.signCommand != null))	156	if (options.repack \|\| (options.pack && options.signCommand != null))
138	processor.addProcessStep(new PackUnpackStep(null, options.verbose));	157	processor.addProcessStep(new PackUnpackStep(properties, options.verbose));
139		158
140	if (options.signCommand != null)	159	if (options.signCommand != null)
141	processor.addProcessStep(new SignCommandStep(null, options.signCommand, options.verbose));	160	processor.addProcessStep(new SignCommandStep(properties, options.signCommand, options.verbose));
142		161
143	if (options.pack)	162	if (options.pack)
144	processor.addProcessStep(new PackStep(null, options.verbose));	163	processor.addProcessStep(new PackStep(properties, options.verbose));
145	else if (options.unpack)	164	else if (options.unpack)
146	processor.addProcessStep(new UnpackStep(null, options.verbose));	165	processor.addProcessStep(new UnpackStep(properties, options.verbose));
147		166
148	try {	167	try {
149	processor.process(options.input, options.unpack ? Utils.PACK_GZ_FILTER : Utils.JAR_FILTER);	168	processor.process(options.input, options.unpack ? Utils.PACK_GZ_FILTER : Utils.JAR_FILTER);

Lines 24-29 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/JarProcessor.java (-7 / +25 lines)
24	private int depth = -1;	24	private int depth = -1;
25	private boolean verbose = false;	25	private boolean verbose = false;
26	private boolean processAll = false;	26	private boolean processAll = false;
		27	private LinkedList containingInfs = new LinkedList();
27		28
28	static public JarProcessor getUnpackProcessor(Properties properties) {	29	static public JarProcessor getUnpackProcessor(Properties properties) {
29	if (!canPerformUnpack())	30	if (!canPerformUnpack())
Lines 54-60 Link Here
54	}	55	}
55		56
56	public void setWorkingDirectory(String dir) {	57	public void setWorkingDirectory(String dir) {
57	workingDirectory = dir;	58	if(dir != null)
		59	workingDirectory = dir;
58	}	60	}
59		61
60	public void setVerbose(boolean verbose) {	62	public void setVerbose(boolean verbose) {
Lines 169-175 Link Here
169	return result;	171	return result;
170	}	172	}
171		173
172	private void extractEntries(JarFile jar, File tempDir, Map data) throws IOException {	174	private void extractEntries(JarFile jar, File tempDir, Map data, Properties inf) throws IOException {
		175	if(inf != null ) {
		176	//skip if excluding children
		177	if(inf.containsKey(Utils.MARK_EXCLUDE_CHILDREN)){
		178	String excludeChildren = inf.getProperty(Utils.MARK_EXCLUDE_CHILDREN);
		179	if( Boolean.valueOf(excludeChildren).booleanValue() )
		180	if(verbose){
		181	for(int i = 0; i <= depth; i++)
		182	System.out.print(" "); //$NON-NLS-1$
		183	System.out.println("Children of " + jar.getName() + "are excluded from processing.");
		184	}
		185	return;
		186	}
		187	}
		188
173	Enumeration entries = jar.entries();	189	Enumeration entries = jar.entries();
174	if (entries.hasMoreElements()) {	190	if (entries.hasMoreElements()) {
175	for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {	191	for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
Lines 201-210 Link Here
201	data.put(name, newName);	217	data.put(name, newName);
202		218
203	//recurse	219	//recurse
		220	containingInfs.addFirst(inf);
204	String dir = getWorkingDirectory();	221	String dir = getWorkingDirectory();
205	setWorkingDirectory(parentDir.getCanonicalPath());	222	setWorkingDirectory(parentDir.getCanonicalPath());
206	processJar(extracted);	223	processJar(extracted);
207	setWorkingDirectory(dir);	224	setWorkingDirectory(dir);
		225	containingInfs.removeFirst();
208		226
209	//delete the extracted item leaving the recursion result	227	//delete the extracted item leaving the recursion result
210	if (!name.equals(newName))	228	if (!name.equals(newName))
Lines 218-224 Link Here
218	File result = null;	236	File result = null;
219	for (Iterator iter = steps.iterator(); iter.hasNext();) {	237	for (Iterator iter = steps.iterator(); iter.hasNext();) {
220	IProcessStep step = (IProcessStep) iter.next();	238	IProcessStep step = (IProcessStep) iter.next();
221	result = step.preProcess(input, tempDir);	239	result = step.preProcess(input, tempDir, containingInfs);
222	if (result != null)	240	if (result != null)
223	input = result;	241	input = result;
224	}	242	}
Lines 229-235 Link Here
229	File result = null;	247	File result = null;
230	for (Iterator iter = steps.iterator(); iter.hasNext();) {	248	for (Iterator iter = steps.iterator(); iter.hasNext();) {
231	IProcessStep step = (IProcessStep) iter.next();	249	IProcessStep step = (IProcessStep) iter.next();
232	result = step.postProcess(input, tempDir);	250	result = step.postProcess(input, tempDir, containingInfs);
233	if (result != null)	251	if (result != null)
234	input = result;	252	input = result;
235	}	253	}
Lines 239-245 Link Here
239	private void adjustInf(File input, Properties inf) {	257	private void adjustInf(File input, Properties inf) {
240	for (Iterator iter = steps.iterator(); iter.hasNext();) {	258	for (Iterator iter = steps.iterator(); iter.hasNext();) {
241	IProcessStep step = (IProcessStep) iter.next();	259	IProcessStep step = (IProcessStep) iter.next();
242	step.adjustInf(input, inf);	260	step.adjustInf(input, inf, containingInfs);
243	}	261	}
244	}	262	}
245		263
Lines 284-292 Link Here
284		302
285	JarFile jar = new JarFile(workingFile, false);	303	JarFile jar = new JarFile(workingFile, false);
286	Map replacements = new HashMap();	304	Map replacements = new HashMap();
287	extractEntries(jar, tempDir, replacements);	305	Properties inf = Utils.getEclipseInf(workingFile, verbose);
		306	extractEntries(jar, tempDir, replacements, inf);
288		307
289	Properties inf = Utils.getEclipseInf(workingFile);
290	if (inf != null)	308	if (inf != null)
291	adjustInf(workingFile, inf);	309	adjustInf(workingFile, inf);
292		310

Lines 10-18 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/SignCommandStep.java (-12 / +44 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.update.internal.jarprocessor;	11	package org.eclipse.update.internal.jarprocessor;
12		12
13	import java.io.*;	13	import java.io.BufferedInputStream;
14	import java.util.*;	14	import java.io.BufferedOutputStream;
15	import java.util.jar.*;	15	import java.io.File;
		16	import java.io.FileOutputStream;
		17	import java.io.IOException;
		18	import java.io.InputStream;
		19	import java.util.Enumeration;
		20	import java.util.Iterator;
		21	import java.util.List;
		22	import java.util.Properties;
		23	import java.util.Set;
		24	import java.util.jar.JarEntry;
		25	import java.util.jar.JarFile;
		26	import java.util.jar.JarOutputStream;
16		27
17	/**	28	/**
18	* @author aniefer@ca.ibm.com	29	* @author aniefer@ca.ibm.com
Lines 43-63 Link Here
43	/* (non-Javadoc)	54	/* (non-Javadoc)
44	* @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)	55	* @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)
45	*/	56	*/
46	public File preProcess(File input, File workingDirectory) {	57	public File preProcess(File input, File workingDirectory, List containers) {
47	return null;	58	return null;
48	}	59	}
49		60
50	/* (non-Javadoc)	61	/* (non-Javadoc)
51	* @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)	62	* @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
52	*/	63	*/
53	public File postProcess(File input, File workingDirectory) {	64	public File postProcess(File input, File workingDirectory, List containers) {
54	if (command != null) {	65	if (command != null && shouldSign(input, containers)) {
55	Properties inf = Utils.getEclipseInf(input);
56	if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_SIGN) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_SIGN)).booleanValue()) {
57	if(verbose)
58	System.out.println("Excluding " + input.getName() + " from signing."); //$NON-NLS-1$ //$NON-NLS-2$
59	return null;
60	}
61	try {	66	try {
62	String[] cmd = new String[] {command, input.getCanonicalPath()};	67	String[] cmd = new String[] {command, input.getCanonicalPath()};
63	int result = execute(cmd, verbose);	68	int result = execute(cmd, verbose);
Lines 76-81 Link Here
76	return null;	81	return null;
77	}	82	}
78		83
		84	private boolean shouldSign(File input, List containers) {
		85	Properties inf = null;
		86
		87	//1: Are we excluded from signing by our parents?
		88	//innermost jar is first on the list, it overrides outer jars
		89	for (Iterator iterator = containers.iterator(); iterator.hasNext();) {
		90	inf = (Properties) iterator.next();
		91	if (inf.containsKey(Utils.MARK_EXCLUDE_CHILDREN_SIGN)){
		92	if(Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_CHILDREN_SIGN)).booleanValue()) {
		93	if (verbose)
		94	System.out.println(input.getName() + "is excluded from signing by its containers."); //$NON-NLS-1$ //$NON-NLS-2$
		95	return false;
		96	}
		97	break;
		98	}
		99	}
		100
		101	//2: Is this jar itself marked as exclude?
		102	inf = Utils.getEclipseInf(input, verbose);
		103	if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_SIGN) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_SIGN)).booleanValue()) {
		104	if (verbose)
		105	System.out.println("Excluding " + input.getName() + " from signing."); //$NON-NLS-1$ //$NON-NLS-2$
		106	return false;
		107	}
		108	return true;
		109	}
		110
79	private void normalize(File input, File workingDirectory) {	111	private void normalize(File input, File workingDirectory) {
80	try {	112	try {
81	File tempJar = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$	113	File tempJar = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$