| /* 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 |
| // ---------------------------------------------------------------------------- |
