| /* 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: AppRunner.java,v 1.1.1.1.2.2 2004/07/16 23:32:03 vlad_r Exp $ |
| */ |
| package com.vladium.emma.rt; |
| |
| import java.io.File; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import com.vladium.logging.Logger; |
| import com.vladium.util.Files; |
| import com.vladium.util.IConstants; |
| import com.vladium.util.IProperties; |
| import com.vladium.util.Property; |
| import com.vladium.util.SoftValueMap; |
| import com.vladium.util.Strings; |
| import com.vladium.util.asserts.$assert; |
| import com.vladium.util.exception.Exceptions; |
| import com.vladium.util.exit.ExitHookManager; |
| import com.vladium.emma.AppLoggers; |
| import com.vladium.emma.IAppConstants; |
| import com.vladium.emma.IAppErrorCodes; |
| import com.vladium.emma.EMMAProperties; |
| import com.vladium.emma.EMMARuntimeException; |
| import com.vladium.emma.Processor; |
| import com.vladium.emma.filter.IInclExclFilter; |
| import com.vladium.emma.data.CoverageOptionsFactory; |
| import com.vladium.emma.data.IMetaData; |
| import com.vladium.emma.data.ICoverageData; |
| import com.vladium.emma.data.DataFactory; |
| import com.vladium.emma.data.ISessionData; |
| import com.vladium.emma.data.SessionData; |
| import com.vladium.emma.report.AbstractReportGenerator; |
| import com.vladium.emma.report.IReportGenerator; |
| import com.vladium.emma.report.SourcePathCache; |
| |
| // ---------------------------------------------------------------------------- |
| /** |
| * @author Vlad Roubtsov, (C) 2003 |
| */ |
| public |
| final class AppRunner extends Processor |
| implements IAppErrorCodes |
| { |
| // public: ................................................................ |
| |
| |
| public static AppRunner create (final ClassLoader delegate) |
| { |
| return new AppRunner (delegate); |
| } |
| |
| |
| public synchronized void run () |
| { |
| validateState (); |
| |
| // disable Runtime's own exit hook: |
| RTSettings.setStandaloneMode (false); // an optimization to disable RT's static init code [this line must precede any reference to RT] |
| RT.reset (true, false); // reset RT [RT creates 'cdata' and loads app properties] |
| |
| // load tool properties: |
| final IProperties toolProperties; |
| { |
| IProperties appProperties = RT.getAppProperties (); // try to use app props consistent with RT's view of them |
| if (appProperties == null) appProperties = EMMAProperties.getAppProperties (); // don't use combine() |
| |
| toolProperties = IProperties.Factory.combine (m_propertyOverrides, appProperties); |
| } |
| if ($assert.ENABLED) $assert.ASSERT (toolProperties != null, "toolProperties is null"); // can be empty, though |
| |
| final Logger current = Logger.getLogger (); |
| final Logger log = AppLoggers.create (m_appName, toolProperties, current); |
| |
| if (log.atTRACE1 ()) |
| { |
| log.trace1 ("run", "complete tool properties:"); |
| toolProperties.list (log.getWriter ()); |
| } |
| |
| try |
| { |
| Logger.push (log); |
| m_log = log; |
| |
| _run (toolProperties); |
| } |
| finally |
| { |
| if (m_log != null) |
| { |
| Logger.pop (m_log); |
| m_log = null; |
| } |
| } |
| } |
| |
| |
| /** |
| * @param path [null is equivalent to empty array] |
| * @param canonical |
| */ |
| public synchronized void setCoveragePath (String [] path, final boolean canonical) |
| { |
| if ((path == null) || (path.length == 0)) |
| m_coveragePath = IConstants.EMPTY_FILE_ARRAY; |
| else |
| m_coveragePath = Files.pathToFiles (path, canonical); |
| |
| m_canonical = canonical; |
| } |
| |
| public synchronized void setScanCoveragePath (final boolean scan) |
| { |
| m_scanCoveragePath = scan; |
| } |
| |
| /** |
| * @param path [null is equivalent to no source path] |
| */ |
| public synchronized void setSourcePath (final String [] path) |
| { |
| if (path == null) |
| m_sourcePath = null; |
| else |
| m_sourcePath = Files.pathToFiles (path, true); // always canonicalize source path |
| } |
| |
| /** |
| * |
| * @param specs [null is equivalent to no filtering (everything is included)] |
| */ |
| public synchronized final void setInclExclFilter (final String [] specs) |
| { |
| if (specs == null) |
| m_coverageFilter = null; |
| else |
| m_coverageFilter = IInclExclFilter.Factory.create (specs); |
| } |
| |
| /** |
| * |
| * @param className [may not be null or empty] |
| * @param args [null is equivalent to an empty array] |
| */ |
| public synchronized void setAppClass (final String className, final String [] args) |
| { |
| if ((className == null) || (className.length () == 0)) |
| throw new IllegalArgumentException ("null/empty input: className"); |
| |
| if (args != null) |
| { |
| final String [] _args = (String []) args.clone (); |
| |
| for (int a = 0; a < _args.length; ++ a) |
| if (_args [a] == null) throw new IllegalArgumentException ("null input: args[" + a + "]"); |
| |
| m_appArgs = _args; |
| } |
| else |
| { |
| m_appArgs = IConstants.EMPTY_STRING_ARRAY; |
| } |
| |
| m_appClassName = className; |
| } |
| |
| public synchronized void setDumpSessionData (final boolean dump) |
| { |
| m_dumpSessionData = dump; |
| } |
| |
| /** |
| * |
| * @param fileName [null unsets the previous override setting] |
| */ |
| public synchronized final void setSessionOutFile (final String fileName) |
| { |
| if (fileName == null) |
| m_sdataOutFile = null; |
| else |
| { |
| final File _file = new File (fileName); |
| |
| if (_file.exists () && ! _file.isFile ()) |
| throw new IllegalArgumentException ("not a file: [" + _file.getAbsolutePath () + "]"); |
| |
| m_sdataOutFile = _file; |
| } |
| } |
| |
| /** |
| * |
| * @param merge [null unsets the previous override setting] |
| */ |
| public synchronized final void setSessionOutMerge (final Boolean merge) |
| { |
| m_sdataOutMerge = merge; |
| } |
| |
| /** |
| * |
| * @param types [may not be null] |
| */ |
| public synchronized void setReportTypes (final String [] types) |
| { |
| if (types == null) throw new IllegalArgumentException ("null input: types"); |
| |
| final String [] reportTypes = Strings.removeDuplicates (types, true); |
| if (reportTypes.length == 0) throw new IllegalArgumentException ("empty input: types"); |
| |
| if ($assert.ENABLED) $assert.ASSERT (reportTypes != null && reportTypes.length > 0); |
| |
| |
| final IReportGenerator [] reportGenerators = new IReportGenerator [reportTypes.length]; |
| for (int t = 0; t < reportTypes.length; ++ t) |
| { |
| reportGenerators [t] = AbstractReportGenerator.create (reportTypes [t]); |
| } |
| |
| m_reportGenerators = reportGenerators; |
| } |
| |
| // protected: ............................................................. |
| |
| |
| protected void validateState () |
| { |
| super.validateState (); |
| |
| if ((m_appClassName == null) || (m_appClassName.length () == 0)) |
| throw new IllegalStateException ("application class name not set"); |
| |
| if (m_appArgs == null) |
| throw new IllegalStateException ("application arguments not set"); |
| |
| if (m_coveragePath == null) |
| throw new IllegalStateException ("coverage path not set"); |
| |
| // [m_coverageFilter can be null] |
| |
| // [m_sdataOutFile can be null] |
| // [m_sdataOutMerge can be null] |
| |
| if ((m_reportGenerators == null) || (m_reportGenerators.length == 0)) |
| throw new IllegalStateException ("report types not set"); |
| |
| // [m_sourcePath can be null/empty] |
| |
| // [m_propertyOverrides can be null] |
| } |
| |
| |
| 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_coveragePath != null] |
| log.verbose ("coverage path:"); |
| log.verbose ("{"); |
| for (int p = 0; p < m_coveragePath.length; ++ p) |
| { |
| final File f = m_coveragePath [p]; |
| final String nonexistent = f.exists () ? "" : "{nonexistent} "; |
| |
| log.verbose (" " + nonexistent + f.getAbsolutePath ()); |
| } |
| log.verbose ("}"); |
| |
| if ((m_sourcePath == null) || (m_sourcePath.length == 0)) |
| { |
| log.verbose ("source path not set"); |
| } |
| else |
| { |
| log.verbose ("source path:"); |
| log.verbose ("{"); |
| for (int p = 0; p < m_sourcePath.length; ++ p) |
| { |
| final File f = m_sourcePath [p]; |
| final String nonexistent = f.exists () ? "" : "{nonexistent} "; |
| |
| log.verbose (" " + nonexistent + f.getAbsolutePath ()); |
| } |
| log.verbose ("}"); |
| } |
| } |
| |
| // get the data out settings [note: this is not conditioned on m_dumpRawData]: |
| File sdataOutFile = m_sdataOutFile; |
| Boolean sdataOutMerge = m_sdataOutMerge; |
| { |
| if (sdataOutFile == null) |
| sdataOutFile = new File (toolProperties.getProperty (EMMAProperties.PROPERTY_SESSION_DATA_OUT_FILE, |
| EMMAProperties.DEFAULT_SESSION_DATA_OUT_FILE)); |
| |
| if (sdataOutMerge == null) |
| { |
| final String _dataOutMerge = toolProperties.getProperty (EMMAProperties.PROPERTY_SESSION_DATA_OUT_MERGE, |
| EMMAProperties.DEFAULT_SESSION_DATA_OUT_MERGE.toString ()); |
| sdataOutMerge = Property.toBoolean (_dataOutMerge) ? Boolean.TRUE : Boolean.FALSE; |
| } |
| } |
| |
| if (verbose && m_dumpSessionData) |
| { |
| log.verbose ("session data output file: " + sdataOutFile.getAbsolutePath ()); |
| log.verbose ("session data output merge mode: " + sdataOutMerge); |
| } |
| |
| // get instr class loader delegation filter settings: |
| final IInclExclFilter forcedDelegationFilter |
| = IInclExclFilter.Factory.create (toolProperties.getProperty (InstrClassLoader.PROPERTY_FORCED_DELEGATION_FILTER), |
| COMMA_DELIMITERS, FORCED_DELEGATION_FILTER_SPECS); |
| final IInclExclFilter throughDelegationFilter |
| = IInclExclFilter.Factory.create (toolProperties.getProperty (InstrClassLoader.PROPERTY_THROUGH_DELEGATION_FILTER), |
| COMMA_DELIMITERS, null); |
| |
| |
| // TODO: consider injecting Runtime straight into appLoader namespace... |
| // TODO: create a thread group for all exit hooks? |
| |
| |
| // get a handle to exit hook manager singleton: |
| ExitHookManager runnerExitHookManager = null; |
| try |
| { |
| runnerExitHookManager = ExitHookManager.getSingleton (); // can throw |
| } |
| catch (Exception e) |
| { |
| // TODO: log/handle/warn |
| e.printStackTrace (System.out); |
| } |
| |
| AppRunnerExitHook runnerExitHook = null; |
| RuntimeException failure = null; |
| |
| try |
| { |
| SourcePathCache srcpathCache = null; |
| if (m_sourcePath != null) srcpathCache = new SourcePathCache (m_sourcePath, true); // ignore non-existent source dirs |
| |
| // create session data containers: |
| ICoverageData cdata = RT.getCoverageData (); |
| if ($assert.ENABLED) $assert.ASSERT (cdata != null, "cdata is null"); |
| |
| IMetaData mdata = DataFactory.newMetaData (CoverageOptionsFactory.create (toolProperties)); |
| |
| runnerExitHook = new AppRunnerExitHook (log, m_dumpSessionData, sdataOutFile, sdataOutMerge.booleanValue (), mdata, cdata, m_reportGenerators, srcpathCache, toolProperties); |
| |
| if (runnerExitHookManager != null) |
| runnerExitHookManager.addExitHook (runnerExitHook); |
| |
| // --------------[ start of exit hook-protected section ]-------------- |
| |
| Map classIOCache = null; |
| |
| // scan the classpath to populate the initial metadata: |
| if (m_scanCoveragePath) |
| { |
| if (USE_SOFT_CACHE) |
| classIOCache = new SoftValueMap (INIT_CACHE_CAPACITY, 0.75F, SOFT_CACHE_READ_CHK_FREQUENCY, SOFT_CACHE_WRITE_CHK_FREQUENCY); |
| else |
| classIOCache = new HashMap (INIT_CACHE_CAPACITY, 0.75F); |
| |
| final ClassPathProcessorST processor = new ClassPathProcessorST (m_coveragePath, m_canonical, mdata, m_coverageFilter, classIOCache); |
| |
| // with a bit of work [ClassPathProcessorST needs to lock on the |
| // metadata, etc] this could be run concurrently with the app |
| // itself to improve perceived performance, however, I am not |
| // going to invest time in this; |
| |
| // populate 'cache' [optional] and 'mdata': |
| processor.run (); |
| |
| if (log.atTRACE1 ()) |
| { |
| log.trace1 ("run", "class cache size after cp scan: " + classIOCache.size ()); |
| log.trace1 ("run", "metadata size after cp scan: " + mdata.size ()); |
| } |
| } |
| |
| |
| // app runner does not need these handles anymore [only the exit hook runner maintains them]: |
| srcpathCache = null; |
| cdata = null; |
| |
| final ClassLoader appLoader; |
| { |
| final IClassLoadHook loadHook = new InstrClassLoadHook (m_coverageFilter, mdata); |
| |
| try |
| { |
| appLoader = new InstrClassLoader (m_delegate, m_coveragePath, forcedDelegationFilter, throughDelegationFilter, loadHook, classIOCache); |
| } |
| catch (SecurityException se) |
| { |
| throw new EMMARuntimeException (SECURITY_RESTRICTION, new String [] {IAppConstants.APP_NAME}, se); |
| } |
| catch (MalformedURLException mue) |
| { |
| throw new EMMARuntimeException (mue); |
| } |
| } |
| |
| // app runner does not need these handles anymore: |
| mdata = null; |
| classIOCache = null; |
| |
| |
| final ClassLoader contextLoader; |
| boolean contextLoaderSet = false; |
| if (SET_CURRENT_CONTEXT_LOADER) |
| { |
| try |
| { |
| final Thread currentThread = Thread.currentThread (); |
| |
| // TODO: rethink if this is the right place to do this |
| contextLoader = currentThread.getContextClassLoader (); |
| currentThread.setContextClassLoader (appLoader); |
| |
| contextLoaderSet = true; |
| } |
| catch (SecurityException se) |
| { |
| throw new EMMARuntimeException (SECURITY_RESTRICTION, new String [] {IAppConstants.APP_NAME}, se); |
| } |
| } |
| |
| |
| ThreadGroup appThreadGroup = null; |
| try |
| { |
| // load [and possibly initialize] the app class: |
| |
| final Class appClass; |
| try |
| { |
| // load [and force early initialization if INIT_AT_LOAD_TIME is 'true']: |
| appClass = Class.forName (m_appClassName, INIT_AT_LOAD_TIME, appLoader); |
| } |
| catch (ClassNotFoundException cnfe) |
| { |
| // TODO: dump the classloader tree into the error message as well |
| throw new EMMARuntimeException (MAIN_CLASS_NOT_FOUND, new String [] {m_appClassName}, cnfe); |
| } |
| catch (ExceptionInInitializerError eiie) // this should not happen for INIT_AT_LOAD_TIME=false |
| { |
| final Throwable cause = eiie.getException (); |
| |
| throw new EMMARuntimeException (MAIN_CLASS_LOAD_FAILURE, new String [] {m_appClassName, cause.toString ()}, cause); |
| } |
| catch (Throwable t) |
| { |
| throw new EMMARuntimeException (MAIN_CLASS_NOT_FOUND, new String [] {m_appClassName}, t); |
| } |
| |
| // ensure that the app is bootstrapped using appLoader: |
| { |
| final ClassLoader actualLoader = appClass.getClassLoader (); |
| if (actualLoader != appLoader) |
| { |
| final String loaderName = actualLoader != null ? actualLoader.getClass ().getName () : "<PRIMORDIAL>"; |
| |
| throw new EMMARuntimeException (MAIN_CLASS_BAD_DELEGATION, new String [] {IAppConstants.APP_NAME, m_appClassName, loaderName}); |
| } |
| } |
| |
| // run the app's main(): |
| |
| final Method appMain; |
| try |
| { |
| // this causes initialization on some non-Sun-compatible JVMs [ignore]: |
| appMain = appClass.getMethod ("main", MAIN_TYPE); // Sun JVMs do not seem to require the method to be declared |
| } |
| catch (Throwable t) |
| { |
| throw new EMMARuntimeException (MAIN_METHOD_NOT_FOUND, new String [] {m_appClassName}, t); |
| } |
| |
| Invoker invoker = new Invoker (appMain, null, new Object [] {m_appArgs}); |
| |
| appThreadGroup = new ThreadGroup (IAppConstants.APP_NAME + " thread group [" + m_appClassName + "]"); |
| appThreadGroup.setDaemon (true); |
| |
| Thread appThread = new Thread (appThreadGroup, invoker, IAppConstants.APP_NAME + " main() thread"); |
| appThread.setContextClassLoader (appLoader); |
| |
| // --- [app start] ---- |
| |
| appThread.start (); |
| |
| try {appThread.join (); } catch (InterruptedException ignore) {} |
| appThread = null; |
| |
| joinNonDeamonThreads (appThreadGroup); |
| |
| // --- [app end] ---- |
| |
| if (log.atTRACE1 ()) |
| { |
| if (appLoader instanceof InstrClassLoader) ((InstrClassLoader) appLoader).debugDump (log.getWriter ()); |
| } |
| |
| final Throwable mainFailure = invoker.getFailure (); |
| invoker = null; |
| |
| if (mainFailure != null) |
| { |
| if (mainFailure instanceof InvocationTargetException) |
| { |
| final Throwable cause = ((InvocationTargetException) mainFailure).getTargetException (); |
| |
| throw new EMMARuntimeException (MAIN_METHOD_FAILURE, new String [] {m_appClassName, cause.toString ()}, cause); |
| } |
| else if (mainFailure instanceof ExceptionInInitializerError) |
| { |
| // this catch block is never entered if INIT_AT_LOAD_TIME is 'true' |
| final Throwable cause = ((ExceptionInInitializerError) mainFailure).getException (); |
| |
| throw new EMMARuntimeException (MAIN_METHOD_FAILURE, new String [] {m_appClassName, cause.toString ()}, cause); |
| } |
| else if ((mainFailure instanceof IllegalAccessException) || |
| (mainFailure instanceof IllegalArgumentException) || |
| (mainFailure instanceof NullPointerException)) |
| { |
| throw new EMMARuntimeException (MAIN_METHOD_NOT_FOUND, new String [] {m_appClassName}, mainFailure); |
| } |
| else |
| { |
| throw new EMMARuntimeException (MAIN_METHOD_FAILURE, new String [] {m_appClassName, mainFailure.toString ()}, mainFailure); |
| } |
| } |
| } |
| catch (SecurityException se) |
| { |
| throw new EMMARuntimeException (SECURITY_RESTRICTION, new String [] {IAppConstants.APP_NAME}, se); |
| } |
| finally |
| { |
| if (SET_CURRENT_CONTEXT_LOADER && contextLoaderSet) |
| { |
| try |
| { |
| Thread.currentThread ().setContextClassLoader (contextLoader); |
| } |
| catch (Throwable ignore) {} |
| } |
| |
| if ((appThreadGroup != null) && ! appThreadGroup.isDestroyed ()) |
| try |
| { |
| appThreadGroup.destroy (); |
| appThreadGroup = null; |
| } |
| catch (Throwable ignore) {} |
| } |
| } |
| catch (RuntimeException re) |
| { |
| failure = re; // should be EMMARuntimeException only if there are no errors above |
| } |
| finally |
| { |
| RT.reset (false, false); |
| } |
| |
| if ($assert.ENABLED) $assert.ASSERT (runnerExitHook != null, "reportExitHook = null"); |
| runnerExitHook.run (); // that this may be a noop (if the shutdown sequence got there first) |
| |
| // [assertion: the report exit hook is done] |
| |
| if (runnerExitHookManager != null) |
| { |
| runnerExitHookManager.removeExitHook (runnerExitHook); // Ok if this fails |
| runnerExitHookManager = null; |
| } |
| |
| // ---------------[ end of exit hook-protected section ]--------------- |
| |
| |
| final Throwable exitHookDataDumpFailure = runnerExitHook.getDataDumpFailure (); |
| final List /* Throwable */ exitHookReportFailures = runnerExitHook.getReportFailures (); |
| runnerExitHook = null; |
| |
| if (failure != null) // 'failure' takes precedence over any possible exit hook's problems |
| { |
| throw wrapFailure (failure); |
| } |
| else if ((exitHookDataDumpFailure != null) || (exitHookReportFailures != null)) |
| { |
| if (exitHookDataDumpFailure != null) |
| log.log (Logger.SEVERE, "exception while persisting raw session data:", exitHookDataDumpFailure); |
| |
| Throwable firstReportFailure = null; |
| if (exitHookReportFailures != null) |
| { |
| for (Iterator i = exitHookReportFailures.iterator (); i.hasNext (); ) |
| { |
| final Throwable reportFailure = (Throwable) i.next (); |
| if (firstReportFailure == null) firstReportFailure = reportFailure; |
| |
| log.log (Logger.SEVERE, "exception while creating a report:", reportFailure); |
| } |
| } |
| |
| if (exitHookDataDumpFailure != null) |
| throw wrapFailure (exitHookDataDumpFailure); |
| else if (firstReportFailure != null) // redundant check |
| throw wrapFailure (firstReportFailure); |
| } |
| |
| } |
| |
| // package: ............................................................... |
| |
| // private: ............................................................... |
| |
| |
| private static final class Invoker implements Runnable |
| { |
| Invoker (final Method method, final Object target, final Object [] args) |
| { |
| if (method == null) throw new IllegalArgumentException ("null input: method"); |
| if (args == null) throw new IllegalArgumentException ("null input: args"); |
| |
| m_method = method; |
| m_target = target; |
| m_args = args; |
| } |
| |
| public void run () |
| { |
| try |
| { |
| m_method.invoke (m_target, m_args); |
| } |
| catch (Throwable t) |
| { |
| m_failure = t; |
| } |
| } |
| |
| Throwable getFailure () |
| { |
| return m_failure; |
| } |
| |
| |
| private final Method m_method; |
| private final Object m_target; |
| private final Object [] m_args; |
| private Throwable m_failure; |
| |
| } // end of nested class |
| |
| |
| private static final class AppRunnerExitHook implements Runnable |
| { |
| public synchronized void run () |
| { |
| try |
| { |
| if (! m_done) |
| { |
| // grab data snapshots: |
| |
| final IMetaData mdataSnashot = m_mdata.shallowCopy (); |
| m_mdata = null; |
| final ICoverageData cdataSnapshot = m_cdata.shallowCopy (); |
| m_cdata = null; |
| |
| if (mdataSnashot.isEmpty ()) |
| { |
| m_log.warning ("no metadata collected at runtime [no reports generated]"); |
| |
| return; |
| } |
| |
| if (cdataSnapshot.isEmpty ()) |
| { |
| m_log.warning ("no coverage data collected at runtime [all reports will be empty]"); |
| } |
| |
| final ISessionData sdata = new SessionData (mdataSnashot, cdataSnapshot); |
| |
| // if requested, dump raw data before running report generators: |
| // [note that the raw dumps and reports will be consistent wrt |
| // the session data they represent] |
| |
| if (m_dumpRawData && (m_sdataOutFile != null)) |
| { |
| try |
| { |
| final boolean info = m_log.atINFO (); |
| |
| final long start = info ? System.currentTimeMillis () : 0; |
| { |
| DataFactory.persist (sdata, m_sdataOutFile, m_sdataOutMerge); |
| } |
| if (info) |
| { |
| final long end = System.currentTimeMillis (); |
| |
| m_log.info ("raw session data " + (m_sdataOutMerge ? "merged into" : "written to") + " [" + m_sdataOutFile.getAbsolutePath () + "] {in " + (end - start) + " ms}"); |
| } |
| } |
| catch (Throwable t) |
| { |
| m_dataDumpFailure = t; |
| } |
| } |
| |
| for (int g = 0; g < m_generators.length; ++ g) |
| { |
| final IReportGenerator generator = m_generators [g]; |
| |
| if (generator != null) |
| { |
| try |
| { |
| generator.process (mdataSnashot, cdataSnapshot, m_cache, m_properties); |
| } |
| catch (Throwable t) |
| { |
| if (m_reportFailures == null) m_reportFailures = new ArrayList (); |
| m_reportFailures.add (t); |
| |
| continue; |
| } |
| finally |
| { |
| try { generator.cleanup (); } catch (Throwable ignore) {} |
| m_generators [g] = null; |
| } |
| } |
| } |
| } |
| } |
| finally |
| { |
| m_generators = null; |
| m_mdata = null; |
| m_cdata = null; |
| m_properties = null; |
| m_cache = null; |
| |
| m_done = true; |
| } |
| } |
| |
| // note: because ExitHookManager is a lazily created static singleton the |
| // correct thing to do is to pass an explicit Logger into each exit hook runner |
| // instead of relying on thread inheritance: |
| |
| AppRunnerExitHook (final Logger log, |
| final boolean dumpRawData, final File sdataOutFile, final boolean sdataOutMerge, |
| final IMetaData mdata, final ICoverageData cdata, |
| final IReportGenerator [] generators, |
| final SourcePathCache cache, final IProperties properties) |
| { |
| if (log == null) throw new IllegalArgumentException ("null input: log"); |
| if ((generators == null) || (generators.length == 0)) throw new IllegalArgumentException ("null/empty input: generators"); |
| if (mdata == null) throw new IllegalArgumentException ("null input: mdata"); |
| if (cdata == null) throw new IllegalArgumentException ("null input: cdata"); |
| if (properties == null) throw new IllegalArgumentException ("null input: properties"); |
| |
| m_log = log; |
| |
| m_dumpRawData = dumpRawData; |
| m_sdataOutFile = sdataOutFile; |
| m_sdataOutMerge = sdataOutMerge; |
| |
| m_generators = (IReportGenerator []) generators.clone (); |
| m_mdata = mdata; |
| m_cdata = cdata; |
| m_cache = cache; |
| m_properties = properties; |
| } |
| |
| |
| synchronized Throwable getDataDumpFailure () |
| { |
| return m_dataDumpFailure; |
| } |
| |
| synchronized List /* Throwable */ getReportFailures () |
| { |
| return m_reportFailures; |
| } |
| |
| |
| private final Logger m_log; |
| private final boolean m_dumpRawData; |
| private final File m_sdataOutFile; |
| private final boolean m_sdataOutMerge; |
| |
| private IReportGenerator [] m_generators; |
| private IMetaData m_mdata; |
| private ICoverageData m_cdata; |
| private SourcePathCache m_cache; |
| private IProperties m_properties; |
| private boolean m_done; |
| private Throwable m_dataDumpFailure; |
| private List /* Throwable */ m_reportFailures; |
| |
| } // end of nested class |
| |
| |
| private AppRunner (final ClassLoader delegate) |
| { |
| m_delegate = delegate; |
| m_coveragePath = IConstants.EMPTY_FILE_ARRAY; |
| } |
| |
| |
| private static void joinNonDeamonThreads (final ThreadGroup group) |
| { |
| if (group == null) throw new IllegalArgumentException ("null input: group"); |
| |
| final List threads = new ArrayList (); |
| while (true) |
| { |
| threads.clear (); |
| |
| // note: group.activeCount() is only an estimate as more threads |
| // could get created while we are doing this [if 'aliveThreads' |
| // array is too short, the extra threads are silently ignored]: |
| |
| Thread [] aliveThreads; |
| final int aliveCount; |
| |
| // enumerate [recursively] all threads in 'group': |
| synchronized (group) |
| { |
| aliveThreads = new Thread [group.activeCount () << 1]; |
| aliveCount = group.enumerate (aliveThreads, true); |
| } |
| |
| for (int t = 0; t < aliveCount; t++) |
| { |
| if (! aliveThreads [t].isDaemon ()) |
| threads.add (aliveThreads [t]); |
| } |
| aliveThreads = null; |
| |
| if (threads.isEmpty ()) |
| break; // note: this logic does not work if daemon threads are spawning non-daemon ones |
| else |
| { |
| for (Iterator i = threads.iterator (); i.hasNext (); ) |
| { |
| try |
| { |
| ((Thread) i.next ()).join (); |
| } |
| catch (InterruptedException ignore) {} |
| } |
| } |
| } |
| } |
| |
| private static RuntimeException wrapFailure (final Throwable t) |
| { |
| if (Exceptions.unexpectedFailure (t, EXPECTED_FAILURES)) |
| return new EMMARuntimeException (UNEXPECTED_FAILURE, |
| new Object [] {t.toString (), IAppConstants.APP_BUG_REPORT_LINK}, |
| t); |
| else if (t instanceof RuntimeException) |
| return (RuntimeException) t; |
| else |
| return new EMMARuntimeException (t); |
| } |
| |
| |
| // caller-settable state [scoped to this runner instance]: |
| |
| private final ClassLoader m_delegate; |
| |
| private String m_appClassName; // required to be non-null for run() |
| private String [] m_appArgs; // required to be non-null for run() |
| |
| private File [] m_coveragePath; // required to be non-null/non-empty for run() |
| private boolean m_canonical; |
| private boolean m_scanCoveragePath; |
| private IInclExclFilter m_coverageFilter; // can be null for run() |
| |
| private boolean m_dumpSessionData; |
| private File m_sdataOutFile; // user override; can be null for run() |
| private Boolean m_sdataOutMerge; // user override; can be null for run() |
| |
| private IReportGenerator [] m_reportGenerators; // required to be non-null for run() |
| private File [] m_sourcePath; // can be null/empty for run() |
| |
| // it is attractive to detect errors at load time, but this may allow |
| // threads created by <clinit> code to escape; on the other hand, classes |
| // that do not override main() will not get initialized this way and will |
| // not register with our runtime [which seems a minor problem at this point]: |
| private static final boolean INIT_AT_LOAD_TIME = false; |
| |
| // setting the context loader on AppRunner's thread should not |
| // be necessary since the app is run in a dedicated thread group; |
| // however, if INIT_AT_LOAD_TIME=true the app's <clinit> code |
| // should run with an adjusted context loader: |
| private static final boolean SET_CURRENT_CONTEXT_LOADER = INIT_AT_LOAD_TIME; |
| |
| // a soft cache is ideal for managing class definitions that are read during |
| // the initial classpath scan; however, the default LRU policy parameters for |
| // clearing SoftReferences in Sun's J2SDK 1.3+ render them next to useless |
| // in the client HotSpot JVM (in which this tool will probably run most often); |
| // using a hard cache guarantees 100% cache hit rate but can also raise the |
| // memory requirements significantly beyond the needs of the original app. |
| // [see bug refs 4471453, 4806720, 4888056, 4239645] |
| // |
| // resolution for now: use a soft cache anyway and doc that to make it useful |
| // for non-trivial apps the user should use -Xms or -XX:SoftRefLRUPolicyMSPerMB |
| // JVM options or use a server HotSpot JVM |
| private static final boolean USE_SOFT_CACHE = true; |
| |
| private static final int INIT_CACHE_CAPACITY = 2003; // prime |
| private static final int SOFT_CACHE_READ_CHK_FREQUENCY = 100; |
| private static final int SOFT_CACHE_WRITE_CHK_FREQUENCY = 100; |
| |
| private static final String [] FORCED_DELEGATION_FILTER_SPECS; // set in <clinit> |
| private static final Class [] MAIN_TYPE = new Class [] {String [].class}; |
| |
| private static final Class [] EXPECTED_FAILURES; // set in <clinit> |
| |
| protected static final String COMMA_DELIMITERS = "," + Strings.WHITE_SPACE; |
| protected static final String PATH_DELIMITERS = ",".concat (File.pathSeparator); |
| |
| static |
| { |
| EXPECTED_FAILURES = new Class [] |
| { |
| EMMARuntimeException.class, |
| IllegalArgumentException.class, |
| IllegalStateException.class, |
| }; |
| |
| FORCED_DELEGATION_FILTER_SPECS = new String [] {"+" + IAppConstants.APP_PACKAGE + ".*"}; |
| } |
| |
| } // end of class |
| // ---------------------------------------------------------------------------- |
