Attachment #37769 for bug #127375

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





	// hashtable of locks
	private static Hashtable locks = new Hashtable();
	
	protected static Object getLock(String key) {
		synchronized (lock) {
			if (locks.get(key) == null)
				locks.put(key, key);
			return locks.get(key);
		}
	}
	
	/**
	 * Feature content provider constructor
	 * 

		// is still copying into it
		File localFile = null;
		FileFragment localFileFragment = null;
		Object keyLock = 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) {




 *******************************************************************************/
package org.eclipse.update.internal.core;
import java.io.*;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.*;
import org.eclipse.update.core.model.SiteModel;
import org.eclipse.update.internal.security.JarVerifier;
import org.eclipse.update.jarprocessor.JarProcessor;

/**
 * Content Provider of a Feature Package

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

		return jarVerifier;
	}

	public void setFeature(IFeature feature) {
		super.setFeature(feature);
		ISite featureSite = feature.getSite();
		if(featureSite instanceof SiteModel){
			siteModel = (SiteModel) 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 = 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()))
					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) {
			Object packedLock = getLock(packedRef.toString());
			synchronized (packedLock) {
				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);
			}
		}
		return packedRef;
	}
	/*
	 * @see IFeatureContentProvider#getNonPluginEntryArchiveReferences(INonPluginEntry)
	 */




	private URL locationURL;
	private String mirrorsURLString;
	private ConfiguredSiteModel configuredSiteModel;
	private boolean pack200 = false;

	/**
	 * Creates an uninitialized site model object.

		assertIsWriteable();
		this.mirrorsURLString = mirrorsURL;
	}
	
	/**
	 * Get whether or not this site may contain jars packed with pack200.
	 * The packed version of foo.jar, is expected to be foo.jar.pack.gz
	 * @return
	 */
	public boolean supportsPack200() {
		return pack200;
	}
	
	/**
	 * Set whether or not this site may contain jars packed with pack200
	 * The packed version of foo.jar is expected to be foo.jar.pack.gz
	 * @param pack
	 */
	public void setSupportsPack200(boolean pack){
		pack200 = pack;
	}
}

Lines 513-518 Link Here

(-)src/org/eclipse/update/core/model/DefaultSiteParser.java (+5 lines)
513	site.setMirrorsURLString(mirrorsURL);	513	site.setMirrorsURLString(mirrorsURL);
514	}	514	}
515		515
		516	String pack200 = attributes.getValue("pack200"); //$NON-NLS-1$
		517	if(pack200 != null && new Boolean(pack200).booleanValue()){
		518	site.setSupportsPack200(true);
		519	}
		520
516	if ( (site instanceof ExtendedSite) && (Boolean.getBoolean(attributes.getValue("digestURL")))) { //$NON-NLS-1$	521	if ( (site instanceof ExtendedSite) && (Boolean.getBoolean(attributes.getValue("digestURL")))) { //$NON-NLS-1$
517	ExtendedSite extendedSite = (ExtendedSite) site;	522	ExtendedSite extendedSite = (ExtendedSite) site;
518	extendedSite.setDigestExist(true);	523	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.jarprocessor.internal;

import java.io.File;
import java.io.IOException;
import java.util.Properties;
import org.eclipse.update.jarprocessor.IProcessStep;

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

	/* (non-Javadoc)
	 * @see org.eclipse.update.jarprocessor.IProcessStep#recursionEffect(java.lang.String)
	 */
	public String recursionEffect(String entryName) {
		if (entryName.endsWith(extension))
			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)
					return input;
			} catch (IOException e) {
				//boo
				e.printStackTrace();
			}
		}
		return input;
	}

	public 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.jarprocessor;

import java.io.*;
import java.util.zip.ZipException;
import org.eclipse.update.jarprocessor.internal.*;

/**
 * @author aniefer
 *
 */
public class Main {
	private static final String OUTPUT = "-outputDir="; //$NON-NLS-1$
	private static final String COMMAND = "-signCommand="; //$NON-NLS-1$

	private static String outputDir = null;
	private static String command = null;
	
	private static void printUsage(){
		System.out.println(" -pack [-signCommand=value] [-outputDir=value] input"); //$NON-NLS-1$
		System.out.println("\tPack the input jars.  If signCommand is specified, then the jars are first repacked and signed using that command"); //$NON-NLS-1$
		System.out.println("\tIf input is a directory, all contained jars are packed, subdirectories are visited recursively."); //$NON-NLS-1$
		System.out.println("\tThe signCommand will be executed with 1 argument that is the file to sign."); //$NON-NLS-1$
		System.out.println();
		System.out.println("-unpack [-outputDir=value] input"); //$NON-NLS-1$
		System.out.println("\tUnpack the input pack.gz files"); //$NON-NLS-1$
		System.out.println();
		System.out.println("[-outputDir=value] input.zip"); //$NON-NLS-1$
		System.out.println("\tCreate an outputDir/input.zip file containing processed repacked, signed & optionally packed versions of jars found"); //$NON-NLS-1$
		System.out.println("\tin input.zip"); //$NON-NLS-1$
	}
	
	private static void processZipFile(File zip){
		ZipProcessor processor = new ZipProcessor();
		processor.setWorkingDirectory(outputDir);
		processor.setCommand(command);
		try {
			processor.processZip(zip);
		} catch (ZipException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		boolean packing = true;
		
		outputDir = "."; //$NON-NLS-1$

		if (args.length == 0) {
			printUsage();
			return;
		}
			
		int i = 0;
		for (; i < args.length - 1; i++) {
			if(args[i].equals("-pack")) {//$NON-NLS-1$
				packing = true;
			} else if( args[i].equals("-unpack")) { //$NON-NLS-1$
				packing = false;
			} else if(args[i].startsWith(COMMAND) && args[i].length() > COMMAND.length()) {
				command = args[i].substring(COMMAND.length()).trim();
			} else 	if (args[i].startsWith(OUTPUT)) {
				outputDir=args[i].substring(OUTPUT.length()).trim();
			}
		}
		File input = new File(args[i]);
		
		if(input.getName().endsWith(".zip")){ //$NON-NLS-1$
			processZipFile(input);
		} else {
			try {
				if(packing) {
					if(!JarProcessor.canPerformPack()){
						System.out.println("Cannot find a pack200 executable."); //$NON-NLS-1$
						return;
					}
					JarProcessor processor = new JarProcessor();
					processor.setWorkingDirectory(outputDir);
					processor.addProcessStep( command != null ? (IProcessStep) new PackUnpackStep(null) : (IProcessStep) new PackStep(null));
					if(command != null){
						processor.addProcessStep(new CommandStep(null, command, ".jar")); //$NON-NLS-1$
						processor.addProcessStep(new PackStep(null));
					}
					processor.process(input, Utils.JAR_FILTER);
				} else {
					if(!JarProcessor.canPerformUnpack()){
						System.out.println("Cannot find a unpack200 exectuable."); //$NON-NLS-1$
						return;
					}
					JarProcessor processor = new JarProcessor();
					processor.setWorkingDirectory(outputDir);
					processor.addProcessStep(new UnpackStep(null));
					processor.process(input, Utils.PACK_GZ_FILTER);
				}
			} catch (FileNotFoundException e ){
				System.out.println(e.getLocalizedMessage());
			}
		}
	}

}




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

import java.io.*;
import java.util.*;
import java.util.zip.*;
import org.eclipse.update.jarprocessor.IProcessStep;
import org.eclipse.update.jarprocessor.JarProcessor;

/**
 * @author aniefer
 *
 */
public class ZipProcessor {
	
	private IProcessStep signStep = null;
	private IProcessStep packStep = null;
	private IProcessStep packUnpackStep = 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 = true;
	private boolean repacking = true;

	public void setWorkingDirectory(String dir) {
		workingDirectory = dir;
	}
	
	public String getWorkingDirectory() {
		if(workingDirectory == null)
			workingDirectory = "."; //$NON-NLS-1$
		return workingDirectory;
	}
	
	public void setCommand(String command){
		this.command = command;
	}
	
	public void processZip(File zipFile) throws ZipException, IOException {
		ZipFile zip = new ZipFile(zipFile);
		initialize(zip);

		File tempDir = new File(getWorkingDirectory(), "temp_" + zipFile.getName()); //$NON-NLS-1$
		JarProcessor processor = new JarProcessor();
		processor.setWorkingDirectory(tempDir.getCanonicalPath());

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

				File extractedFile = null;
				if (entry.getName().endsWith(".jar") && (pack || sign)) { //$NON-NLS-1$
					extractedFile = new File(tempDir, entry.getName());
					parent = extractedFile.getParentFile();
					if (!parent.exists())
						parent.mkdirs();
					FileOutputStream extracted = new FileOutputStream(extractedFile);
					Utils.transferStreams(entryStream, extracted, true);

					processor.clearProcessSteps();
					if(repacking || pack)
						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() + ".pack.gz"); //$NON-NLS-1$
						ZipEntry zipEntry = new ZipEntry(name + ".pack.gz"); //$NON-NLS-1$
						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);
			}
		}
		String pack = properties.getProperty("packing"); //$NON-NLS-1$
		packing = (pack != null && Boolean.valueOf(pack).booleanValue());
		String sign = properties.getProperty("signing"); //$NON-NLS-1$
		signing = (sign == null || Boolean.valueOf(sign).booleanValue());
		String repack = properties.getProperty("repacking"); //$NON-NLS-1$
		repacking = (repack == null || Boolean.valueOf(repack).booleanValue());
		
		String packExcludes = properties.getProperty("pack.excludes"); //$NON-NLS-1$
		if (packExcludes != null) {
			String[] excludes = packExcludes.split(",\\s*"); //$NON-NLS-1$
			packExclusions = new HashSet();
			for (int i = 0; i < excludes.length; i++) {
				packExclusions.add(excludes[i]);
			}
		} else {
			packExclusions = Collections.EMPTY_SET;
		}

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

		packUnpackStep = new PackUnpackStep(properties);
		packStep = new PackStep(properties);
		signStep = new CommandStep(properties, command, ".jar"); //$NON-NLS-1$

	}
}




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

import java.io.*;
import java.util.jar.JarFile;
import org.eclipse.update.jarprocessor.JarProcessor;

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

	public static final String PACKED_SUFFIX = ".pack.gz"; //$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(JarProcessor.PACK200_PROPERTY);
		String javaHome = System.getProperty("java.home"); //$NON-NLS-1$
		if (JarProcessor.NONE.equals(prop)) {
			return null;
		} else if (JarProcessor.JRE.equals(prop)) {
			locations = new String[] {javaHome + "/bin/" + cmd}; //$NON-NLS-1$
		} else if (JarProcessor.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;
	}
}




/*******************************************************************************
 * 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.jarprocessor;

import java.io.*;
import java.util.*;
import java.util.jar.*;
import org.eclipse.update.jarprocessor.internal.*;

/**
 * @author aniefer
 *
 */
public class JarProcessor {
	/**
	 * The system property "org.eclipse.update.jarprocessor.pack200".  Set to the location in which to look for the
	 * pack200/unpack200 executables. 
	 * Possible values are:
	 *  "@jre": look for the executables in java.home/bin
	 *  "@path": look for the executables in the system search path
	 *  "@none": don't use pack200
	 *  dir : a directory containing pack200 & unpack200 executables 
	 */
	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$
	
	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());// + Utils.PACKED_SUFFIX;
					replacement = new File(directory, name);
					in = new FileInputStream(replacement);
					newEntry = new JarEntry(name);
					//long time = entry.getTime();
//					entry = new JarEntry(name);
//					entry.setTime(time);
				} else {
					in = jar.getInputStream(entry);
					newEntry = new JarEntry(entry.getName());
					//entry.setCompressedSize(-1);
				}
				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;
					FileOutputStream out = null;
					try {
						in = jar.getInputStream(entry);
						out = new FileOutputStream(extracted);
						Utils.transferStreams(in, out, true); //this will close both streams
					} finally {
						Utils.close(in);
						Utils.close(out);
					}
					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;
		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$
		}
//		if(depth == 0){
//			JarFile jar = new JarFile(workingFile, false);
//			Map replacements = new HashMap();
//			extractEntries(jar, tempDir, replacements);
//			
//			//Recreate the jar with replacements
//			File tempJar = null;
//			if(replacements.size() > 0) {
//				tempJar = new File(tempDir, workingFile.getName());
//				File parent = tempJar.getParentFile();
//				if(!parent.exists())
//					parent.mkdirs();
//				JarOutputStream jarOut = new JarOutputStream(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);
		
		--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.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.jarprocessor.internal;

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

/**
 * @author aniefer
 *
 */
public class PackUnpackStep extends PackStep {
//	private PackStep pack = null;
//	private UnpackStep unpack = null;
	
	public PackUnpackStep(Properties options) {
		super(options);
//		pack = new PackStep(options);
//		unpack = new UnpackStep(options);
	}

	public String recursionEffect(String entryName) {
		if (canPack() && entryName.endsWith(".jar")) { //$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() && command != 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;
	}
//	public File postProcess(File input, File workingDirectory){
//		if(PackStep.canPack() && UnpackStep.canUnpack() ){
//			File packed = pack.postProcess(input, workingDirectory);
//			return unpack.preProcess(packed, workingDirectory);
//		}
//		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.jarprocessor.internal;

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 command = 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;
			command = 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) {
					command = 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() && command != 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[] {command, options, input.getCanonicalPath(), unpacked.getCanonicalPath()};
					} else {
						cmd = new String[] {command, 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;
	}
}




/*******************************************************************************
 * 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.jarprocessor.internal;

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

public class PackStep extends CommandStep {

	protected static String command = 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;
			command = 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) {
					command = 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);
	}

	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() && command != 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 options = getOptions().getProperty(input.getName() + ".pack.args"); //$NON-NLS-1$
		if (options != null) {
			String[] args = options.split(",\\s*"); //$NON-NLS-1$
			cmd = new String[3 + args.length];
			cmd[0] = command;
			System.arraycopy(args, 0, cmd, 1, args.length);
			cmd[cmd.length - 2] = outputFile.getCanonicalPath();
			cmd[cmd.length - 1] = input.getCanonicalPath();
		} else {
			cmd = new String[] {command, outputFile.getCanonicalPath(), input.getCanonicalPath()};
		}
		return cmd;
	}
}

Return to bug 127375

Lines 109-115 Link Here

(-)src/org/eclipse/update/core/FeatureContentProvider.java (-8 / +10 lines)
109		109
110	// hashtable of locks	110	// hashtable of locks
111	private static Hashtable locks = new Hashtable();	111	private static Hashtable locks = new Hashtable();
112		112
		113	protected static Object getLock(String key) {
		114	synchronized (lock) {
		115	if (locks.get(key) == null)
		116	locks.put(key, key);
		117	return locks.get(key);
		118	}
		119	}
		120
113	/**	121	/**
114	* Feature content provider constructor	122	* Feature content provider constructor
115	*	123	*
Lines 179-191 Link Here
179	// is still copying into it	187	// is still copying into it
180	File localFile = null;	188	File localFile = null;
181	FileFragment localFileFragment = null;	189	FileFragment localFileFragment = null;
182	Object keyLock = null;	190	Object keyLock = getLock(key);
183	synchronized (lock) {
184	if (locks.get(key) == null)
185	locks.put(key, key);
186	keyLock = locks.get(key);
187	}
188
189	synchronized (keyLock) {	191	synchronized (keyLock) {
190	localFile = Utilities.lookupLocalFile(key);	192	localFile = Utilities.lookupLocalFile(key);
191	if (localFile != null) {	193	if (localFile != null) {

Lines 45-50 Link Here

(-)src/org/eclipse/update/core/model/SiteModel.java (+19 lines)
45	private URL locationURL;	45	private URL locationURL;
46	private String mirrorsURLString;	46	private String mirrorsURLString;
47	private ConfiguredSiteModel configuredSiteModel;	47	private ConfiguredSiteModel configuredSiteModel;
		48	private boolean pack200 = false;
48		49
49	/**	50	/**
50	* Creates an uninitialized site model object.	51	* Creates an uninitialized site model object.
Lines 447-450 Link Here
447	assertIsWriteable();	448	assertIsWriteable();
448	this.mirrorsURLString = mirrorsURL;	449	this.mirrorsURLString = mirrorsURL;
449	}	450	}
		451
		452	/**
		453	* Get whether or not this site may contain jars packed with pack200.
		454	* The packed version of foo.jar, is expected to be foo.jar.pack.gz
		455	* @return
		456	*/
		457	public boolean supportsPack200() {
		458	return pack200;
		459	}
		460
		461	/**
		462	* Set whether or not this site may contain jars packed with pack200
		463	* The packed version of foo.jar is expected to be foo.jar.pack.gz
		464	* @param pack
		465	*/
		466	public void setSupportsPack200(boolean pack){
		467	pack200 = pack;
		468	}
450	}	469	}

Lines 10-22 Link Here

(-)src/org/eclipse/update/internal/core/FeaturePackagedContentProvider.java (-6 / +65 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.update.internal.core;	11	package org.eclipse.update.internal.core;
12	import java.io.*;	12	import java.io.*;
13	import java.net.*;	13	import java.net.URL;
14	import java.util.*;	14	import java.util.*;
15		15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.core.runtime.*;
17	import org.eclipse.osgi.util.NLS;	16	import org.eclipse.osgi.util.NLS;
18	import org.eclipse.update.core.*;	17	import org.eclipse.update.core.*;
19	import org.eclipse.update.internal.security.*;	18	import org.eclipse.update.core.model.SiteModel;
		19	import org.eclipse.update.internal.security.JarVerifier;
		20	import org.eclipse.update.jarprocessor.JarProcessor;
20		21
21	/**	22	/**
22	* Content Provider of a Feature Package	23	* Content Provider of a Feature Package
Lines 26-32 Link Here
26	private ContentReference localManifest = null;	27	private ContentReference localManifest = null;
27	private ContentReference[] localFeatureFiles = new ContentReference[0];	28	private ContentReference[] localFeatureFiles = new ContentReference[0];
28	private IVerifier jarVerifier = null;	29	private IVerifier jarVerifier = null;
29		30	private SiteModel siteModel = null;
30	/*	31	/*
31	* filter for file with .jar	32	* filter for file with .jar
32	*/	33	*/
Lines 58-63 Link Here
58	return jarVerifier;	59	return jarVerifier;
59	}	60	}
60		61
		62	public void setFeature(IFeature feature) {
		63	super.setFeature(feature);
		64	ISite featureSite = feature.getSite();
		65	if(featureSite instanceof SiteModel){
		66	siteModel = (SiteModel) featureSite;
		67	}
		68	}
61	/*	69	/*
62	* @see IFeatureContentProvider#getFeatureManifestReference()	70	* @see IFeatureContentProvider#getFeatureManifestReference()
63	*/	71	*/
Lines 162-174 Link Here
162	URL url = (siteContentProvider == null) ? null : siteContentProvider.getArchiveReference(archiveID);	170	URL url = (siteContentProvider == null) ? null : siteContentProvider.getArchiveReference(archiveID);
163		171
164	try {	172	try {
165	references[0] = asLocalReference(new JarContentReference(archiveID, url), monitor);	173	references[0] = retrieveLocalJar(new JarContentReference(archiveID, url), monitor);
166	} catch (IOException e) {	174	} catch (IOException e) {
167	throw errorRetrieving(archiveID, references[0], e);	175	throw errorRetrieving(archiveID, references[0], e);
168	}	176	}
169	return references;	177	return references;
170	}	178	}
171		179
		180	private ContentReference retrieveLocalJar(JarContentReference reference, InstallMonitor monitor) throws IOException, CoreException {
		181	//If the site does not support pack200, just get the jar as normal
		182	if(siteModel == null \|\| !siteModel.supportsPack200() \|\| !JarProcessor.canPerformUnpack()) {
		183	return asLocalReference(reference, monitor);
		184	}
		185
		186	ContentReference packedRef = null;
		187	String key = reference.toString();
		188	Object jarLock = getLock(key);
		189	synchronized (jarLock) {
		190	//do we have this jar already?
		191	File localFile = Utilities.lookupLocalFile(key);
		192	if (localFile != null) {
		193	// check if the cached file is still valid (no newer version on server)
		194	if (UpdateManagerUtils.isSameTimestamp(reference.asURL(), localFile.lastModified()))
		195	return reference.createContentReference(reference.getIdentifier(), localFile);
		196	}
		197
		198	try {
		199	//don't have jar, check for pack.gz
		200	URL packGZURL = new URL(reference.asURL().toExternalForm() + ".pack.gz"); //$NON-NLS-1$
		201	packedRef = asLocalReference(new JarContentReference(reference.getIdentifier(), packGZURL), monitor);
		202	} catch (IOException e) {
		203	//no pack.gz
		204	}
		205	}
		206	if (packedRef == null) {
		207	//no pack.gz on server, get normal jar
		208	return asLocalReference(reference, monitor);
		209	}
		210
		211	synchronized (jarLock) {
		212	Object packedLock = getLock(packedRef.toString());
		213	synchronized (packedLock) {
		214	File tempFile = packedRef.asFile();
		215	long timeStamp = tempFile.lastModified();
		216
		217	JarProcessor processor = JarProcessor.getUnpackProcessor(null);
		218	processor.setWorkingDirectory(tempFile.getParent());
		219
		220	File packedFile = new File(tempFile.toString() + ".pack.gz"); //$NON-NLS-1$
		221	tempFile.renameTo(packedFile);
		222	//unpacking the jar will strip the ".pack.gz" and leave us back with the original filename
		223	processor.processJar(packedFile);
		224
		225	tempFile.setLastModified(timeStamp);
		226	Utilities.mapLocalFile(key, tempFile);
		227	}
		228	}
		229	return packedRef;
		230	}
172	/*	231	/*
173	* @see IFeatureContentProvider#getNonPluginEntryArchiveReferences(INonPluginEntry)	232	* @see IFeatureContentProvider#getNonPluginEntryArchiveReferences(INonPluginEntry)
174	*/	233	*/

Added Link Here

(-)src/org/eclipse/update/jarprocessor/internal/CommandStep.java (+84 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.jarprocessor.internal;
12
13	import java.io.File;
14	import java.io.IOException;
15	import java.util.Properties;
16	import org.eclipse.update.jarprocessor.IProcessStep;
17
18	/**
19	* @author aniefer
20	*
21	*/
22	public class CommandStep implements IProcessStep {
23	private String command = null;
24	private String extension = null;
25	private Properties options = null;
26
27	public CommandStep(Properties options, String command, String extension) {
28	this.command = command;
29	this.extension = extension;
30	this.options = options;
31	}
32
33	/* (non-Javadoc)
34	* @see org.eclipse.update.jarprocessor.IProcessStep#recursionEffect(java.lang.String)
35	*/
36	public String recursionEffect(String entryName) {
37	if (entryName.endsWith(extension))
38	return entryName;
39	return null;
40	}
41
42	/* (non-Javadoc)
43	* @see org.eclipse.update.jarprocessor.IProcessStep#preProcess(java.io.File, java.io.File)
44	*/
45	public File preProcess(File input, File workingDirectory) {
46	return null;
47	}
48
49	/* (non-Javadoc)
50	* @see org.eclipse.update.jarprocessor.IProcessStep#postProcess(java.io.File, java.io.File)
51	*/
52	public File postProcess(File input, File workingDirectory) {
53	if(command != null) {
54	try {
55	String[] cmd = new String[] {command, input.getCanonicalPath()};
56	int result = execute(cmd);
57	if(result == 0)
58	return input;
59	} catch (IOException e) {
60	//boo
61	e.printStackTrace();
62	}
63	}
64	return input;
65	}
66
67	public static int execute(String[] cmd) throws IOException {
68	Runtime runtime = Runtime.getRuntime();
69	Process proc = runtime.exec(cmd);
70	try {
71	int result = proc.waitFor();
72	return result;
73	} catch (InterruptedException e) {
74	//ignore
75	}
76	return -1;
77	}
78
79	public Properties getOptions() {
80	if(options == null)
81	options = new Properties();
82	return options;
83	}
84	}

Added Link Here

(-)src/org/eclipse/update/jarprocessor/Main.java (+119 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.jarprocessor;
12
13	import java.io.*;
14	import java.util.zip.ZipException;
15	import org.eclipse.update.jarprocessor.internal.*;
16
17	/**
18	* @author aniefer
19	*
20	*/
21	public class Main {
22	private static final String OUTPUT = "-outputDir="; //$NON-NLS-1$
23	private static final String COMMAND = "-signCommand="; //$NON-NLS-1$
24
25	private static String outputDir = null;
26	private static String command = null;
27
28	private static void printUsage(){
29	System.out.println(" -pack [-signCommand=value] [-outputDir=value] input"); //$NON-NLS-1$
30	System.out.println("\tPack the input jars. If signCommand is specified, then the jars are first repacked and signed using that command"); //$NON-NLS-1$
31	System.out.println("\tIf input is a directory, all contained jars are packed, subdirectories are visited recursively."); //$NON-NLS-1$
32	System.out.println("\tThe signCommand will be executed with 1 argument that is the file to sign."); //$NON-NLS-1$
33	System.out.println();
34	System.out.println("-unpack [-outputDir=value] input"); //$NON-NLS-1$
35	System.out.println("\tUnpack the input pack.gz files"); //$NON-NLS-1$
36	System.out.println();
37	System.out.println("[-outputDir=value] input.zip"); //$NON-NLS-1$
38	System.out.println("\tCreate an outputDir/input.zip file containing processed repacked, signed & optionally packed versions of jars found"); //$NON-NLS-1$
39	System.out.println("\tin input.zip"); //$NON-NLS-1$
40	}
41
42	private static void processZipFile(File zip){
43	ZipProcessor processor = new ZipProcessor();
44	processor.setWorkingDirectory(outputDir);
45	processor.setCommand(command);
46	try {
47	processor.processZip(zip);
48	} catch (ZipException e) {
49	// TODO Auto-generated catch block
50	e.printStackTrace();
51	} catch (IOException e) {
52	// TODO Auto-generated catch block
53	e.printStackTrace();
54	}
55
56
57	}
58
59	/**
60	* @param args
61	*/
62	public static void main(String[] args) {
63	boolean packing = true;
64
65	outputDir = "."; //$NON-NLS-1$
66
67	if (args.length == 0) {
68	printUsage();
69	return;
70	}
71
72	int i = 0;
73	for (; i < args.length - 1; i++) {
74	if(args[i].equals("-pack")) {//$NON-NLS-1$
75	packing = true;
76	} else if( args[i].equals("-unpack")) { //$NON-NLS-1$
77	packing = false;
78	} else if(args[i].startsWith(COMMAND) && args[i].length() > COMMAND.length()) {
79	command = args[i].substring(COMMAND.length()).trim();
80	} else if (args[i].startsWith(OUTPUT)) {
81	outputDir=args[i].substring(OUTPUT.length()).trim();
82	}
83	}
84	File input = new File(args[i]);
85
86	if(input.getName().endsWith(".zip")){ //$NON-NLS-1$
87	processZipFile(input);
88	} else {
89	try {
90	if(packing) {
91	if(!JarProcessor.canPerformPack()){
92	System.out.println("Cannot find a pack200 executable."); //$NON-NLS-1$
93	return;
94	}
95	JarProcessor processor = new JarProcessor();
96	processor.setWorkingDirectory(outputDir);
97	processor.addProcessStep( command != null ? (IProcessStep) new PackUnpackStep(null) : (IProcessStep) new PackStep(null));
98	if(command != null){
99	processor.addProcessStep(new CommandStep(null, command, ".jar")); //$NON-NLS-1$
100	processor.addProcessStep(new PackStep(null));
101	}
102	processor.process(input, Utils.JAR_FILTER);
103	} else {
104	if(!JarProcessor.canPerformUnpack()){
105	System.out.println("Cannot find a unpack200 exectuable."); //$NON-NLS-1$
106	return;
107	}
108	JarProcessor processor = new JarProcessor();
109	processor.setWorkingDirectory(outputDir);
110	processor.addProcessStep(new UnpackStep(null));
111	processor.process(input, Utils.PACK_GZ_FILTER);
112	}
113	} catch (FileNotFoundException e ){
114	System.out.println(e.getLocalizedMessage());
115	}
116	}
117	}
118
119	}

Added Link Here

(-)src/org/eclipse/update/jarprocessor/JarProcessor.java (+288 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.jarprocessor;
12
13	import java.io.*;
14	import java.util.*;
15	import java.util.jar.*;
16	import org.eclipse.update.jarprocessor.internal.*;
17
18	/**
19	* @author aniefer
20	*
21	*/
22	public class JarProcessor {
23	/**
24	* The system property "org.eclipse.update.jarprocessor.pack200". Set to the location in which to look for the
25	* pack200/unpack200 executables.
26	* Possible values are:
27	* "@jre": look for the executables in java.home/bin
28	* "@path": look for the executables in the system search path
29	* "@none": don't use pack200
30	* dir : a directory containing pack200 & unpack200 executables
31	*/
32	public static final String PACK200_PROPERTY = "org.eclipse.update.jarprocessor.pack200"; //$NON-NLS-1$
33	public static final String JRE = "@jre"; //$NON-NLS-1$
34	public static final String PATH = "@path"; //$NON-NLS-1$
35	public static final String NONE = "@none"; //$NON-NLS-1$
36
37	private List steps = new ArrayList();
38	private String workingDirectory = ""; //$NON-NLS-1$
39	private int depth = -1;
40
41	static public JarProcessor getUnpackProcessor(Properties properties) {
42	if(!canPerformUnpack())
43	throw new UnsupportedOperationException();
44	JarProcessor processor = new JarProcessor();
45	processor.addProcessStep(new UnpackStep(properties));
46	return processor;
47	}
48
49	static public JarProcessor getPackProcessor(Properties properties) {
50	if(!canPerformPack())
51	throw new UnsupportedOperationException();
52	JarProcessor processor = new JarProcessor();
53	processor.addProcessStep(new PackStep(properties));
54	return processor;
55	}
56
57	static public boolean canPerformPack() {
58	return PackStep.canPack();
59	}
60
61	static public boolean canPerformUnpack(){
62	return UnpackStep.canUnpack();
63	}
64
65	public String getWorkingDirectory() {
66	return workingDirectory;
67	}
68
69	public void setWorkingDirectory(String dir) {
70	workingDirectory = dir;
71	}
72
73	public void addProcessStep(IProcessStep step) {
74	steps.add(step);
75	}
76
77	public void clearProcessSteps() {
78	steps.clear();
79	}
80	public void process(File input, FileFilter filter) throws FileNotFoundException {
81	if(!input.exists() )
82	throw new FileNotFoundException();
83
84	File [] files = null;
85	if(input.isDirectory()){
86	files = input.listFiles();
87	} else if(filter.accept(input)) {
88	files = new File [] {input};
89	}
90	for (int i = 0; i < files.length; i++) {
91	System.out.println("Processing " +files[i].getName()); //$NON-NLS-1$
92	if(files[i].isDirectory()){
93	String dir = getWorkingDirectory();
94	setWorkingDirectory(dir + "/" + files[i].getName()); //$NON-NLS-1$
95	process(files[i], filter);
96	setWorkingDirectory(dir);
97	} else if(filter.accept(files[i])) {
98	try {
99	processJar(files[i]);
100	} catch (IOException e) {
101	// TODO Auto-generated catch block
102	e.printStackTrace();
103	}
104	}
105	}
106	}
107
108	/**
109	* Recreate a jar file. The replacements map specifies entry names to be replaced, the replacements are
110	* expected to be found in directory.
111	*
112	* @param jar - The input jar
113	* @param outputJar - the output
114	* @param replacements - map of entryName -> new entryName
115	* @param directory - location to find file for new entryName
116	* @throws IOException
117	*/
118	private void recreateJar(JarFile jar, JarOutputStream outputJar, Map replacements, File directory) throws IOException {
119	InputStream in = null;
120	try {
121	Enumeration entries = jar.entries();
122	for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
123	File replacement = null;
124	JarEntry newEntry = null;
125	if (replacements.containsKey(entry.getName())) {
126	String name = (String) replacements.get(entry.getName());// + Utils.PACKED_SUFFIX;
127	replacement = new File(directory, name);
128	in = new FileInputStream(replacement);
129	newEntry = new JarEntry(name);
130	//long time = entry.getTime();
131	// entry = new JarEntry(name);
132	// entry.setTime(time);
133	} else {
134	in = jar.getInputStream(entry);
135	newEntry = new JarEntry(entry.getName());
136	//entry.setCompressedSize(-1);
137	}
138	newEntry.setTime(entry.getTime());
139	outputJar.putNextEntry(newEntry);
140	Utils.transferStreams(in, outputJar, false);
141	outputJar.closeEntry();
142	in.close();
143
144	//delete the nested jar file
145	if (replacement != null) {
146	replacement.delete();
147	}
148	}
149	} finally {
150	Utils.close(outputJar);
151	Utils.close(jar);
152	Utils.close(in);
153	}
154	}
155
156	private String recursionEffect(String entryName) {
157	String result = null;
158	for (Iterator iter = steps.iterator(); iter.hasNext();) {
159	IProcessStep step = (IProcessStep) iter.next();
160
161	result = step.recursionEffect(entryName);
162	if(result != null)
163	entryName = result;
164	}
165	return result;
166	}
167
168	private void extractEntries(JarFile jar, File tempDir, Map data) throws IOException {
169	Enumeration entries = jar.entries();
170	if (entries.hasMoreElements()) {
171	for (JarEntry entry = (JarEntry) entries.nextElement(); entry != null; entry = entries.hasMoreElements() ? (JarEntry) entries.nextElement() : null) {
172	String name = entry.getName();
173	String newName = recursionEffect(name);
174	if (newName != null) {
175	//extract entry to temp directory
176	File extracted = new File(tempDir, name);
177	File parentDir = extracted.getParentFile();
178	if (!parentDir.exists())
179	parentDir.mkdirs();
180
181	InputStream in = null;
182	FileOutputStream out = null;
183	try {
184	in = jar.getInputStream(entry);
185	out = new FileOutputStream(extracted);
186	Utils.transferStreams(in, out, true); //this will close both streams
187	} finally {
188	Utils.close(in);
189	Utils.close(out);
190	}
191	data.put(name, newName);
192
193	//recurse
194	String dir = getWorkingDirectory();
195	setWorkingDirectory(parentDir.getCanonicalPath());
196	processJar(extracted);
197	setWorkingDirectory(dir);
198
199	//delete the extracted item leaving the recursion result
200	if(!name.equals(newName))
201	extracted.delete();
202	}
203	}
204	}
205	}
206
207
208
209	private File preProcess(File input, File tempDir) {
210	File result = null;
211	for (Iterator iter = steps.iterator(); iter.hasNext();) {
212	IProcessStep step = (IProcessStep) iter.next();
213	result = step.preProcess(input, tempDir);
214	if( result != null)
215	input = result;
216	}
217	return input;
218	}
219
220	private File postProcess(File input, File tempDir) {
221	File result = null;
222	for (Iterator iter = steps.iterator(); iter.hasNext();) {
223	IProcessStep step = (IProcessStep) iter.next();
224	result = step.postProcess(input, tempDir);
225	if(result != null)
226	input = result;
227	}
228	return input;
229	}
230
231	public void processJar(File input) throws IOException {
232	++depth;
233	File workingDir = new File(getWorkingDirectory());
234	if(!workingDir.exists())
235	workingDir.mkdirs();
236
237	//pre
238	File workingFile = preProcess(input, workingDir);
239
240	//Extract entries from jar and recurse on them
241	File tempDir = null;
242	if(depth == 0) {
243	tempDir = new File(workingDir, "temp." + workingFile.getName()); //$NON-NLS-1$
244	} else {
245	File parent = workingDir.getParentFile();
246	tempDir = new File(parent, "temp_" + depth +'_' + workingFile.getName()); //$NON-NLS-1$
247	}
248	// if(depth == 0){
249	// JarFile jar = new JarFile(workingFile, false);
250	// Map replacements = new HashMap();
251	// extractEntries(jar, tempDir, replacements);
252	//
253	// //Recreate the jar with replacements
254	// File tempJar = null;
255	// if(replacements.size() > 0) {
256	// tempJar = new File(tempDir, workingFile.getName());
257	// File parent = tempJar.getParentFile();
258	// if(!parent.exists())
259	// parent.mkdirs();
260	// JarOutputStream jarOut = new JarOutputStream(new FileOutputStream(tempJar));
261	// recreateJar(jar, jarOut, replacements, tempDir);
262	// }
263	//
264	// jar.close();
265	// if( tempJar != null) {
266	// if(!workingFile.equals(input)){
267	// workingFile.delete();
268	// }
269	// workingFile = tempJar;
270	// }
271	// }
272	//post
273	File result = postProcess(workingFile, workingDir);
274	if(!result.equals(workingFile) && !workingFile.equals(input))
275	workingFile.delete();
276	if(!result.getParentFile().equals(workingDir)){
277	File finalFile = new File(workingDir, result.getName());
278	if(finalFile.exists())
279	finalFile.delete();
280	result.renameTo(finalFile);
281	}
282
283	if(tempDir.exists())
284	Utils.clear(tempDir);
285
286	--depth;
287	}
288	}