src/java_tools/singlejar/java/com/google/devtools/build/singlejar/SingleJar.java - bazel - Git at Google

 // Copyright 2014 The Bazel Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.devtools.build.singlejar;

 import static com.google.devtools.build.singlejar.ZipCombiner.DOS_EPOCH;

 import com.google.devtools.build.singlejar.DefaultJarEntryFilter.PathFilter;
 import com.google.devtools.build.singlejar.ZipCombiner.OutputMode;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Properties;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
 import javax.annotation.concurrent.NotThreadSafe;

 /**
  * An application that emulates the existing SingleJar tool, using the {@link
  * ZipCombiner} class.
  */
 @NotThreadSafe
 public class SingleJar {

   private static final byte NEWLINE_BYTE = (byte) '\n';
   private static final String MANIFEST_FILENAME = JarFile.MANIFEST_NAME;
   private static final String BUILD_DATA_FILENAME = "build-data.properties";

   private final SimpleFileSystem fileSystem;

   /** The input jar files we want to combine into the output jar. */
   private final List<String> inputJars = new ArrayList<>();

   /** Additional resources to be added to the output jar. */
   private final List<String> resources = new ArrayList<>();

   /** Additional class path resources to be added to the output jar. */
   private final List<String> classpathResources = new ArrayList<>();

   /** The name of the output Jar file. */
   private String outputJar;

   /** A filter for what jar entries to include */
   private PathFilter allowedPaths = DefaultJarEntryFilter.ANY_PATH;

   /** Extra manifest contents. */
   private String extraManifestContent;
   /** The main class - this is put into the manifest and also into the build info. */
   private String mainClass;

   /**
    * Warn about duplicate resource files, and skip them. Default behavior is to
    * give an error message.
    */
   private boolean warnDuplicateFiles = false;

   /** Indicates whether to set all timestamps to a fixed value. */
   private boolean normalize = false;
   private OutputMode outputMode = OutputMode.FORCE_STORED;

   /** Whether to include build-data.properties file */
   protected boolean includeBuildData = true;

   /** List of build information properties files */
   protected List<String> buildInformationFiles = new ArrayList<>();

   /** Extraneous build informations (key=value) */
   protected List<String> buildInformations = new ArrayList<>();

   /** The (optional) native executable that will be prepended to this JAR. */
   private String launcherBin = null;

   // Only visible for testing.
   protected SingleJar(SimpleFileSystem fileSystem) {
     this.fileSystem = fileSystem;
   }

   /**
    * Creates a manifest and returns an input stream for its contents.
    */
   private InputStream createManifest() throws IOException {
     Manifest manifest = new Manifest();
     Attributes attributes = manifest.getMainAttributes();
     attributes.put(Attributes.Name.MANIFEST_VERSION, "1.0");
     attributes.put(new Attributes.Name("Created-By"), "blaze-singlejar");
     if (mainClass != null) {
       attributes.put(Attributes.Name.MAIN_CLASS, mainClass);
     }
     if (extraManifestContent != null) {
       ByteArrayInputStream in = new ByteArrayInputStream(extraManifestContent.getBytes("UTF8"));
       manifest.read(in);
     }
     ByteArrayOutputStream out = new ByteArrayOutputStream();
     manifest.write(out);
     return new ByteArrayInputStream(out.toByteArray());
   }

   private InputStream createBuildData() throws IOException {
     Properties properties = mergeBuildData();
     ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
     properties.store(outputStream, null);
     byte[] output = outputStream.toByteArray();
     // Properties#store() adds a timestamp comment as first line, delete it.
     output = stripFirstLine(output);
     return new ByteArrayInputStream(output);
   }

   static byte[] stripFirstLine(byte[] output) {
     int i = 0;
     while (i < output.length && output[i] != NEWLINE_BYTE) {
       i++;
     }
     if (i < output.length) {
       output = Arrays.copyOfRange(output, i + 1, output.length);
     } else {
       output = new byte[0];
     }
     return output;
   }

   private Properties mergeBuildData() throws IOException {
     Properties properties = new Properties();
     for (String fileName : buildInformationFiles) {
       InputStream file = fileSystem.getInputStream(fileName);
       if (file != null) {
         properties.load(file);
       }
     }

     // extra properties
     for (String info : buildInformations) {
       String[] split = info.split("=", 2);
       String key = split[0];
       String value = "";
       if (split.length > 1) {
         value = split[1];
       }
       properties.put(key, value);
     }

     // finally add generic information
     // TODO(bazel-team) do we need to resolve the path to be absolute or canonical?
     properties.put("build.target", outputJar);
     if (mainClass != null) {
       properties.put("main.class", mainClass);
     }
     return properties;
   }

   private String getName(String filename) {
     int index = filename.lastIndexOf('/');
     return index < 0 ? filename : filename.substring(index + 1);
   }

   // Only visible for testing.
   protected int run(List<String> args) throws IOException {
     List<String> expandedArgs = new OptionFileExpander(fileSystem).expandArguments(args);
     processCommandlineArgs(expandedArgs);
     InputStream buildInfo = createBuildData();

     ZipCombiner combiner = null;
     try {
       combiner = new ZipCombiner(outputMode, createEntryFilter(normalize, allowedPaths),
           fileSystem.getOutputStream(outputJar));
       if (launcherBin != null) {
         combiner.prependExecutable(fileSystem.getInputStream(launcherBin));
       }
       Date date = normalize ? ZipCombiner.DOS_EPOCH : null;

       // Add a manifest file.
       JarUtils.addMetaInf(combiner, date);
       combiner.addFile(MANIFEST_FILENAME, date, createManifest());

       if (includeBuildData) {
         // Add the build data file.
         combiner.addFile(BUILD_DATA_FILENAME, date, buildInfo);
       }

       // Copy the resources to the top level of the jar file.
       for (String classpathResource : classpathResources) {
         String entryName = getName(classpathResource);
         if (warnDuplicateFiles && combiner.containsFile(entryName)) {
           System.err.println("File " + entryName + " clashes with a previous file");
           continue;
         }
         combiner.addFile(entryName, date, fileSystem.getInputStream(classpathResource));
       }

       // Copy the resources into the jar file.
       for (String resource : resources) {
         String from;
         String to;
         int i = resource.indexOf(':');
         if (i < 0) {
           to = from = resource;
         } else {
           from = resource.substring(0, i);
           to = resource.substring(i + 1);
         }
         if (warnDuplicateFiles && combiner.containsFile(to)) {
           System.err.println("File " + from + " at " + to + " clashes with a previous file");
           continue;
         }

         // Add parent directory entries.
         int idx = to.indexOf('/');
         while (idx != -1) {
           String dir = to.substring(0, idx + 1);
           if (!combiner.containsFile(dir)) {
             combiner.addDirectory(dir, DOS_EPOCH);
           }
           idx = to.indexOf('/', idx + 1);
         }

         combiner.addFile(to, date, fileSystem.getInputStream(from));
       }

       // Copy the jars into the jar file.
       for (String inputJar : inputJars) {
         File jar = fileSystem.getFile(inputJar);
         combiner.addZip(jar);
       }

       // Close the output file. If something goes wrong here, delete the file.
       combiner.close();
       combiner = null;
     } finally {
       // This part is only executed if an exception occurred.
       if (combiner != null) {
         try {
           // We may end up calling close twice, but that's ok.
           combiner.close();
         } catch (IOException e) {
           // There's already an exception in progress - this won't add any
           // additional information.
         }
         // Ignore return value - there's already an exception in progress.
         fileSystem.delete(outputJar);
       }
     }
     return 0;
   }

   protected ZipEntryFilter createEntryFilter(boolean normalize, PathFilter allowedPaths) {
     return new DefaultJarEntryFilter(normalize, allowedPaths);
   }

   /**
    * Collects the arguments for a command line flag until it finds a flag that
    * starts with the terminatorPrefix.
    *
    * @param args
    * @param startIndex the start index in the args to collect the flag arguments
    *        from
    * @param flagArguments the collected flag arguments
    * @param terminatorPrefix the terminator prefix to stop collecting of
    *        argument flags
    * @return the index of the first argument that started with the
    *         terminatorPrefix
    */
   private static int collectFlagArguments(List<String> args, int startIndex,
       List<String> flagArguments, String terminatorPrefix) {
     startIndex++;
     while (startIndex < args.size()) {
       String name = args.get(startIndex);
       if (name.startsWith(terminatorPrefix)) {
         return startIndex - 1;
       }
       flagArguments.add(name);
       startIndex++;
     }
     return startIndex;
   }

   /**
    * Returns a single argument for a command line option.
    *
    * @throws IOException if no more arguments are available
    */
   private static String getArgument(List<String> args, int i, String arg) throws IOException {
     if (i + 1 < args.size()) {
       return args.get(i + 1);
     }
     throw new IOException(arg + ": missing argument");
   }

   /**
    * Processes the command line arguments.
    *
    * @throws IOException if one of the files containing options cannot be read
    */
   protected void processCommandlineArgs(List<String> args) throws IOException {
     List<String> manifestLines = new ArrayList<>();
     List<String> prefixes = new ArrayList<>();
     for (int i = 0; i < args.size(); i++) {
       String arg = args.get(i);
       if (arg.equals("--sources")) {
         i = collectFlagArguments(args, i, inputJars, "--");
       } else if (arg.equals("--resources")) {
         i = collectFlagArguments(args, i, resources, "--");
       } else if (arg.equals("--classpath_resources")) {
         i = collectFlagArguments(args, i, classpathResources, "--");
       } else if (arg.equals("--deploy_manifest_lines")) {
         i = collectFlagArguments(args, i, manifestLines, "--");
       } else if (arg.equals("--build_info_file")) {
         buildInformationFiles.add(getArgument(args, i, arg));
         i++;
       } else if (arg.equals("--extra_build_info")) {
         buildInformations.add(getArgument(args, i, arg));
         i++;
       } else if (arg.equals("--main_class")) {
         mainClass = getArgument(args, i, arg);
         i++;
       } else if (arg.equals("--output")) {
         outputJar = getArgument(args, i, arg);
         i++;
       } else if (arg.equals("--compression")) {
         outputMode = OutputMode.FORCE_DEFLATE;
       } else if (arg.equals("--dont_change_compression")) {
         outputMode = OutputMode.DONT_CARE;
       } else if (arg.equals("--normalize")) {
         normalize = true;
       } else if (arg.equals("--include_prefixes")) {
         i = collectFlagArguments(args, i, prefixes, "--");
       } else if (arg.equals("--exclude_build_data")) {
         includeBuildData = false;
       } else if (arg.equals("--warn_duplicate_resources")) {
         warnDuplicateFiles = true;
       } else if (arg.equals("--java_launcher")) {
         launcherBin = getArgument(args, i, arg);
         i++;
       } else {
         throw new IOException("unknown option : '" + arg + "'");
       }
     }
     if (!manifestLines.isEmpty()) {
       setExtraManifestContent(joinWithNewlines(manifestLines));
     }
     if (!prefixes.isEmpty()) {
       setPathPrefixes(prefixes);
     }
   }

   private String joinWithNewlines(Iterable<String> lines) {
     StringBuilder result = new StringBuilder();
     Iterator<String> it = lines.iterator();
     if (it.hasNext()) {
       result.append(it.next());
     }
     while (it.hasNext()) {
       result.append('\n');
       result.append(it.next());
     }
     return result.toString();
   }

   private void setExtraManifestContent(String extraManifestContent) {
     // The manifest content has to be terminated with a newline character
     if (!extraManifestContent.endsWith("\n")) {
       extraManifestContent = extraManifestContent + '\n';
     }
     this.extraManifestContent = extraManifestContent;
   }

   private void setPathPrefixes(List<String> prefixes) throws IOException {
     if (prefixes.isEmpty()) {
       throw new IOException(
           "Empty set of path prefixes; cowardly refusing to emit an empty jar file");
     }
     allowedPaths = new PrefixListPathFilter(prefixes);
   }

   static int singleRun(String[] args) throws IOException {
     SingleJar singlejar = new SingleJar(new JavaIoFileSystem());
     return singlejar.run(Arrays.asList(args));
   }

   public static void main(String[] args) {
     if (shouldRunInWorker(args)) {
       if (!canRunInWorker()) {
         System.err.println("Asked to run in a worker, but no worker support");
         System.exit(1);
       }
       try {
         runWorker(args);
       } catch (Exception e) {
         System.err.println("Error running worker : " + e.getMessage());
         System.exit(1);
       }
       return;
     }

     try {
       System.exit(singleRun(args));
     } catch (IOException e) {
       System.err.println("SingleJar threw exception : " + e.getMessage());
       System.exit(1);
     }
   }

   private static void runWorker(String[] args) throws Exception {
     // Invocation is done through reflection so that this code will work in bazel open source
     // as well. SingleJar is used for bootstrap and thus can not depend on protos (used in
     // SingleJarWorker).
     Class<?> workerClass = Class.forName("com.google.devtools.build.singlejar.SingleJarWorker");
     workerClass.getMethod("main", String[].class).invoke(null, (Object) args);
   }

   protected static boolean shouldRunInWorker(String[] args) {
     return Arrays.asList(args).contains("--persistent_worker");
   }

   private static boolean canRunInWorker() {
     try {
       Class.forName("com.google.devtools.build.singlejar.SingleJarWorker");
       return true;
     } catch (ClassNotFoundException e1) {
       return false;
     }
   }

 }
	// Copyright 2014 The Bazel Authors. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.devtools.build.singlejar;

	import static com.google.devtools.build.singlejar.ZipCombiner.DOS_EPOCH;

	import com.google.devtools.build.singlejar.DefaultJarEntryFilter.PathFilter;
	import com.google.devtools.build.singlejar.ZipCombiner.OutputMode;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Date;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Properties;
	import java.util.jar.Attributes;
	import java.util.jar.JarFile;
	import java.util.jar.Manifest;
	import javax.annotation.concurrent.NotThreadSafe;

	/**
	* An application that emulates the existing SingleJar tool, using the {@link
	* ZipCombiner} class.
	*/
	@NotThreadSafe
	public class SingleJar {

	private static final byte NEWLINE_BYTE = (byte) '\n';
	private static final String MANIFEST_FILENAME = JarFile.MANIFEST_NAME;
	private static final String BUILD_DATA_FILENAME = "build-data.properties";

	private final SimpleFileSystem fileSystem;

	/** The input jar files we want to combine into the output jar. */
	private final List<String> inputJars = new ArrayList<>();

	/** Additional resources to be added to the output jar. */
	private final List<String> resources = new ArrayList<>();

	/** Additional class path resources to be added to the output jar. */
	private final List<String> classpathResources = new ArrayList<>();

	/** The name of the output Jar file. */
	private String outputJar;

	/** A filter for what jar entries to include */
	private PathFilter allowedPaths = DefaultJarEntryFilter.ANY_PATH;

	/** Extra manifest contents. */
	private String extraManifestContent;
	/** The main class - this is put into the manifest and also into the build info. */
	private String mainClass;

	/**
	* Warn about duplicate resource files, and skip them. Default behavior is to
	* give an error message.
	*/
	private boolean warnDuplicateFiles = false;

	/** Indicates whether to set all timestamps to a fixed value. */
	private boolean normalize = false;
	private OutputMode outputMode = OutputMode.FORCE_STORED;

	/** Whether to include build-data.properties file */
	protected boolean includeBuildData = true;

	/** List of build information properties files */
	protected List<String> buildInformationFiles = new ArrayList<>();

	/** Extraneous build informations (key=value) */
	protected List<String> buildInformations = new ArrayList<>();

	/** The (optional) native executable that will be prepended to this JAR. */
	private String launcherBin = null;

	// Only visible for testing.
	protected SingleJar(SimpleFileSystem fileSystem) {
	this.fileSystem = fileSystem;
	}

	/**
	* Creates a manifest and returns an input stream for its contents.
	*/
	private InputStream createManifest() throws IOException {
	Manifest manifest = new Manifest();
	Attributes attributes = manifest.getMainAttributes();
	attributes.put(Attributes.Name.MANIFEST_VERSION, "1.0");
	attributes.put(new Attributes.Name("Created-By"), "blaze-singlejar");
	if (mainClass != null) {
	attributes.put(Attributes.Name.MAIN_CLASS, mainClass);
	}
	if (extraManifestContent != null) {
	ByteArrayInputStream in = new ByteArrayInputStream(extraManifestContent.getBytes("UTF8"));
	manifest.read(in);
	}
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	manifest.write(out);
	return new ByteArrayInputStream(out.toByteArray());
	}

	private InputStream createBuildData() throws IOException {
	Properties properties = mergeBuildData();
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	properties.store(outputStream, null);
	byte[] output = outputStream.toByteArray();
	// Properties#store() adds a timestamp comment as first line, delete it.
	output = stripFirstLine(output);
	return new ByteArrayInputStream(output);
	}

	static byte[] stripFirstLine(byte[] output) {
	int i = 0;
	while (i < output.length && output[i] != NEWLINE_BYTE) {
	i++;
	}
	if (i < output.length) {
	output = Arrays.copyOfRange(output, i + 1, output.length);
	} else {
	output = new byte[0];
	}
	return output;
	}

	private Properties mergeBuildData() throws IOException {
	Properties properties = new Properties();
	for (String fileName : buildInformationFiles) {
	InputStream file = fileSystem.getInputStream(fileName);
	if (file != null) {
	properties.load(file);
	}
	}

	// extra properties
	for (String info : buildInformations) {
	String[] split = info.split("=", 2);
	String key = split[0];
	String value = "";
	if (split.length > 1) {
	value = split[1];
	}
	properties.put(key, value);
	}

	// finally add generic information
	// TODO(bazel-team) do we need to resolve the path to be absolute or canonical?
	properties.put("build.target", outputJar);
	if (mainClass != null) {
	properties.put("main.class", mainClass);
	}
	return properties;
	}

	private String getName(String filename) {
	int index = filename.lastIndexOf('/');
	return index < 0 ? filename : filename.substring(index + 1);
	}

	// Only visible for testing.
	protected int run(List<String> args) throws IOException {
	List<String> expandedArgs = new OptionFileExpander(fileSystem).expandArguments(args);
	processCommandlineArgs(expandedArgs);
	InputStream buildInfo = createBuildData();

	ZipCombiner combiner = null;
	try {
	combiner = new ZipCombiner(outputMode, createEntryFilter(normalize, allowedPaths),
	fileSystem.getOutputStream(outputJar));
	if (launcherBin != null) {
	combiner.prependExecutable(fileSystem.getInputStream(launcherBin));
	}
	Date date = normalize ? ZipCombiner.DOS_EPOCH : null;

	// Add a manifest file.
	JarUtils.addMetaInf(combiner, date);
	combiner.addFile(MANIFEST_FILENAME, date, createManifest());

	if (includeBuildData) {
	// Add the build data file.
	combiner.addFile(BUILD_DATA_FILENAME, date, buildInfo);
	}

	// Copy the resources to the top level of the jar file.
	for (String classpathResource : classpathResources) {
	String entryName = getName(classpathResource);
	if (warnDuplicateFiles && combiner.containsFile(entryName)) {
	System.err.println("File " + entryName + " clashes with a previous file");
	continue;
	}
	combiner.addFile(entryName, date, fileSystem.getInputStream(classpathResource));
	}

	// Copy the resources into the jar file.
	for (String resource : resources) {
	String from;
	String to;
	int i = resource.indexOf(':');
	if (i < 0) {
	to = from = resource;
	} else {
	from = resource.substring(0, i);
	to = resource.substring(i + 1);
	}
	if (warnDuplicateFiles && combiner.containsFile(to)) {
	System.err.println("File " + from + " at " + to + " clashes with a previous file");
	continue;
	}

	// Add parent directory entries.
	int idx = to.indexOf('/');
	while (idx != -1) {
	String dir = to.substring(0, idx + 1);
	if (!combiner.containsFile(dir)) {
	combiner.addDirectory(dir, DOS_EPOCH);
	}
	idx = to.indexOf('/', idx + 1);
	}

	combiner.addFile(to, date, fileSystem.getInputStream(from));
	}

	// Copy the jars into the jar file.
	for (String inputJar : inputJars) {
	File jar = fileSystem.getFile(inputJar);
	combiner.addZip(jar);
	}

	// Close the output file. If something goes wrong here, delete the file.
	combiner.close();
	combiner = null;
	} finally {
	// This part is only executed if an exception occurred.
	if (combiner != null) {
	try {
	// We may end up calling close twice, but that's ok.
	combiner.close();
	} catch (IOException e) {
	// There's already an exception in progress - this won't add any
	// additional information.
	}
	// Ignore return value - there's already an exception in progress.
	fileSystem.delete(outputJar);
	}
	}
	return 0;
	}

	protected ZipEntryFilter createEntryFilter(boolean normalize, PathFilter allowedPaths) {
	return new DefaultJarEntryFilter(normalize, allowedPaths);
	}

	/**
	* Collects the arguments for a command line flag until it finds a flag that
	* starts with the terminatorPrefix.
	*
	* @param args
	* @param startIndex the start index in the args to collect the flag arguments
	* from
	* @param flagArguments the collected flag arguments
	* @param terminatorPrefix the terminator prefix to stop collecting of
	* argument flags
	* @return the index of the first argument that started with the
	* terminatorPrefix
	*/
	private static int collectFlagArguments(List<String> args, int startIndex,
	List<String> flagArguments, String terminatorPrefix) {
	startIndex++;
	while (startIndex < args.size()) {
	String name = args.get(startIndex);
	if (name.startsWith(terminatorPrefix)) {
	return startIndex - 1;
	}
	flagArguments.add(name);
	startIndex++;
	}
	return startIndex;
	}

	/**
	* Returns a single argument for a command line option.
	*
	* @throws IOException if no more arguments are available
	*/
	private static String getArgument(List<String> args, int i, String arg) throws IOException {
	if (i + 1 < args.size()) {
	return args.get(i + 1);
	}
	throw new IOException(arg + ": missing argument");
	}

	/**
	* Processes the command line arguments.
	*
	* @throws IOException if one of the files containing options cannot be read
	*/
	protected void processCommandlineArgs(List<String> args) throws IOException {
	List<String> manifestLines = new ArrayList<>();
	List<String> prefixes = new ArrayList<>();
	for (int i = 0; i < args.size(); i++) {
	String arg = args.get(i);
	if (arg.equals("--sources")) {
	i = collectFlagArguments(args, i, inputJars, "--");
	} else if (arg.equals("--resources")) {
	i = collectFlagArguments(args, i, resources, "--");
	} else if (arg.equals("--classpath_resources")) {
	i = collectFlagArguments(args, i, classpathResources, "--");
	} else if (arg.equals("--deploy_manifest_lines")) {
	i = collectFlagArguments(args, i, manifestLines, "--");
	} else if (arg.equals("--build_info_file")) {
	buildInformationFiles.add(getArgument(args, i, arg));
	i++;
	} else if (arg.equals("--extra_build_info")) {
	buildInformations.add(getArgument(args, i, arg));
	i++;
	} else if (arg.equals("--main_class")) {
	mainClass = getArgument(args, i, arg);
	i++;
	} else if (arg.equals("--output")) {
	outputJar = getArgument(args, i, arg);
	i++;
	} else if (arg.equals("--compression")) {
	outputMode = OutputMode.FORCE_DEFLATE;
	} else if (arg.equals("--dont_change_compression")) {
	outputMode = OutputMode.DONT_CARE;
	} else if (arg.equals("--normalize")) {
	normalize = true;
	} else if (arg.equals("--include_prefixes")) {
	i = collectFlagArguments(args, i, prefixes, "--");
	} else if (arg.equals("--exclude_build_data")) {
	includeBuildData = false;
	} else if (arg.equals("--warn_duplicate_resources")) {
	warnDuplicateFiles = true;
	} else if (arg.equals("--java_launcher")) {
	launcherBin = getArgument(args, i, arg);
	i++;
	} else {
	throw new IOException("unknown option : '" + arg + "'");
	}
	}
	if (!manifestLines.isEmpty()) {
	setExtraManifestContent(joinWithNewlines(manifestLines));
	}
	if (!prefixes.isEmpty()) {
	setPathPrefixes(prefixes);
	}
	}

	private String joinWithNewlines(Iterable<String> lines) {
	StringBuilder result = new StringBuilder();
	Iterator<String> it = lines.iterator();
	if (it.hasNext()) {
	result.append(it.next());
	}
	while (it.hasNext()) {
	result.append('\n');
	result.append(it.next());
	}
	return result.toString();
	}

	private void setExtraManifestContent(String extraManifestContent) {
	// The manifest content has to be terminated with a newline character
	if (!extraManifestContent.endsWith("\n")) {
	extraManifestContent = extraManifestContent + '\n';
	}
	this.extraManifestContent = extraManifestContent;
	}

	private void setPathPrefixes(List<String> prefixes) throws IOException {
	if (prefixes.isEmpty()) {
	throw new IOException(
	"Empty set of path prefixes; cowardly refusing to emit an empty jar file");
	}
	allowedPaths = new PrefixListPathFilter(prefixes);
	}

	static int singleRun(String[] args) throws IOException {
	SingleJar singlejar = new SingleJar(new JavaIoFileSystem());
	return singlejar.run(Arrays.asList(args));
	}

	public static void main(String[] args) {
	if (shouldRunInWorker(args)) {
	if (!canRunInWorker()) {
	System.err.println("Asked to run in a worker, but no worker support");
	System.exit(1);
	}
	try {
	runWorker(args);
	} catch (Exception e) {
	System.err.println("Error running worker : " + e.getMessage());
	System.exit(1);
	}
	return;
	}

	try {
	System.exit(singleRun(args));
	} catch (IOException e) {
	System.err.println("SingleJar threw exception : " + e.getMessage());
	System.exit(1);
	}
	}

	private static void runWorker(String[] args) throws Exception {
	// Invocation is done through reflection so that this code will work in bazel open source
	// as well. SingleJar is used for bootstrap and thus can not depend on protos (used in
	// SingleJarWorker).
	Class<?> workerClass = Class.forName("com.google.devtools.build.singlejar.SingleJarWorker");
	workerClass.getMethod("main", String[].class).invoke(null, (Object) args);
	}

	protected static boolean shouldRunInWorker(String[] args) {
	return Arrays.asList(args).contains("--persistent_worker");
	}

	private static boolean canRunInWorker() {
	try {
	Class.forName("com.google.devtools.build.singlejar.SingleJarWorker");
	return true;
	} catch (ClassNotFoundException e1) {
	return false;
	}
	}

	}