/*******************************************************************************
* Copyright (c) 2006, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.update.internal.jarprocessor;
import java.io.File;
import java.io.IOException;
import java.util.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 Set exclusions = Collections.EMPTY_SET;
public static boolean canPack() {
if (canPack != null)
return canPack.booleanValue();
String[] locations = Utils.getPack200Commands("pack200"); //$NON-NLS-1$
if (locations == null) {
canPack = Boolean.FALSE;
packCommand = null;
return false;
}
int result;
for (int i = 0; i < locations.length; i++) {
if (locations[i] == null)
continue;
result = execute(new String[] {locations[i], "-V"}); //$NON-NLS-1$
if (result == 0) {
packCommand = locations[i];
canPack = Boolean.TRUE;
return true;
}
}
canPack = Boolean.FALSE;
return false;
}
public PackStep(Properties options) {
super(options, null, null, false);
exclusions = Utils.getPackExclusions(options);
}
public PackStep(Properties options, boolean verbose) {
super(options, null, null, verbose);
exclusions = Utils.getPackExclusions(options);
}
public String recursionEffect(String entryName) {
if (canPack() && entryName.endsWith(".jar") && !exclusions.contains(entryName)) { //$NON-NLS-1$
return entryName + Utils.PACKED_SUFFIX;
}
return null;
}
public File preProcess(File input, File workingDirectory, 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))
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$
} catch (IOException e) {
if (verbose)
e.printStackTrace();
return null;
}
return outputFile;
}
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];
cmd[0] = packCommand;
System.arraycopy(args, 0, cmd, 1, args.length);
cmd[cmd.length - 2] = outputFile.getCanonicalPath();
cmd[cmd.length - 1] = input.getCanonicalPath();
} else {
cmd = new String[] {packCommand, outputFile.getCanonicalPath(), input.getCanonicalPath()};
}
return cmd;
}
protected String getArguments(File input, Properties inf, List containers) {
//1: Explicitly marked in our .inf file
if (inf != null && inf.containsKey(Utils.PACK_ARGS)) {
return inf.getProperty(Utils.PACK_ARGS);
}
//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)) {
return container.getProperty(Utils.DEFAULT_PACK_ARGS);
}
}
//3: Set by name in outside pack.properties file
Properties options = getOptions();
String argsKey = input.getName() + Utils.PACK_ARGS_SUFFIX;
if (options.containsKey(argsKey)) {
return options.getProperty(argsKey);
}
//4: Set by default in outside pack.properties file
if (options.containsKey(Utils.DEFAULT_PACK_ARGS)) {
return options.getProperty(Utils.DEFAULT_PACK_ARGS);
}
return ""; //$NON-NLS-1$
}
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;
}
verbose = v;
//mark as conditioned if not previously marked. A signed jar is assumed to be previously conditioned.
if (inf.getProperty(Utils.MARK_PROPERTY) == null) {
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);
}
}
}
}