build-tools/ant-gwt/src/com/google/gwt/ant/taskdefs/LatestTimeJar.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * 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.gwt.ant.taskdefs;

 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.taskdefs.Jar;
 import org.apache.tools.zip.ZipExtraField;
 import org.apache.tools.zip.ZipOutputStream;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Map;
 import java.util.Random;
 import java.util.TreeMap;

 /**
  * A variation on Jar which handles duplicate entries by only archiving the most
  * recent of any given path. This is done by keeping a map of paths (as shown in
  * the jar file) against {@link EntryInfo} objects identifying the input source
  * and its timestamp. Most of the actual archiving is deferred until archive
  * finalization, when we've decided on the actual de-duplicated set of entries.
  */
 public class LatestTimeJar extends Jar {

   /**
    * Metadata about pending entries in the jar, for replacement if newer entries
    * are found. Subclasses of EntryInfo are held in the
    */
   protected abstract class EntryInfo {
     protected long timestamp;
     protected int mode;

     public EntryInfo(long lastModified, int mode) {
       this.timestamp = lastModified;
       this.mode = mode;
     }

     /**
      * Called to actually add the entry to a given zip stream.
      *
      * @param out
      * @param path
      * @throws IOException
      */
     public abstract void addToZip(ZipOutputStream out, String path)
         throws IOException;

     public long getLastModified() {
       return timestamp;
     }

     public int getMode() {
       return mode;
     }
   }

   /**
    * Metadata about a directory entry.
    */
   protected class DirEntryInfo extends EntryInfo {
     protected File dir;
     protected ZipExtraField extra[];

     public DirEntryInfo(File dir, long touchTime, int mode,
         ZipExtraField extra[]) {
       super(touchTime, mode);
       this.dir = dir;
       this.extra = extra;
     }

     @Override
     public void addToZip(ZipOutputStream out, String path) throws IOException {
       doZipDir(dir, out, path, mode, extra);
     }
   }

   /**
    * Metadata about a file entry.
    */
   protected class FileEntryInfo extends EntryInfo {
     private File tmpFile;
     private File archive;

     public FileEntryInfo(InputStream in, long lastModified, File fromArchive,
         int mode) throws IOException {
       super(lastModified, mode);
       tmpFile = createTempFile("gwtjar", "");
       tmpFile.deleteOnExit();
       OutputStream fos = new FileOutputStream(tmpFile);
       int readLen = in.read(buffer);
       while (readLen > 0) {
         fos.write(buffer, 0, readLen);
         readLen = in.read(buffer);
       }
       fos.close();
       archive = fromArchive;
     }

     @Override
     public void addToZip(ZipOutputStream out, String path) throws IOException {
       FileInputStream inStream = new FileInputStream(tmpFile);
       try {
         doZipFile(inStream, out, path, timestamp, archive, mode);
         tmpFile.delete();
       } finally {
         inStream.close();
       }
     }
   }

   /**
    * Used to generate temporary file names.
    */
   private static long counter = -1;

   /**
    * Creates a temporary file.
    *
    * @param prefix the file prefix
    * @param suffix the file suffix
    * @return the new file
    * @throws IOException if the file cannot be created
    */
   private static File createTempFile(String prefix, String suffix)
       throws IOException {
     if (suffix == null) {
       suffix = ".tmp";
     }

     // Get the temp file directory.
     File tmpDir = new File(System.getProperty("java.io.tmpdir"));
     tmpDir.mkdirs();

     // Generate a random name.
     if (counter == -1) {
       counter = new Random().nextLong();
     }
     boolean created = false;
     File tmpFile;
     do {
       counter++;
       tmpFile = new File(tmpDir, prefix + Long.toString(counter) + suffix);
       if (!tmpFile.exists()) {
         created = tmpFile.createNewFile();
         if (!created) {
           // If we fail the create the temp file, it must have been created by
           // another thread between lines 161 and 162.  We re-seed to avoid
           // further race conditions.
           counter = new Random().nextLong();
         }
       }
     } while (!created);

     // Create the file.
     tmpFile.createNewFile();
     return tmpFile;
   }

   private byte buffer[] = new byte[16 * 1024];
   private Map<String, EntryInfo> paths = new TreeMap<String, EntryInfo>();

   @Override
   protected void finalizeZipOutputStream(ZipOutputStream out)
       throws IOException, BuildException {
     for (String path : paths.keySet()) {
       paths.get(path).addToZip(out, path);
     }
     super.finalizeZipOutputStream(out);
   }

   @Override
   protected void zipDir(File dir,
       @SuppressWarnings("unused") ZipOutputStream out, String path, int mode,
       ZipExtraField[] extra) throws IOException {
     long thisTouchTime = (dir == null ? 0L : dir.lastModified());
     String dirName = (dir == null ? "<null>" : dir.getAbsolutePath());
     if (shouldReplace(path, thisTouchTime)) {
       if (paths.get(path) != null) {
         log("Obsoleting older " + path + " with " + dirName,
             Project.MSG_VERBOSE);
       }
       paths.put(path, new DirEntryInfo(dir, thisTouchTime, mode, extra));
     } else {
       log("Newer " + path + " already added, skipping " + dirName,
           Project.MSG_VERBOSE);
     }
   }

   @Override
   protected void zipFile(InputStream in,
       @SuppressWarnings("unused") ZipOutputStream out, String path,
       long lastModified, File fromArchive, int mode) throws IOException {

     String desc = (fromArchive == null ? "file" : "file from "
         + fromArchive.getAbsolutePath());

     if (shouldReplace(path, lastModified)) {
       if (paths.get(path) != null) {
         log("Obsoleting older " + path + " with " + desc, Project.MSG_VERBOSE);
       }
       paths.put(path, new FileEntryInfo(in, lastModified, fromArchive, mode));
     } else {
       log("Newer " + path + " already added, skipping " + desc,
           Project.MSG_VERBOSE);
     }
   }

   private void doZipDir(File dir, ZipOutputStream out, String entryName,
       int mode, ZipExtraField[] extra) throws IOException {
     super.zipDir(dir, out, entryName, mode, extra);
   }

   private void doZipFile(InputStream inStream, ZipOutputStream out,
       String entryName, long timestamp, File archive, int mode)
       throws IOException {
     super.zipFile(inStream, out, entryName, timestamp, archive, mode);
   }

   /**
    * Checks whether an entry should be replaced, by touch dates and duplicates
    * setting.
    *
    * @param path the path of an entry being considered
    * @param touchTime the lastModified of the candiate replacement
    * @return true if the file should be replaced
    */
   private boolean shouldReplace(String path, long touchTime) {
     EntryInfo oldInfo = paths.get(path);
     // adding from jars, we get directories with 0L time; missing should be
     // earlier than that, -1L.
     long existingTouchTime = ((oldInfo != null) ? oldInfo.getLastModified()
         : -1L);
     return (existingTouchTime < touchTime || (existingTouchTime == touchTime && this.duplicate.equals("add")));
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* 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.gwt.ant.taskdefs;

	import org.apache.tools.ant.BuildException;
	import org.apache.tools.ant.Project;
	import org.apache.tools.ant.taskdefs.Jar;
	import org.apache.tools.zip.ZipExtraField;
	import org.apache.tools.zip.ZipOutputStream;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.Map;
	import java.util.Random;
	import java.util.TreeMap;

	/**
	* A variation on Jar which handles duplicate entries by only archiving the most
	* recent of any given path. This is done by keeping a map of paths (as shown in
	* the jar file) against {@link EntryInfo} objects identifying the input source
	* and its timestamp. Most of the actual archiving is deferred until archive
	* finalization, when we've decided on the actual de-duplicated set of entries.
	*/
	public class LatestTimeJar extends Jar {

	/**
	* Metadata about pending entries in the jar, for replacement if newer entries
	* are found. Subclasses of EntryInfo are held in the
	*/
	protected abstract class EntryInfo {
	protected long timestamp;
	protected int mode;

	public EntryInfo(long lastModified, int mode) {
	this.timestamp = lastModified;
	this.mode = mode;
	}

	/**
	* Called to actually add the entry to a given zip stream.
	*
	* @param out
	* @param path
	* @throws IOException
	*/
	public abstract void addToZip(ZipOutputStream out, String path)
	throws IOException;

	public long getLastModified() {
	return timestamp;
	}

	public int getMode() {
	return mode;
	}
	}

	/**
	* Metadata about a directory entry.
	*/
	protected class DirEntryInfo extends EntryInfo {
	protected File dir;
	protected ZipExtraField extra[];

	public DirEntryInfo(File dir, long touchTime, int mode,
	ZipExtraField extra[]) {
	super(touchTime, mode);
	this.dir = dir;
	this.extra = extra;
	}

	@Override
	public void addToZip(ZipOutputStream out, String path) throws IOException {
	doZipDir(dir, out, path, mode, extra);
	}
	}

	/**
	* Metadata about a file entry.
	*/
	protected class FileEntryInfo extends EntryInfo {
	private File tmpFile;
	private File archive;

	public FileEntryInfo(InputStream in, long lastModified, File fromArchive,
	int mode) throws IOException {
	super(lastModified, mode);
	tmpFile = createTempFile("gwtjar", "");
	tmpFile.deleteOnExit();
	OutputStream fos = new FileOutputStream(tmpFile);
	int readLen = in.read(buffer);
	while (readLen > 0) {
	fos.write(buffer, 0, readLen);
	readLen = in.read(buffer);
	}
	fos.close();
	archive = fromArchive;
	}

	@Override
	public void addToZip(ZipOutputStream out, String path) throws IOException {
	FileInputStream inStream = new FileInputStream(tmpFile);
	try {
	doZipFile(inStream, out, path, timestamp, archive, mode);
	tmpFile.delete();
	} finally {
	inStream.close();
	}
	}
	}

	/**
	* Used to generate temporary file names.
	*/
	private static long counter = -1;

	/**
	* Creates a temporary file.
	*
	* @param prefix the file prefix
	* @param suffix the file suffix
	* @return the new file
	* @throws IOException if the file cannot be created
	*/
	private static File createTempFile(String prefix, String suffix)
	throws IOException {
	if (suffix == null) {
	suffix = ".tmp";
	}

	// Get the temp file directory.
	File tmpDir = new File(System.getProperty("java.io.tmpdir"));
	tmpDir.mkdirs();

	// Generate a random name.
	if (counter == -1) {
	counter = new Random().nextLong();
	}
	boolean created = false;
	File tmpFile;
	do {
	counter++;
	tmpFile = new File(tmpDir, prefix + Long.toString(counter) + suffix);
	if (!tmpFile.exists()) {
	created = tmpFile.createNewFile();
	if (!created) {
	// If we fail the create the temp file, it must have been created by
	// another thread between lines 161 and 162. We re-seed to avoid
	// further race conditions.
	counter = new Random().nextLong();
	}
	}
	} while (!created);

	// Create the file.
	tmpFile.createNewFile();
	return tmpFile;
	}

	private byte buffer[] = new byte[16 * 1024];
	private Map<String, EntryInfo> paths = new TreeMap<String, EntryInfo>();

	@Override
	protected void finalizeZipOutputStream(ZipOutputStream out)
	throws IOException, BuildException {
	for (String path : paths.keySet()) {
	paths.get(path).addToZip(out, path);
	}
	super.finalizeZipOutputStream(out);
	}

	@Override
	protected void zipDir(File dir,
	@SuppressWarnings("unused") ZipOutputStream out, String path, int mode,
	ZipExtraField[] extra) throws IOException {
	long thisTouchTime = (dir == null ? 0L : dir.lastModified());
	String dirName = (dir == null ? "<null>" : dir.getAbsolutePath());
	if (shouldReplace(path, thisTouchTime)) {
	if (paths.get(path) != null) {
	log("Obsoleting older " + path + " with " + dirName,
	Project.MSG_VERBOSE);
	}
	paths.put(path, new DirEntryInfo(dir, thisTouchTime, mode, extra));
	} else {
	log("Newer " + path + " already added, skipping " + dirName,
	Project.MSG_VERBOSE);
	}
	}

	@Override
	protected void zipFile(InputStream in,
	@SuppressWarnings("unused") ZipOutputStream out, String path,
	long lastModified, File fromArchive, int mode) throws IOException {

	String desc = (fromArchive == null ? "file" : "file from "
	+ fromArchive.getAbsolutePath());

	if (shouldReplace(path, lastModified)) {
	if (paths.get(path) != null) {
	log("Obsoleting older " + path + " with " + desc, Project.MSG_VERBOSE);
	}
	paths.put(path, new FileEntryInfo(in, lastModified, fromArchive, mode));
	} else {
	log("Newer " + path + " already added, skipping " + desc,
	Project.MSG_VERBOSE);
	}
	}

	private void doZipDir(File dir, ZipOutputStream out, String entryName,
	int mode, ZipExtraField[] extra) throws IOException {
	super.zipDir(dir, out, entryName, mode, extra);
	}

	private void doZipFile(InputStream inStream, ZipOutputStream out,
	String entryName, long timestamp, File archive, int mode)
	throws IOException {
	super.zipFile(inStream, out, entryName, timestamp, archive, mode);
	}

	/**
	* Checks whether an entry should be replaced, by touch dates and duplicates
	* setting.
	*
	* @param path the path of an entry being considered
	* @param touchTime the lastModified of the candiate replacement
	* @return true if the file should be replaced
	*/
	private boolean shouldReplace(String path, long touchTime) {
	EntryInfo oldInfo = paths.get(path);
	// adding from jars, we get directories with 0L time; missing should be
	// earlier than that, -1L.
	long existingTouchTime = ((oldInfo != null) ? oldInfo.getLastModified()
	: -1L);
	return (existingTouchTime < touchTime \|\| (existingTouchTime == touchTime && this.duplicate.equals("add")));
	}
	}