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

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

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

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

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