src/org/apache/pig/backend/hadoop/accumulo/Utils.java - pig - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements. See the NOTICE file distributed with this
  * work for additional information regarding copyright ownership. The ASF
  * licenses this file to you 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 org.apache.pig.backend.hadoop.accumulo;

 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLDecoder;
 import java.text.MessageFormat;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
 import java.util.jar.Manifest;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import java.util.zip.ZipOutputStream;

 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.util.StringUtils;
 import org.apache.log4j.Logger;

 import com.google.common.base.Preconditions;

 public class Utils {
     private static final Logger log = Logger.getLogger(Utils.class);

     // Thanks, HBase
     public static void addDependencyJars(Configuration conf,
             Class<?>... classes) throws IOException {

         FileSystem localFs = FileSystem.getLocal(conf);
         Set<String> jars = new HashSet<String>();
         // Add jars that are already in the tmpjars variable
         jars.addAll(conf.getStringCollection("tmpjars"));

         // add jars as we find them to a map of contents jar name so that we can
         // avoid
         // creating new jars for classes that have already been packaged.
         Map<String, String> packagedClasses = new HashMap<String, String>();

         // Add jars containing the specified classes
         for (Class<?> clazz : classes) {
             if (clazz == null)
                 continue;

             Path path = findOrCreateJar(clazz, localFs, packagedClasses);
             if (path == null) {
                 log.warn("Could not find jar for class " + clazz
                         + " in order to ship it to the cluster.");
                 continue;
             }
             if (!localFs.exists(path)) {
                 log.warn("Could not validate jar file " + path + " for class "
                         + clazz);
                 continue;
             }
             jars.add(path.toString());
         }
         if (jars.isEmpty())
             return;

         conf.set("tmpjars", StringUtils.arrayToString(jars
                 .toArray(new String[jars.size()])));
     }

     /**
      * If org.apache.hadoop.util.JarFinder is available (0.23+ hadoop), finds
      * the Jar for a class or creates it if it doesn't exist. If the class is in
      * a directory in the classpath, it creates a Jar on the fly with the
      * contents of the directory and returns the path to that Jar. If a Jar is
      * created, it is created in the system temporary directory. Otherwise,
      * returns an existing jar that contains a class of the same name. Maintains
      * a mapping from jar contents to the tmp jar created.
      *
      * @param my_class
      *            the class to find.
      * @param fs
      *            the FileSystem with which to qualify the returned path.
      * @param packagedClasses
      *            a map of class name to path.
      * @return a jar file that contains the class.
      * @throws IOException
      */
     private static Path findOrCreateJar(Class<?> my_class, FileSystem fs,
             Map<String, String> packagedClasses) throws IOException {
         // attempt to locate an existing jar for the class.
         String jar = findContainingJar(my_class, packagedClasses);
         if (null == jar || jar.isEmpty()) {
             jar = getJar(my_class);
             updateMap(jar, packagedClasses);
         }

         if (null == jar || jar.isEmpty()) {
             return null;
         }

         log.debug(String.format("For class %s, using jar %s",
                 my_class.getName(), jar));
         return new Path(jar).makeQualified(fs);
     }

     /**
      * Add entries to <code>packagedClasses</code> corresponding to class files
      * contained in <code>jar</code>.
      *
      * @param jar
      *            The jar who's content to list.
      * @param packagedClasses
      *            map[class -> jar]
      */
     private static void updateMap(String jar,
             Map<String, String> packagedClasses) throws IOException {
         if (null == jar || jar.isEmpty()) {
             return;
         }
         ZipFile zip = null;
         try {
             zip = new ZipFile(jar);
             for (Enumeration<? extends ZipEntry> iter = zip.entries(); iter
                     .hasMoreElements();) {
                 ZipEntry entry = iter.nextElement();
                 if (entry.getName().endsWith("class")) {
                     packagedClasses.put(entry.getName(), jar);
                 }
             }
         } finally {
             if (null != zip)
                 zip.close();
         }
     }

     /**
      * Find a jar that contains a class of the same name, if any. It will return
      * a jar file, even if that is not the first thing on the class path that
      * has a class with the same name. Looks first on the classpath and then in
      * the <code>packagedClasses</code> map.
      *
      * @param my_class
      *            the class to find.
      * @return a jar file that contains the class, or null.
      * @throws IOException
      */
     private static String findContainingJar(Class<?> my_class,
             Map<String, String> packagedClasses) throws IOException {
         ClassLoader loader = my_class.getClassLoader();
         String class_file = my_class.getName().replaceAll("\\.", "/")
                 + ".class";

         // first search the classpath
         for (Enumeration<URL> itr = loader.getResources(class_file); itr
                 .hasMoreElements();) {
             URL url = itr.nextElement();
             if ("jar".equals(url.getProtocol())) {
                 String toReturn = url.getPath();
                 if (toReturn.startsWith("file:")) {
                     toReturn = toReturn.substring("file:".length());
                 }
                 // URLDecoder is a misnamed class, since it actually decodes
                 // x-www-form-urlencoded MIME type rather than actual
                 // URL encoding (which the file path has). Therefore it would
                 // decode +s to ' 's which is incorrect (spaces are actually
                 // either unencoded or encoded as "%20"). Replace +s first, so
                 // that they are kept sacred during the decoding process.
                 toReturn = toReturn.replaceAll("\\+", "%2B");
                 toReturn = URLDecoder.decode(toReturn, "UTF-8");
                 return toReturn.replaceAll("!.*$", "");
             }
         }

         // now look in any jars we've packaged using JarFinder. Returns null
         // when
         // no jar is found.
         return packagedClasses.get(class_file);
     }

     /**
      * Invoke 'getJar' on a JarFinder implementation. Useful for some job
      * configuration contexts (HBASE-8140) and also for testing on MRv2. First
      * check if we have HADOOP-9426. Lacking that, fall back to the backport.
      *
      * @param my_class
      *            the class to find.
      * @return a jar file that contains the class, or null.
      */
     private static String getJar(Class<?> my_class) {
         String ret = null;
         String hadoopJarFinder = "org.apache.hadoop.util.JarFinder";
         Class<?> jarFinder = null;
         try {
             log.debug("Looking for " + hadoopJarFinder + ".");
             jarFinder = Class.forName(hadoopJarFinder);
             log.debug(hadoopJarFinder + " found.");
             Method getJar = jarFinder.getMethod("getJar", Class.class);
             ret = (String) getJar.invoke(null, my_class);
         } catch (ClassNotFoundException e) {
             log.debug("Using backported JarFinder.");
             ret = jarFinderGetJar(my_class);
         } catch (InvocationTargetException e) {
             // function was properly called, but threw it's own exception.
             // Unwrap it
             // and pass it on.
             throw new RuntimeException(e.getCause());
         } catch (Exception e) {
             // toss all other exceptions, related to reflection failure
             throw new RuntimeException("getJar invocation failed.", e);
         }

         return ret;
     }

     /**
      * Returns the full path to the Jar containing the class. It always return a
      * JAR.
      *
      * @param klass
      *            class.
      *
      * @return path to the Jar containing the class.
      */
     @SuppressWarnings("rawtypes")
     public static String jarFinderGetJar(Class klass) {
         Preconditions.checkNotNull(klass, "klass");
         ClassLoader loader = klass.getClassLoader();
         if (loader != null) {
             String class_file = klass.getName().replaceAll("\\.", "/")
                     + ".class";
             try {
                 for (Enumeration itr = loader.getResources(class_file); itr
                         .hasMoreElements();) {
                     URL url = (URL) itr.nextElement();
                     String path = url.getPath();
                     if (path.startsWith("file:")) {
                         path = path.substring("file:".length());
                     }
                     path = URLDecoder.decode(path, "UTF-8");
                     if ("jar".equals(url.getProtocol())) {
                         path = URLDecoder.decode(path, "UTF-8");
                         return path.replaceAll("!.*$", "");
                     } else if ("file".equals(url.getProtocol())) {
                         String klassName = klass.getName();
                         klassName = klassName.replace(".", "/") + ".class";
                         path = path.substring(0,
                                 path.length() - klassName.length());
                         File baseDir = new File(path);
                         File testDir = new File(System.getProperty(
                                 "test.build.dir", "target/test-dir"));
                         testDir = testDir.getAbsoluteFile();
                         if (!testDir.exists()) {
                             testDir.mkdirs();
                         }
                         File tempJar = File.createTempFile("hadoop-", "",
                                 testDir);
                         tempJar = new File(tempJar.getAbsolutePath() + ".jar");
                         createJar(baseDir, tempJar);
                         return tempJar.getAbsolutePath();
                     }
                 }
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         }
         return null;
     }

     private static void copyToZipStream(InputStream is, ZipEntry entry,
             ZipOutputStream zos) throws IOException {
         zos.putNextEntry(entry);
         byte[] arr = new byte[4096];
         int read = is.read(arr);
         while (read > -1) {
             zos.write(arr, 0, read);
             read = is.read(arr);
         }
     }

     public static void jarDir(File dir, String relativePath, ZipOutputStream zos)
             throws IOException {
         Preconditions.checkNotNull(relativePath, "relativePath");
         Preconditions.checkNotNull(zos, "zos");

         // by JAR spec, if there is a manifest, it must be the first entry in
         // the
         // ZIP.
         File manifestFile = new File(dir, JarFile.MANIFEST_NAME);
         ZipEntry manifestEntry = new ZipEntry(JarFile.MANIFEST_NAME);
         if (!manifestFile.exists()) {
             zos.putNextEntry(manifestEntry);
             new Manifest().write(new BufferedOutputStream(zos));
             zos.closeEntry();
         } else {
             InputStream is = new FileInputStream(manifestFile);
             try {
                 copyToZipStream(is, manifestEntry, zos);
             } finally {
                 if (is != null) {
                     is.close();
                 }
                 if (zos != null) {
                     zos.closeEntry();
                 }
             }
         }
         zos.closeEntry();
         zipDir(dir, relativePath, zos, true);
         zos.close();
     }

     private static void zipDir(File dir, String relativePath,
             ZipOutputStream zos, boolean start) throws IOException {
         String[] dirList = dir.list();
         for (String aDirList : dirList) {
             File f = new File(dir, aDirList);
             if (!f.isHidden()) {
                 if (f.isDirectory()) {
                     if (!start) {
                         ZipEntry dirEntry = new ZipEntry(relativePath
                                 + f.getName() + "/");
                         zos.putNextEntry(dirEntry);
                         zos.closeEntry();
                     }
                     String filePath = f.getPath();
                     File file = new File(filePath);
                     zipDir(file, relativePath + f.getName() + "/", zos, false);
                 } else {
                     String path = relativePath + f.getName();
                     if (!path.equals(JarFile.MANIFEST_NAME)) {
                         ZipEntry anEntry = new ZipEntry(path);
                         InputStream is = new FileInputStream(f);
                         try {
                             copyToZipStream(is, anEntry, zos);
                         } finally {
                             if (is != null) {
                                 is.close();
                             }
                             if (zos != null) {
                                 zos.closeEntry();
                             }
                         }
                     }
                 }
             }
         }
     }

     private static void createJar(File dir, File jarFile) throws IOException {
         Preconditions.checkNotNull(dir, "dir");
         Preconditions.checkNotNull(jarFile, "jarFile");
         File jarDir = jarFile.getParentFile();
         if (!jarDir.exists()) {
             if (!jarDir.mkdirs()) {
                 throw new IOException(MessageFormat.format(
                         "could not create dir [{0}]", jarDir));
             }
         }
         JarOutputStream zos = new JarOutputStream(new FileOutputStream(jarFile));
         jarDir(dir, "", zos);
     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with this
	* work for additional information regarding copyright ownership. The ASF
	* licenses this file to you 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 org.apache.pig.backend.hadoop.accumulo;

	import java.io.BufferedOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.net.URL;
	import java.net.URLDecoder;
	import java.text.MessageFormat;
	import java.util.Enumeration;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;
	import java.util.jar.JarFile;
	import java.util.jar.JarOutputStream;
	import java.util.jar.Manifest;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipFile;
	import java.util.zip.ZipOutputStream;

	import org.apache.hadoop.conf.Configuration;
	import org.apache.hadoop.fs.FileSystem;
	import org.apache.hadoop.fs.Path;
	import org.apache.hadoop.util.StringUtils;
	import org.apache.log4j.Logger;

	import com.google.common.base.Preconditions;

	public class Utils {
	private static final Logger log = Logger.getLogger(Utils.class);

	// Thanks, HBase
	public static void addDependencyJars(Configuration conf,
	Class<?>... classes) throws IOException {

	FileSystem localFs = FileSystem.getLocal(conf);
	Set<String> jars = new HashSet<String>();
	// Add jars that are already in the tmpjars variable
	jars.addAll(conf.getStringCollection("tmpjars"));

	// add jars as we find them to a map of contents jar name so that we can
	// avoid
	// creating new jars for classes that have already been packaged.
	Map<String, String> packagedClasses = new HashMap<String, String>();

	// Add jars containing the specified classes
	for (Class<?> clazz : classes) {
	if (clazz == null)
	continue;

	Path path = findOrCreateJar(clazz, localFs, packagedClasses);
	if (path == null) {
	log.warn("Could not find jar for class " + clazz
	+ " in order to ship it to the cluster.");
	continue;
	}
	if (!localFs.exists(path)) {
	log.warn("Could not validate jar file " + path + " for class "
	+ clazz);
	continue;
	}
	jars.add(path.toString());
	}
	if (jars.isEmpty())
	return;

	conf.set("tmpjars", StringUtils.arrayToString(jars
	.toArray(new String[jars.size()])));
	}

	/**
	* If org.apache.hadoop.util.JarFinder is available (0.23+ hadoop), finds
	* the Jar for a class or creates it if it doesn't exist. If the class is in
	* a directory in the classpath, it creates a Jar on the fly with the
	* contents of the directory and returns the path to that Jar. If a Jar is
	* created, it is created in the system temporary directory. Otherwise,
	* returns an existing jar that contains a class of the same name. Maintains
	* a mapping from jar contents to the tmp jar created.
	*
	* @param my_class
	* the class to find.
	* @param fs
	* the FileSystem with which to qualify the returned path.
	* @param packagedClasses
	* a map of class name to path.
	* @return a jar file that contains the class.
	* @throws IOException
	*/
	private static Path findOrCreateJar(Class<?> my_class, FileSystem fs,
	Map<String, String> packagedClasses) throws IOException {
	// attempt to locate an existing jar for the class.
	String jar = findContainingJar(my_class, packagedClasses);
	if (null == jar \|\| jar.isEmpty()) {
	jar = getJar(my_class);
	updateMap(jar, packagedClasses);
	}

	if (null == jar \|\| jar.isEmpty()) {
	return null;
	}

	log.debug(String.format("For class %s, using jar %s",
	my_class.getName(), jar));
	return new Path(jar).makeQualified(fs);
	}

	/**
	* Add entries to <code>packagedClasses</code> corresponding to class files
	* contained in <code>jar</code>.
	*
	* @param jar
	* The jar who's content to list.
	* @param packagedClasses
	* map[class -> jar]
	*/
	private static void updateMap(String jar,
	Map<String, String> packagedClasses) throws IOException {
	if (null == jar \|\| jar.isEmpty()) {
	return;
	}
	ZipFile zip = null;
	try {
	zip = new ZipFile(jar);
	for (Enumeration<? extends ZipEntry> iter = zip.entries(); iter
	.hasMoreElements();) {
	ZipEntry entry = iter.nextElement();
	if (entry.getName().endsWith("class")) {
	packagedClasses.put(entry.getName(), jar);
	}
	}
	} finally {
	if (null != zip)
	zip.close();
	}
	}

	/**
	* Find a jar that contains a class of the same name, if any. It will return
	* a jar file, even if that is not the first thing on the class path that
	* has a class with the same name. Looks first on the classpath and then in
	* the <code>packagedClasses</code> map.
	*
	* @param my_class
	* the class to find.
	* @return a jar file that contains the class, or null.
	* @throws IOException
	*/
	private static String findContainingJar(Class<?> my_class,
	Map<String, String> packagedClasses) throws IOException {
	ClassLoader loader = my_class.getClassLoader();
	String class_file = my_class.getName().replaceAll("\\.", "/")
	+ ".class";

	// first search the classpath
	for (Enumeration<URL> itr = loader.getResources(class_file); itr
	.hasMoreElements();) {
	URL url = itr.nextElement();
	if ("jar".equals(url.getProtocol())) {
	String toReturn = url.getPath();
	if (toReturn.startsWith("file:")) {
	toReturn = toReturn.substring("file:".length());
	}
	// URLDecoder is a misnamed class, since it actually decodes
	// x-www-form-urlencoded MIME type rather than actual
	// URL encoding (which the file path has). Therefore it would
	// decode +s to ' 's which is incorrect (spaces are actually
	// either unencoded or encoded as "%20"). Replace +s first, so
	// that they are kept sacred during the decoding process.
	toReturn = toReturn.replaceAll("\\+", "%2B");
	toReturn = URLDecoder.decode(toReturn, "UTF-8");
	return toReturn.replaceAll("!.*$", "");
	}
	}

	// now look in any jars we've packaged using JarFinder. Returns null
	// when
	// no jar is found.
	return packagedClasses.get(class_file);
	}

	/**
	* Invoke 'getJar' on a JarFinder implementation. Useful for some job
	* configuration contexts (HBASE-8140) and also for testing on MRv2. First
	* check if we have HADOOP-9426. Lacking that, fall back to the backport.
	*
	* @param my_class
	* the class to find.
	* @return a jar file that contains the class, or null.
	*/
	private static String getJar(Class<?> my_class) {
	String ret = null;
	String hadoopJarFinder = "org.apache.hadoop.util.JarFinder";
	Class<?> jarFinder = null;
	try {
	log.debug("Looking for " + hadoopJarFinder + ".");
	jarFinder = Class.forName(hadoopJarFinder);
	log.debug(hadoopJarFinder + " found.");
	Method getJar = jarFinder.getMethod("getJar", Class.class);
	ret = (String) getJar.invoke(null, my_class);
	} catch (ClassNotFoundException e) {
	log.debug("Using backported JarFinder.");
	ret = jarFinderGetJar(my_class);
	} catch (InvocationTargetException e) {
	// function was properly called, but threw it's own exception.
	// Unwrap it
	// and pass it on.
	throw new RuntimeException(e.getCause());
	} catch (Exception e) {
	// toss all other exceptions, related to reflection failure
	throw new RuntimeException("getJar invocation failed.", e);
	}

	return ret;
	}

	/**
	* Returns the full path to the Jar containing the class. It always return a
	* JAR.
	*
	* @param klass
	* class.
	*
	* @return path to the Jar containing the class.
	*/
	@SuppressWarnings("rawtypes")
	public static String jarFinderGetJar(Class klass) {
	Preconditions.checkNotNull(klass, "klass");
	ClassLoader loader = klass.getClassLoader();
	if (loader != null) {
	String class_file = klass.getName().replaceAll("\\.", "/")
	+ ".class";
	try {
	for (Enumeration itr = loader.getResources(class_file); itr
	.hasMoreElements();) {
	URL url = (URL) itr.nextElement();
	String path = url.getPath();
	if (path.startsWith("file:")) {
	path = path.substring("file:".length());
	}
	path = URLDecoder.decode(path, "UTF-8");
	if ("jar".equals(url.getProtocol())) {
	path = URLDecoder.decode(path, "UTF-8");
	return path.replaceAll("!.*$", "");
	} else if ("file".equals(url.getProtocol())) {
	String klassName = klass.getName();
	klassName = klassName.replace(".", "/") + ".class";
	path = path.substring(0,
	path.length() - klassName.length());
	File baseDir = new File(path);
	File testDir = new File(System.getProperty(
	"test.build.dir", "target/test-dir"));
	testDir = testDir.getAbsoluteFile();
	if (!testDir.exists()) {
	testDir.mkdirs();
	}
	File tempJar = File.createTempFile("hadoop-", "",
	testDir);
	tempJar = new File(tempJar.getAbsolutePath() + ".jar");
	createJar(baseDir, tempJar);
	return tempJar.getAbsolutePath();
	}
	}
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	}
	return null;
	}

	private static void copyToZipStream(InputStream is, ZipEntry entry,
	ZipOutputStream zos) throws IOException {
	zos.putNextEntry(entry);
	byte[] arr = new byte[4096];
	int read = is.read(arr);
	while (read > -1) {
	zos.write(arr, 0, read);
	read = is.read(arr);
	}
	}

	public static void jarDir(File dir, String relativePath, ZipOutputStream zos)
	throws IOException {
	Preconditions.checkNotNull(relativePath, "relativePath");
	Preconditions.checkNotNull(zos, "zos");

	// by JAR spec, if there is a manifest, it must be the first entry in
	// the
	// ZIP.
	File manifestFile = new File(dir, JarFile.MANIFEST_NAME);
	ZipEntry manifestEntry = new ZipEntry(JarFile.MANIFEST_NAME);
	if (!manifestFile.exists()) {
	zos.putNextEntry(manifestEntry);
	new Manifest().write(new BufferedOutputStream(zos));
	zos.closeEntry();
	} else {
	InputStream is = new FileInputStream(manifestFile);
	try {
	copyToZipStream(is, manifestEntry, zos);
	} finally {
	if (is != null) {
	is.close();
	}
	if (zos != null) {
	zos.closeEntry();
	}
	}
	}
	zos.closeEntry();
	zipDir(dir, relativePath, zos, true);
	zos.close();
	}

	private static void zipDir(File dir, String relativePath,
	ZipOutputStream zos, boolean start) throws IOException {
	String[] dirList = dir.list();
	for (String aDirList : dirList) {
	File f = new File(dir, aDirList);
	if (!f.isHidden()) {
	if (f.isDirectory()) {
	if (!start) {
	ZipEntry dirEntry = new ZipEntry(relativePath
	+ f.getName() + "/");
	zos.putNextEntry(dirEntry);
	zos.closeEntry();
	}
	String filePath = f.getPath();
	File file = new File(filePath);
	zipDir(file, relativePath + f.getName() + "/", zos, false);
	} else {
	String path = relativePath + f.getName();
	if (!path.equals(JarFile.MANIFEST_NAME)) {
	ZipEntry anEntry = new ZipEntry(path);
	InputStream is = new FileInputStream(f);
	try {
	copyToZipStream(is, anEntry, zos);
	} finally {
	if (is != null) {
	is.close();
	}
	if (zos != null) {
	zos.closeEntry();
	}
	}
	}
	}
	}
	}
	}

	private static void createJar(File dir, File jarFile) throws IOException {
	Preconditions.checkNotNull(dir, "dir");
	Preconditions.checkNotNull(jarFile, "jarFile");
	File jarDir = jarFile.getParentFile();
	if (!jarDir.exists()) {
	if (!jarDir.mkdirs()) {
	throw new IOException(MessageFormat.format(
	"could not create dir [{0}]", jarDir));
	}
	}
	JarOutputStream zos = new JarOutputStream(new FileOutputStream(jarFile));
	jarDir(dir, "", zos);
	}
	}