/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
*
* This program and the accompanying materials are made available under
* the terms of the Common Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/cpl-v10.html
*
* $Id: InstrProcessorST.java,v 1.1.1.1.2.3 2004/07/16 23:32:28 vlad_r Exp $
*/
package com.vladium.emma.instr;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.Date;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import com.vladium.jcd.cls.ClassDef;
import com.vladium.jcd.compiler.ClassWriter;
import com.vladium.jcd.parser.ClassDefParser;
import com.vladium.logging.Logger;
import com.vladium.util.ByteArrayOStream;
import com.vladium.util.Descriptors;
import com.vladium.util.Files;
import com.vladium.util.IPathEnumerator;
import com.vladium.util.IProperties;
//import com.vladium.util.Profiler;
import com.vladium.util.Property;
import com.vladium.util.asserts.$assert;
import com.vladium.util.exception.Exceptions;
//import com.vladium.utils.ObjectSizeProfiler;
import com.vladium.emma.IAppConstants;
import com.vladium.emma.IAppErrorCodes;
import com.vladium.emma.EMMAProperties;
import com.vladium.emma.EMMARuntimeException;
import com.vladium.emma.data.CoverageOptions;
import com.vladium.emma.data.CoverageOptionsFactory;
import com.vladium.emma.data.DataFactory;
import com.vladium.emma.data.IMetaData;
// ----------------------------------------------------------------------------
/**
* @author Vlad Roubtsov, (C) 2003
*/
final class InstrProcessorST extends InstrProcessor
implements IAppErrorCodes
{
// public: ................................................................
// TODO: performance of 'copy' mode could be improved by pushing dir filtering
// all the way to the path enumerator [although dir listing is reasonably fast]
// IPathEnumerator.IPathHandler:
public final void handleArchiveStart (final File parentDir, final File archive, final Manifest manifest)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleArchiveStart", "[" + parentDir + "] [" + archive + "]");
// TODO: pass manifest into this callback, if any
// TODO: detect if manifest corresonds to a previously intrumented archive already ?
if (DO_DEPENDS_CHECKING)
{
final File fullArchiveFile = Files.newFile (parentDir, archive);
m_currentArchiveTS = fullArchiveFile.lastModified ();
if ($assert.ENABLED) $assert.ASSERT (m_currentArchiveTS > 0, "invalid ts: " + m_currentArchiveTS);
}
if ((m_outMode == OutMode.OUT_MODE_FULLCOPY) || (m_outMode == OutMode.OUT_MODE_OVERWRITE))
{
final Manifest outManifest = manifest != null
? new Manifest (manifest) // shallow copy
: new Manifest ();
// set some basic main attributes:
final Attributes mainAttrs = outManifest.getMainAttributes ();
if (manifest == null) mainAttrs.put (Attributes.Name.MANIFEST_VERSION, "1.0");
mainAttrs.put (new Attributes.Name ("Created-By"), IAppConstants.APP_NAME + " v" + IAppConstants.APP_VERSION_WITH_BUILD_ID_AND_TAG);
// note: Manifest makes these 72-char-safe
mainAttrs.put (Attributes.Name.IMPLEMENTATION_TITLE, "instrumented version of [" + archive.getAbsolutePath () + "]");
mainAttrs.put (Attributes.Name.SPECIFICATION_TITLE, "instrumented on " + new Date (m_timeStamp) + " [" + Property.getSystemFingerprint () + "]");
// TODO: remove entries related to signing
if (m_outMode == OutMode.OUT_MODE_FULLCOPY)
{
// create an identically named artive in outdir/lib [the stream is
// closed in the archive end event handler]:
try
{
final OutputStream out = new FileOutputStream (getFullOutFile (parentDir, archive, IN_LIB));
m_archiveOut = outManifest != null ? new JarOutputStream (out, outManifest) : new JarOutputStream (out);
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
}
else if (m_outMode == OutMode.OUT_MODE_OVERWRITE)
{
// create a temp file in the same dir [moved into the original one
// in the archive end event handler]:
m_origArchiveFile = Files.newFile (parentDir, archive);
// length > 3:
final String archiveName = Files.getFileName (archive) + IAppConstants.APP_NAME_LC;
final String archiveExt = EMMAProperties.PROPERTY_TEMP_FILE_EXT;
try
{
m_tempArchiveFile = Files.createTempFile (parentDir, archiveName, archiveExt);
if (log.atTRACE2 ()) log.trace2 ("handleArchiveStart", "created temp archive [" + m_tempArchiveFile.getAbsolutePath () + "]");
final OutputStream out = new FileOutputStream (m_tempArchiveFile);
m_archiveOut = outManifest != null ? new JarOutputStream (out, outManifest) : new JarOutputStream (out);
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
}
}
}
public final void handleArchiveEntry (final JarInputStream in, final ZipEntry entry)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleArchiveEntry", "[" + entry.getName () + "]");
final String name = entry.getName ();
final String lcName = name.toLowerCase ();
final boolean notcopymode = (m_outMode == OutMode.OUT_MODE_FULLCOPY) || (m_outMode == OutMode.OUT_MODE_OVERWRITE);
boolean copyEntry = false;
if (lcName.endsWith (".class"))
{
final String className = name.substring (0, name.length () - 6).replace ('/', '.');
// it is possible that a class with this name has already been processed;
// however, we can't skip it here because there is no guarantee that
// the runtime classpath will be identical to the instrumentation path
// [the metadata will still contain only a single entry for a class with
// this name: it is the responsibility of the user to ensure that both
// files represent the same class; in the future I might use a more
// robust internal strategy that uses something other than a class name
// as a metadata key]
if ((m_coverageFilter == null) || m_coverageFilter.included (className))
{
InputStream clsin = null;
try
{
File outFile = null;
File fullOutFile = null;
if (DO_DEPENDS_CHECKING)
{
// in 'copy' mode
if (m_outMode == OutMode.OUT_MODE_COPY)
{
outFile = new File (className.replace ('.', File.separatorChar).concat (".class"));
fullOutFile = getFullOutFile (null, outFile, IN_CLASSES);
// if we already processed this class name within this instrumentor
// run, skip duplicates in copy mode:
if (m_mdata.hasDescriptor (Descriptors.javaNameToVMName (className)))
return;
// BUG_SF989071: using outFile here instead resulted in
// a zero result regardless of whether the target existed or not
final long outTimeStamp = fullOutFile.lastModified (); // 0 if 'fullOutFile' does not exist or if an I/O error occurs
if (outTimeStamp > 0)
{
long inTimeStamp = entry.getTime (); // can return -1
if (inTimeStamp < 0) inTimeStamp = m_currentArchiveTS; // default to the archive file timestamp
if ($assert.ENABLED) $assert.ASSERT (inTimeStamp > 0);
if (inTimeStamp <= outTimeStamp)
{
if (log.atVERBOSE ()) log.verbose ("destination file [" + outFile + "] skipped: more recent than the source");
return;
}
}
}
}
readZipEntry (in, entry);
final ClassDef clsDef = ClassDefParser.parseClass (m_readbuf, m_readpos);
m_visitor.process (clsDef, m_outMode == OutMode.OUT_MODE_OVERWRITE, true, true, m_instrResult);
if (m_instrResult.m_instrumented)
{
if ($assert.ENABLED) $assert.ASSERT (m_instrResult.m_descriptor != null, "no descriptor created for an instrumented class");
++ m_classInstrs;
// update metadata [if this class has not been seen before]:
m_mdata.add (m_instrResult.m_descriptor, false);
// class def modified: write it to an array and submit a write job
m_baos.reset ();
ClassWriter.writeClassTable (clsDef, m_baos);
if (notcopymode)
{
// [destination is a zip entry]
entry.setTime (m_timeStamp);
addJob (new EntryWriteJob (m_archiveOut, m_baos.copyByteArray (), entry, false));
}
else // copy mode
{
// [destination is a file]
if (! DO_DEPENDS_CHECKING) // this block is just a complement to the one above (where fullOutFile is inited)
{
outFile = new File (className.replace ('.', File.separatorChar).concat (".class"));
fullOutFile = getFullOutFile (null, outFile, IN_CLASSES);
}
addJob (new FileWriteJob (fullOutFile, m_baos.copyByteArray (), true));
}
}
else if (notcopymode)
{
// original class def already read into m_readbuf:
// clone the array and submit an entry write job
final byte [] data = new byte [m_readpos];
System.arraycopy (m_readbuf, 0, data, 0, data.length);
++ m_classCopies;
entry.setTime (m_timeStamp);
addJob (new EntryWriteJob (m_archiveOut, data, entry, true));
}
}
catch (FileNotFoundException fnfe)
{
// ignore: this should never happen
if ($assert.ENABLED)
{
fnfe.printStackTrace (System.out);
}
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
finally
{
if (clsin != null)
try
{
clsin.close ();
}
catch (Exception e)
{
// TODO: error code
throw new EMMARuntimeException (e);
}
}
}
else
{
// copy excluded .class entries in full copy and overwrite modes:
copyEntry = notcopymode;
}
}
else
{
// copy non-.class entries in full copy and overwrite modes:
copyEntry = notcopymode;
// skipping these entries here is important: this is done as a complement
// to Sun jar API workarounds as detailed in PathEnumerator.enumeratePathArchive():
if (copyEntry && name.equalsIgnoreCase ("META-INF/"))
copyEntry = false;
if (copyEntry && name.equalsIgnoreCase (JarFile.MANIFEST_NAME))
copyEntry = false;
// TODO: skip signature-related entries (.SF and .RSA/.DSA/.PGP)
}
if (copyEntry)
{
try
{
readZipEntry (in, entry);
final byte [] data = new byte [m_readpos];
System.arraycopy (m_readbuf, 0, data, 0, data.length);
++ m_classCopies;
entry.setTime (m_timeStamp);
addJob (new EntryWriteJob (m_archiveOut, data, entry, true));
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
}
}
public final void handleArchiveEnd (final File parentDir, final File archive)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleArchiveEnd", "[" + parentDir + "] [" + archive + "]");
m_currentArchiveTS = Long.MAX_VALUE;
if ((m_outMode == OutMode.OUT_MODE_FULLCOPY) || (m_outMode == OutMode.OUT_MODE_OVERWRITE))
{
try
{
drainJobQueue (); // drain the queue before closing the archive
m_archiveOut.flush ();
m_archiveOut.close ();
m_archiveOut = null;
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
// in overwrite mode replace the original archive with the temp archive:
if (m_outMode == OutMode.OUT_MODE_OVERWRITE)
{
if (! Files.renameFile (m_tempArchiveFile, m_origArchiveFile, true)) // overwrite the original archive
{
// TODO: disable temp file cleanup in this case so that the user
// could do it manually later?
// error code
throw new EMMARuntimeException ("could not rename temporary file [" + m_tempArchiveFile + "] to [" + m_origArchiveFile + "]: make sure the original file is not locked and can be deleted");
}
else
{
if (log.atTRACE2 ()) log.trace2 ("handleArchiveEnd", "renamed temp archive [" + m_tempArchiveFile.getAbsolutePath () + "] to [" + m_origArchiveFile + "]");
m_origArchiveFile = m_tempArchiveFile = null;
}
}
}
}
public final void handleDirStart (final File pathDir, final File dir)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleDirStart", "[" + pathDir + "] [" + dir + "]");
// in full copy mode, create all dirs here; in copy mode, do it as part
// of writing each individual file:
if (m_outMode == OutMode.OUT_MODE_FULLCOPY)
{
final File saveDir = new File (getFullOutDir (pathDir, IN_CLASSES), dir.getPath ());
createDir (saveDir, true);
}
}
public final void handleFile (final File pathDir, final File file)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleFile", "[" + pathDir + "] [" + file + "]");
final String name = file.getPath ();
final String lcName = name.toLowerCase ();
final boolean fullcopymode = (m_outMode == OutMode.OUT_MODE_FULLCOPY);
final boolean mkdir = (m_outMode == OutMode.OUT_MODE_COPY);
boolean copyFile = false;
if (lcName.endsWith (".class"))
{
final String className = name.substring (0, name.length () - 6).replace (File.separatorChar, '.');
// it is possible that a class with this name has already been processed;
// however, we can't skip it here because there is no guarantee that
// the runtime classpath will be identical to the instrumentation path
// [the metadata will still contain only a single entry for a class with
// this name: it is the responsibility of the user to ensure that both
// files represent the same class; in the future I might use a more
// robust internal strategy that uses something other than a class name
// as a metadata key]
if ((m_coverageFilter == null) || m_coverageFilter.included (className))
{
InputStream clsin = null;
try
{
final File inFile = Files.newFile (pathDir, file.getPath ());
final File fullOutFile = getFullOutFile (pathDir, file, IN_CLASSES);
if (DO_DEPENDS_CHECKING)
{
if (m_outMode == OutMode.OUT_MODE_COPY)
{
// if we already processed this class name within this instrumentor
// run, skip duplicates in copy mode:
if (m_mdata.hasDescriptor (Descriptors.javaNameToVMName (className)))
return;
// otherwise, instrument only if the dest file is out of date
// wrt to the source file:
final long outTimeStamp = fullOutFile.lastModified (); // 0 if 'fullOutFile' does not exist or if an I/O error occurs
if (outTimeStamp > 0)
{
final long inTimeStamp = inFile.lastModified ();
if (inTimeStamp <= outTimeStamp)
{
if (log.atVERBOSE ()) log.verbose ("destination file [" + fullOutFile + "] skipped: more recent that the source file");
return;
}
}
}
}
readFile (inFile);
ClassDef clsDef = ClassDefParser.parseClass (m_readbuf, m_readpos);
// in non-overwrite modes, bail if src file already instrumented:
m_visitor.process (clsDef, m_outMode == OutMode.OUT_MODE_OVERWRITE, true, true, m_instrResult);
if (m_instrResult.m_instrumented)
{
if ($assert.ENABLED) $assert.ASSERT (m_instrResult.m_descriptor != null, "no descriptor created for an instrumented class");
++ m_classInstrs;
// update metadata [if this class has not been seen before]:
// ObjectSizeProfiler.SizeProfile profile = ObjectSizeProfiler.profile (m_instrResult.m_descriptor, true);
// System.out.println (clsDef.getName () + " metadata:");
// System.out.println (profile.root ().dump (0.2));
m_mdata.add (m_instrResult.m_descriptor, false);
// class def modified: write it to an array and submit a write job
m_baos.reset ();
ClassWriter.writeClassTable (clsDef, m_baos);
clsDef = null;
final byte [] outdata = m_baos.copyByteArray ();
addJob (new FileWriteJob (fullOutFile, outdata, mkdir));
}
else if (fullcopymode)
{
// original class def already read into m_readbuf:
// clone the array and submit a file write job
clsDef = null;
final byte [] outdata = new byte [m_readpos];
System.arraycopy (m_readbuf, 0, outdata, 0, m_readpos);
++ m_classCopies;
addJob (new FileWriteJob (fullOutFile, outdata, mkdir));
}
}
catch (FileNotFoundException fnfe)
{
// ignore: this should never happen
if ($assert.ENABLED)
{
fnfe.printStackTrace (System.out);
}
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
finally
{
if (clsin != null)
try
{
clsin.close ();
}
catch (Exception e)
{
// TODO: error code
throw new EMMARuntimeException (e);
}
}
}
else
{
// copy excluded .class files in full copy mode:
copyFile = fullcopymode;
}
}
else
{
// copy non-.class files in full copy mode:
copyFile = fullcopymode;
}
if (copyFile)
{
try
{
final File inFile = Files.newFile (pathDir, file.getPath ());
readFile (inFile);
final byte [] data = new byte [m_readpos];
System.arraycopy (m_readbuf, 0, data, 0, data.length);
++ m_classCopies;
final File outFile = getFullOutFile (pathDir, file, IN_CLASSES);
addJob (new FileWriteJob (outFile, data, mkdir));
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
}
}
public final void handleDirEnd (final File pathDir, final File dir)
{
final Logger log = m_log;
if (log.atTRACE2 ()) log.trace2 ("handleDirEnd", "[" + pathDir + "] [" + dir + "]");
// in overwrite mode, flush the job queue before going to the next directory:
if (m_outMode == OutMode.OUT_MODE_OVERWRITE)
{
try
{
drainJobQueue ();
}
catch (IOException ioe)
{
// TODO: error code
throw new EMMARuntimeException (ioe);
}
}
}
// protected: .............................................................
protected void reset ()
{
m_visitor = null;
m_mdata = null;
m_readbuf = null;
m_baos = null;
for (int j = 0; j < m_jobs.length; ++ j) m_jobs [j] = null;
if (CLEANUP_TEMP_ARCHIVE_ON_ERRORS)
{
if (m_archiveOut != null)
try { m_archiveOut.close (); } catch (Exception ignore) {} // unlock the file descriptor for deletion
if (m_tempArchiveFile != null)
m_tempArchiveFile.delete ();
}
m_archiveOut = null;
m_origArchiveFile = null;
m_tempArchiveFile = null;
super.reset ();
}
protected void _run (final IProperties toolProperties)
{
final Logger log = m_log;
final boolean verbose = log.atVERBOSE ();
if (verbose)
{
log.verbose (IAppConstants.APP_VERBOSE_BUILD_ID);
// [assertion: m_instrPath != null]
log.verbose ("instrumentation path:");
log.verbose ("{");
for (int p = 0; p < m_instrPath.length; ++ p)
{
final File f = m_instrPath [p];
final String nonexistent = f.exists () ? "" : "{nonexistent} ";
log.verbose (" " + nonexistent + f.getAbsolutePath ());
}
log.verbose ("}");
// [assertion: m_outMode != null]
log.verbose ("instrumentation output mode: " + m_outMode);
}
else
{
log.info ("processing instrumentation path ...");
}
RuntimeException failure = null;
try
{
long start = System.currentTimeMillis ();
m_timeStamp = start;
// construct instr path enumerator [throws on illegal input only]:
final IPathEnumerator enumerator = IPathEnumerator.Factory.create (m_instrPath, m_canonical, this);
// create out dir(s):
{
if (m_outMode != OutMode.OUT_MODE_OVERWRITE) createDir (m_outDir, true);
if ((m_outMode == OutMode.OUT_MODE_FULLCOPY))
{
final File classesDir = Files.newFile (m_outDir, CLASSES);
createDir (classesDir, false); // note: not using mkdirs() here
final File libDir = Files.newFile (m_outDir, LIB);
createDir (libDir, false); // note: not using mkdirs() here
}
}
// get the data out settings [note: this is not conditioned on m_dumpRawData]:
File mdataOutFile = m_mdataOutFile;
Boolean mdataOutMerge = m_mdataOutMerge;
{
if (mdataOutFile == null)
mdataOutFile = new File (toolProperties.getProperty (EMMAProperties.PROPERTY_META_DATA_OUT_FILE,
EMMAProperties.DEFAULT_META_DATA_OUT_FILE));
if (mdataOutMerge == null)
{
final String _dataOutMerge = toolProperties.getProperty (EMMAProperties.PROPERTY_META_DATA_OUT_MERGE,
EMMAProperties.DEFAULT_META_DATA_OUT_MERGE.toString ());
mdataOutMerge = Property.toBoolean (_dataOutMerge) ? Boolean.TRUE : Boolean.FALSE;
}
}
if (verbose)
{
log.verbose ("metadata output file: " + mdataOutFile.getAbsolutePath ());
log.verbose ("metadata output merge mode: " + mdataOutMerge);
}
// TODO: can also register an exit hook to clean up temp files, but this is low value
// allocate I/O buffers:
m_readbuf = new byte [BUF_SIZE]; // don't reuse this across run() calls to reset it to the original size
m_readpos = 0;
m_baos = new ByteArrayOStream (BUF_SIZE); // don't reuse this across run() calls to reset it to the original size
// reset job queue position:
m_jobPos = 0;
m_currentArchiveTS = Long.MAX_VALUE;
final CoverageOptions options = CoverageOptionsFactory.create (toolProperties);
m_visitor = new InstrVisitor (options); // TODO: reuse this?
m_mdata = DataFactory.newMetaData (options);
// actual work is driven by the path enumerator:
try
{
enumerator.enumerate ();
drainJobQueue ();
}
catch (IOException ioe)
{
throw new EMMARuntimeException (INSTR_IO_FAILURE, ioe);
}
if (log.atINFO ())
{
final long end = System.currentTimeMillis ();
log.info ("instrumentation path processed in " + (end - start) + " ms");
log.info ("[" + m_classInstrs + " class(es) instrumented, " + m_classCopies + " resource(s) copied]");
}
// persist metadata:
try
{
// TODO: create an empty file earlier to catch any errors sooner? [to avoid scenarios where a user waits throught the entire instr run to find out the file could not be written to]
if ($assert.ENABLED) $assert.ASSERT (mdataOutFile != null, "m_metadataOutFile is null");
if (verbose)
{
if (m_mdata != null)
{
log.verbose ("metadata contains " + m_mdata.size () + " entries");
}
}
if (m_mdata.isEmpty ())
{
log.info ("no output created: metadata is empty");
}
else
{
start = System.currentTimeMillis ();
DataFactory.persist (m_mdata, mdataOutFile, mdataOutMerge.booleanValue ());
final long end = System.currentTimeMillis ();
if (log.atINFO ())
{
log.info ("metadata " + (mdataOutMerge.booleanValue () ? "merged into" : "written to") + " [" + mdataOutFile.getAbsolutePath () + "] {in " + (end - start) + " ms}");
}
}
}
catch (IOException ioe)
{
throw new EMMARuntimeException (OUT_IO_FAILURE, new Object [] {mdataOutFile.getAbsolutePath ()}, ioe);
}
}
catch (SecurityException se)
{
failure = new EMMARuntimeException (SECURITY_RESTRICTION, new String [] {IAppConstants.APP_NAME}, se);
}
catch (RuntimeException re)
{
failure = re;
}
finally
{
reset ();
}
if (failure != null)
{
if (Exceptions.unexpectedFailure (failure, EXPECTED_FAILURES))
{
throw new EMMARuntimeException (UNEXPECTED_FAILURE,
new Object [] {failure.toString (), IAppConstants.APP_BUG_REPORT_LINK},
failure);
}
else
throw failure;
}
}
// package: ...............................................................
InstrProcessorST ()
{
m_jobs = new Job [JOB_QUEUE_SIZE];
m_instrResult = new InstrVisitor.InstrResult ();
}
static void writeFile (final byte [] data, final File outFile, final boolean mkdirs)
throws IOException
{
RandomAccessFile raf = null;
try
{
if (mkdirs)
{
final File parent = outFile.getParentFile ();
if (parent != null) parent.mkdirs (); // no error checking here [errors will be throw below]
}
raf = new RandomAccessFile (outFile, "rw");
if (DO_RAF_EXTENSION) raf.setLength (data.length);
raf.write (data);
}
finally
{
if (raf != null) raf.close (); // note: intentionally letting the exception percolate up
}
}
static void writeZipEntry (final byte [] data, final ZipOutputStream out, final ZipEntry entry, final boolean isCopy)
throws IOException
{
if (isCopy)
{
out.putNextEntry (entry); // reusing ' entry' is ok here because we are not changing the data
try
{
out.write (data);
}
finally
{
out.closeEntry ();
}
}
else
{
// need to compute the checksum which slows things down quite a bit:
final ZipEntry entryCopy = new ZipEntry (entry.getName ());
entryCopy.setTime (entry.getTime ()); // avoid repeated calls to System.currentTimeMillis() inside the zip stream
entryCopy.setMethod (ZipOutputStream.STORED);
// [directory status is implicit in the name]
entryCopy.setSize (data.length);
entryCopy.setCompressedSize (data.length);
final CRC32 crc = new CRC32 ();
crc.update (data);
entryCopy.setCrc (crc.getValue ());
out.putNextEntry (entryCopy);
try
{
out.write (data);
}
finally
{
out.closeEntry ();
}
}
}
// private: ...............................................................
private static abstract class Job
{
protected abstract void run () throws IOException;
} // end of nested class
private static final class FileWriteJob extends Job
{
protected void run () throws IOException
{
writeFile (m_data, m_outFile, m_mkdirs);
m_data = null;
}
FileWriteJob (final File outFile, final byte [] data, final boolean mkdirs)
{
m_outFile = outFile;
m_data = data;
m_mkdirs = mkdirs;
}
final File m_outFile;
final boolean m_mkdirs;
byte [] m_data;
} // end of nested class
private static final class EntryWriteJob extends Job
{
protected void run () throws IOException
{
writeZipEntry (m_data, m_out, m_entry, m_isCopy);
m_data = null;
}
EntryWriteJob (final ZipOutputStream out, final byte [] data, final ZipEntry entry, final boolean isCopy)
{
m_out = out;
m_data = data;
m_entry = entry;
m_isCopy = isCopy;
}
final ZipOutputStream m_out;
byte [] m_data;
final ZipEntry m_entry;
final boolean m_isCopy;
} // end of nested class
private void addJob (final Job job)
throws FileNotFoundException, IOException
{
if (m_jobPos == JOB_QUEUE_SIZE) drainJobQueue ();
m_jobs [m_jobPos ++] = job;
}
private void drainJobQueue ()
throws IOException
{
for (int j = 0; j < m_jobPos; ++ j)
{
final Job job = m_jobs [j];
if (job != null) // a guard just in case
{
m_jobs [j] = null;
job.run ();
}
}
m_jobPos = 0;
}
/*
* Reads into m_readbuf (m_readpos is updated correspondingly)
*/
private void readFile (final File file)
throws IOException
{
final int length = (int) file.length ();
ensureReadCapacity (length);
InputStream in = null;
try
{
in = new FileInputStream (file);
int totalread = 0;
for (int read;
(totalread < length) && (read = in.read (m_readbuf, totalread, length - totalread)) >= 0;
totalread += read);
m_readpos = totalread;
}
finally
{
if (in != null) try { in.close (); } catch (Exception ignore) {}
}
}
/*
* Reads into m_readbuf (m_readpos is updated correspondingly)
*/
private void readZipEntry (final ZipInputStream in, final ZipEntry entry)
throws IOException
{
final int length = (int) entry.getSize (); // can be -1 if unknown
if (length >= 0)
{
ensureReadCapacity (length);
int totalread = 0;
for (int read;
(totalread < length) && (read = in.read (m_readbuf, totalread, length - totalread)) >= 0;
totalread += read);
m_readpos = totalread;
}
else
{
ensureReadCapacity (BUF_SIZE);
m_baos.reset ();
for (int read; (read = in.read (m_readbuf)) >= 0; m_baos.write (m_readbuf, 0, read));
m_readbuf = m_baos.copyByteArray ();
m_readpos = m_readbuf.length;
}
}
private void ensureReadCapacity (final int capacity)
{
if (m_readbuf.length < capacity)
{
final int readbuflen = m_readbuf.length;
m_readbuf = null;
m_readbuf = new byte [Math.max (readbuflen << 1, capacity)];
}
}
// internal run()-scoped state:
private final Job [] m_jobs;
private final InstrVisitor.InstrResult m_instrResult;
private InstrVisitor m_visitor;
private IMetaData m_mdata;
private byte [] m_readbuf;
private int m_readpos;
private ByteArrayOStream m_baos; // TODO: code to guard this from becoming too large
private int m_jobPos;
private long m_currentArchiveTS;
private File m_origArchiveFile, m_tempArchiveFile;
private JarOutputStream m_archiveOut;
private long m_timeStamp;
private static final int BUF_SIZE = 32 * 1024;
private static final int JOB_QUEUE_SIZE = 128; // a reasonable size chosen empirically after testing a few SCSI/IDE machines
private static final boolean CLEANUP_TEMP_ARCHIVE_ON_ERRORS = true;
private static final boolean DO_RAF_EXTENSION = true;
private static final boolean DO_DEPENDS_CHECKING = true;
private static final Class [] EXPECTED_FAILURES; // set in <clinit>
static
{
EXPECTED_FAILURES = new Class []
{
EMMARuntimeException.class,
IllegalArgumentException.class,
IllegalStateException.class,
};
}
} // end of class
// ---------------------------------------------------------------------------- |
