Attachment #46045 for bug #146066

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

Lines 11-19 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/IProcessStep.java (-1 / +9 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.Properties;
14		15
15	/**	16	/**
16	* @author aniefer	17	* @author aniefer@ca.ibm.com
17	*	18	*
18	*/	19	*/
19	public interface IProcessStep {	20	public interface IProcessStep {
Lines 50-53 Link Here
50	* @return	51	* @return
51	*/	52	*/
52	public String getStepName();	53	public String getStepName();
		54
		55	/**
		56	* Adjust any properties in the eclipse.inf as appropriate for this step
		57	* @param input
		58	* @param inf
		59	*/
		60	public void adjustInf(File input, Properties inf);
53	}	61	}




import java.util.Set;

/**
 * @author aniefer@ca.ibm.com
 *
 */
public class PackUnpackStep extends PackStep {

	 */
	public File postProcess(File input, File workingDirectory) {
		if (canPack() && packCommand != null) {
			Properties inf = Utils.getEclipseInf(input);
			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 null;
			}
			File tempFile = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$
			try {
				String[] tmp = getCommand(input, tempFile, inf);
				String[] cmd = new String[tmp.length + 1];
				cmd[0] = tmp[0];
				cmd[1] = "-r"; //$NON-NLS-1$

Lines 15-21 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/ZipProcessor.java (-2 / +2 lines)
15	import java.util.zip.*;	15	import java.util.zip.*;
16		16
17	/**	17	/**
18	* @author aniefer	18	* @author aniefer@ca.ibm.com
19	*	19	*
20	*/	20	*/
21	public class ZipProcessor {	21	public class ZipProcessor {
Lines 116-122 Link Here
116	FileOutputStream extracted = new FileOutputStream(extractedFile);	116	FileOutputStream extracted = new FileOutputStream(extractedFile);
117	Utils.transferStreams(entryStream, extracted, true);	117	Utils.transferStreams(entryStream, extracted, true);
118		118
119	boolean skip = !processAll && Utils.isUnmarkedJar(extractedFile);	119	boolean skip = Utils.shouldSkipJar(extractedFile, processAll, verbose);
120	if (skip) {	120	if (skip) {
121	//skipping this file	121	//skipping this file
122	entryStream = new FileInputStream(extractedFile);	122	entryStream = new FileInputStream(extractedFile);

Lines 15-26 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/Utils.java (-20 / +72 lines)
15	import java.util.jar.*;	15	import java.util.jar.*;
16		16
17	/**	17	/**
18	* @author aniefer	18	* @author aniefer@ca.ibm.com
19	*	19	*
20	*/	20	*/
21	public class Utils {	21	public class Utils {
		22	public static final String SIGN_EXCLUDES = "sign.excludes"; //$NON-NLS-1$
		23	public static final String PACK_EXCLUDES = "pack.excludes"; //$NON-NLS-1$
22	public static final String MARK_FILE_NAME = "META-INF/eclipse.inf"; //$NON-NLS-1$	24	public static final String MARK_FILE_NAME = "META-INF/eclipse.inf"; //$NON-NLS-1$
23	public static final String MARK_PROPERTY = "pack200.conditioned"; //$NON-NLS-1$	25	public static final String MARK_PROPERTY = "pack200.conditioned"; //$NON-NLS-1$
		26	public static final String MARK_EXCLUDE = "jarprocessor.exclude"; //$NON-NLS-1$
		27	public static final String MARK_EXCLUDE_PACK = "jarprocessor.exclude.pack"; //$NON-NLS-1$
		28	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$
		30	public static final String PACK_ARGS = "pack200.args"; //$NON-NLS-1$
		31
24	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$	32	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$
25	public static final String JRE = "@jre"; //$NON-NLS-1$	33	public static final String JRE = "@jre"; //$NON-NLS-1$
26	public static final String PATH = "@path"; //$NON-NLS-1$	34	public static final String PATH = "@path"; //$NON-NLS-1$
Lines 151-157 Link Here
151	if (properties == null)	159	if (properties == null)
152	return Collections.EMPTY_SET;	160	return Collections.EMPTY_SET;
153		161
154	String packExcludes = properties.getProperty("pack.excludes"); //$NON-NLS-1$	162	String packExcludes = properties.getProperty(PACK_EXCLUDES);
155	if (packExcludes != null) {	163	if (packExcludes != null) {
156	String[] excludes = toStringArray(packExcludes, ","); //$NON-NLS-1$	164	String[] excludes = toStringArray(packExcludes, ","); //$NON-NLS-1$
157	Set packExclusions = new HashSet();	165	Set packExclusions = new HashSet();
Lines 166-172 Link Here
166	public static Set getSignExclusions(Properties properties) {	174	public static Set getSignExclusions(Properties properties) {
167	if (properties == null)	175	if (properties == null)
168	return Collections.EMPTY_SET;	176	return Collections.EMPTY_SET;
169	String signExcludes = properties.getProperty("sign.excludes"); //$NON-NLS-1$	177	String signExcludes = properties.getProperty(SIGN_EXCLUDES);
170	if (signExcludes != null) {	178	if (signExcludes != null) {
171	String[] excludes = toStringArray(signExcludes, ","); //$NON-NLS-1$	179	String[] excludes = toStringArray(signExcludes, ","); //$NON-NLS-1$
172	Set signExclusions = new HashSet();	180	Set signExclusions = new HashSet();
Lines 193-232 Link Here
193	int count = tokenizer.countTokens();	201	int count = tokenizer.countTokens();
194	String[] result = new String[count];	202	String[] result = new String[count];
195	for (int i = 0; i < count; i++) {	203	for (int i = 0; i < count; i++) {
196	result[i] = tokenizer.nextToken();	204	result[i] = tokenizer.nextToken().trim();
197	}	205	}
198	return result;	206	return result;
199	}	207	}
200		208
201	public static boolean isUnmarkedJar(File jarFile) {	209	/**
202	if(jarFile == null \|\| !jarFile.exists())	210	* Get the properties from the eclipse.inf file from the given jar. If the file is not a jar, null is returned.
203	return false;	211	* If the file is a jar, but does not contain an eclipse.inf file, an empty Properties object is returned.
204		212	* @param jarFile
205	boolean result = true;	213	* @return
206	JarFile jar = null;	214	*/
		215	public static Properties getEclipseInf(File jarFile) {
		216	if (jarFile == null \|\| !jarFile.exists())
		217	return null;
207		218
		219	JarFile jar = null;
208	try {	220	try {
209	jar = new JarFile(jarFile, false);	221	jar = new JarFile(jarFile, false);
210	} catch (IOException e1) {
211	//not a jar
212	return false;
213	}
214
215	try {
216	JarEntry mark = jar.getJarEntry(MARK_FILE_NAME);	222	JarEntry mark = jar.getJarEntry(MARK_FILE_NAME);
217	if (mark != null) {	223	if (mark != null) {
218	InputStream in = jar.getInputStream(mark);	224	InputStream in = jar.getInputStream(mark);
219	Properties props = new Properties();	225	Properties props = new Properties();
220	props.load(in);	226	props.load(in);
221	in.close();	227	in.close();
222	String value = props.getProperty(MARK_PROPERTY);	228	return props;
223	result = !Boolean.valueOf(value).booleanValue();
224	}	229	}
		230	return new Properties();
225	} catch (IOException e) {	231	} catch (IOException e) {
226	return false;	232	//not a jar
227	} finally {	233	} finally {
228	close(jar);	234	close(jar);
229	}	235	}
230	return result;	236	return null;
		237	}
		238
		239	public static boolean shouldSkipJar(File input, boolean processAll, boolean verbose) {
		240	Properties inf = getEclipseInf(input);
		241	if (inf == null) {
		242	//not a jar, could be a pack.gz
		243	return false;
		244	}
		245	String exclude = inf.getProperty(MARK_EXCLUDE);
		246
		247	//was marked as exclude, we should skip
		248	if (exclude != null && Boolean.valueOf(exclude).booleanValue())
		249	return true;
		250
		251	//process all was set, don't skip
		252	if (processAll)
		253	return false;
		254
		255	//otherwise, we skip if not marked marked
		256	String marked = inf.getProperty(MARK_PROPERTY);
		257	boolean skip = !Boolean.valueOf(marked).booleanValue();
		258
		259	String version = inf.getProperty(MARK_JARPROCESSOR_VERSION);
		260	if (marked != null && verbose) {
		261	if (version == null) {
		262	//no version == 1.0.0
		263	version = "1.0.0"; //$NON-NLS-1$
		264	}
		265	if (!JarProcessor.PROCESSOR_VERSION.equals(version)) {
		266	System.out.println("Warning: " + input.getName() + " was conditioned with JarProcessor version " + version); //$NON-NLS-1$ //$NON-NLS-2$
		267	}
		268	}
		269	return skip;
		270	}
		271
		272	public static void storeProperties(Properties props, OutputStream stream) {
		273	PrintStream printStream = new PrintStream(stream);
		274	printStream.println("#Processed using Jarprocessor version " + JarProcessor.PROCESSOR_VERSION); //$NON-NLS-1$
		275	SortedMap sorted = new TreeMap(props);
		276	for (Iterator iter = sorted.keySet().iterator(); iter.hasNext();) {
		277	String key = (String) iter.next();
		278	printStream.print(key);
		279	printStream.print(" = "); //$NON-NLS-1$
		280	printStream.println(sorted.get(key));
		281	}
		282	printStream.flush();
231	}	283	}
232	}	284	}

Lines 15-21 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/SignCommandStep.java (-1 / +7 lines)
15	import java.util.jar.*;	15	import java.util.jar.*;
16		16
17	/**	17	/**
18	* @author aniefer	18	* @author aniefer@ca.ibm.com
19	*	19	*
20	*/	20	*/
21	public class SignCommandStep extends CommandStep {	21	public class SignCommandStep extends CommandStep {
Lines 52-57 Link Here
52	*/	52	*/
53	public File postProcess(File input, File workingDirectory) {	53	public File postProcess(File input, File workingDirectory) {
54	if (command != null) {	54	if (command != null) {
		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	}
55	try {	61	try {
56	String[] cmd = new String[] {command, input.getCanonicalPath()};	62	String[] cmd = new String[] {command, input.getCanonicalPath()};
57	int result = execute(cmd, verbose);	63	int result = execute(cmd, verbose);

Lines 10-19 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/CommandStep.java (-1 / +6 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.update.internal.jarprocessor;	11	package org.eclipse.update.internal.jarprocessor;
12		12
		13	import java.io.File;
13	import java.util.Properties;	14	import java.util.Properties;
14		15
15	/**	16	/**
16	* @author aniefer	17	* @author aniefer@ca.ibm.com
17	*	18	*
18	*/	19	*/
19	public abstract class CommandStep implements IProcessStep {	20	public abstract class CommandStep implements IProcessStep {
Lines 60-63 Link Here
60	options = new Properties();	61	options = new Properties();
61	return options;	62	return options;
62	}	63	}
		64
		65	public void adjustInf(File input, Properties inf) {
		66	//nothing
		67	}
63	}	68	}




import java.util.jar.*;

/**
 * @author aniefer@ca.ibm.com
 *
 */
public class JarProcessor {
	public static final String PROCESSOR_VERSION = "1.0.1"; //$NON-NLS-1$
	private List steps = new ArrayList();
	private String workingDirectory = ""; //$NON-NLS-1$
	private int depth = -1;
	private boolean verbose = false;
	private boolean processAll = false;
	private boolean shouldMarkJars = false;

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


	public void addProcessStep(IProcessStep step) {
		steps.add(step);
		if(step instanceof PackUnpackStep)
			shouldMarkJars = true;
	}

	public void clearProcessSteps() {
		steps.clear();
		shouldMarkJars = false;
	}

	public void process(File input, FileFilter filter) throws FileNotFoundException {

	 * @param directory - location to find file for new entryName
	 * @throws IOException
	 */
	private void recreateJar(JarFile jar, JarOutputStream outputJar, Map replacements, File directory, Properties inf) throws IOException {
		inf.put(Utils.MARK_JARPROCESSOR_VERSION, PROCESSOR_VERSION);

		InputStream in = null;
		boolean marked = false;
		try {

				}
				newEntry.setTime(entry.getTime());
				outputJar.putNextEntry(newEntry);
				if (entry.getName().equals(Utils.MARK_FILE_NAME)) {
					Utils.storeProperties(inf, outputJar);
					props.load(in);
					String val = props.getProperty(Utils.MARK_PROPERTY);
					if(val == null || !Boolean.valueOf(val).booleanValue())
						props.setProperty(Utils.MARK_PROPERTY, "true"); //$NON-NLS-1$
					props.store(outputJar, null);
					marked = true;
				} else {
					Utils.transferStreams(in, outputJar, false);

					replacement.delete();
				}
			}
			if (!marked) {
				JarEntry entry = new JarEntry(Utils.MARK_FILE_NAME);
				Properties props = new Properties();
				props.setProperty(Utils.MARK_PROPERTY, "true"); //$NON-NLS-1$
				outputJar.putNextEntry(entry);
				Utils.storeProperties(inf, outputJar);
				outputJar.closeEntry();
			}
		} finally {

		return input;
	}

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

	public void processJar(File input) throws IOException {
		++depth;
		long lastModified = input.lastModified();

		if (!workingDir.exists())
			workingDir.mkdirs();

		boolean skip = Utils.shouldSkipJar(input, processAll, verbose);
		if (depth == 0 && verbose) {
			if (skip)
				System.out.println("Skipping " + input.getPath()); //$NON-NLS-1$

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

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

		//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;

		if (!parent.exists())
			parent.mkdirs();
		JarOutputStream jarOut = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(tempJar)));
		recreateJar(jar, jarOut, replacements, tempDir, inf);

		jar.close();
		if (tempJar != null) {

Lines 71-79 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/PackStep.java (-4 / +32 lines)
71		71
72	public File postProcess(File input, File workingDirectory) {	72	public File postProcess(File input, File workingDirectory) {
73	if (canPack() && packCommand != null) {	73	if (canPack() && packCommand != null) {
		74	Properties inf = Utils.getEclipseInf(input);
		75	if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_PACK) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_PACK)).booleanValue()) {
		76	if(verbose)
		77	System.out.println("Excluding " + input.getName() + " from " + getStepName()); //$NON-NLS-1$ //$NON-NLS-2$
		78	return null;
		79	}
74	File outputFile = new File(workingDirectory, input.getName() + Utils.PACKED_SUFFIX);	80	File outputFile = new File(workingDirectory, input.getName() + Utils.PACKED_SUFFIX);
75	try {	81	try {
76	String[] cmd = getCommand(input, outputFile);	82	String[] cmd = getCommand(input, outputFile, inf);
77	int result = execute(cmd, verbose);	83	int result = execute(cmd, verbose);
78	if (result != 0 && verbose)	84	if (result != 0 && verbose)
79	System.out.println("Error: " + result + " was returned from command: " + Utils.concat(cmd)); //$NON-NLS-1$ //$NON-NLS-2$	85	System.out.println("Error: " + result + " was returned from command: " + Utils.concat(cmd)); //$NON-NLS-1$ //$NON-NLS-2$
Lines 87-96 Link Here
87	return null;	93	return null;
88	}	94	}
89		95
90	protected String[] getCommand(File input, File outputFile) throws IOException {	96	protected String[] getCommand(File input, File outputFile, Properties inf) throws IOException {
91	String[] cmd = null;	97	String[] cmd = null;
92	String arguments = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$	98	String arguments = null;
93	if (arguments != null) {	99	if (inf != null && inf.containsKey(Utils.PACK_ARGS)) {
		100	arguments = inf.getProperty(Utils.PACK_ARGS);
		101	} else {
		102	arguments = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$
		103	}
		104	if (arguments != null && arguments.length() > 0) {
94	String[] args = Utils.toStringArray(arguments, ","); //$NON-NLS-1$	105	String[] args = Utils.toStringArray(arguments, ","); //$NON-NLS-1$
95	cmd = new String[3 + args.length];	106	cmd = new String[3 + args.length];
96	cmd[0] = packCommand;	107	cmd[0] = packCommand;
Lines 106-109 Link Here
106	public String getStepName() {	117	public String getStepName() {
107	return "Pack"; //$NON-NLS-1$	118	return "Pack"; //$NON-NLS-1$
108	}	119	}
		120
		121	public void adjustInf(File input, Properties inf) {
		122	if (input == null \|\| inf == null)
		123	return;
		124
		125	if (inf.containsKey(Utils.MARK_EXCLUDE_PACK) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_PACK)).booleanValue()) {
		126	return;
		127	}
		128
		129	inf.put(Utils.MARK_PROPERTY, "true"); //$NON-NLS-1$
		130	String arguments = inf.getProperty(Utils.PACK_ARGS);
		131	if (arguments == null) {
		132	arguments = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$
		133	if (arguments != null)
		134	inf.put(Utils.PACK_ARGS, arguments);
		135	}
		136	}
109	}	137	}

Return to bug 146066

Lines 16-22 Link Here

(-)src/org/eclipse/update/internal/jarprocessor/PackUnpackStep.java (-2 / +8 lines)
16	import java.util.Set;	16	import java.util.Set;
17		17
18	/**	18	/**
19	* @author aniefer	19	* @author aniefer@ca.ibm.com
20	*	20	*
21	*/	21	*/
22	public class PackUnpackStep extends PackStep {	22	public class PackUnpackStep extends PackStep {
Lines 44-52 Link Here
44	*/	44	*/
45	public File postProcess(File input, File workingDirectory) {	45	public File postProcess(File input, File workingDirectory) {
46	if (canPack() && packCommand != null) {	46	if (canPack() && packCommand != null) {
		47	Properties inf = Utils.getEclipseInf(input);
		48	if (inf != null && inf.containsKey(Utils.MARK_EXCLUDE_PACK) && Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_PACK)).booleanValue()) {
		49	if (verbose)
		50	System.out.println("Excluding " + input.getName() + " from " + getStepName()); //$NON-NLS-1$ //$NON-NLS-2$
		51	return null;
		52	}
47	File tempFile = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$	53	File tempFile = new File(workingDirectory, "temp_" + input.getName()); //$NON-NLS-1$
48	try {	54	try {
49	String[] tmp = getCommand(input, tempFile);	55	String[] tmp = getCommand(input, tempFile, inf);
50	String[] cmd = new String[tmp.length + 1];	56	String[] cmd = new String[tmp.length + 1];
51	cmd[0] = tmp[0];	57	cmd[0] = tmp[0];
52	cmd[1] = "-r"; //$NON-NLS-1$	58	cmd[1] = "-r"; //$NON-NLS-1$