0001: /*
0002: * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright
0003: * notice. All rights reserved.
0004: */
0005: package com.tc.object.tools;
0006:
0007: import org.apache.commons.cli.CommandLine;
0008: import org.apache.commons.cli.HelpFormatter;
0009: import org.apache.commons.cli.Option;
0010: import org.apache.commons.cli.Options;
0011: import org.apache.commons.cli.ParseException;
0012: import org.apache.commons.cli.PosixParser;
0013:
0014: import com.tc.asm.ClassReader;
0015: import com.tc.asm.ClassVisitor;
0016: import com.tc.asm.ClassWriter;
0017: import com.tc.asm.MethodVisitor;
0018: import com.tc.asm.commons.SerialVersionUIDAdder;
0019: import com.tc.asm.tree.ClassNode;
0020: import com.tc.asm.tree.InnerClassNode;
0021: import com.tc.asm.tree.MethodNode;
0022: import com.tc.aspectwerkz.reflect.ClassInfo;
0023: import com.tc.aspectwerkz.reflect.impl.asm.AsmClassInfo;
0024: import com.tc.aspectwerkz.reflect.impl.java.JavaClassInfo;
0025: import com.tc.cluster.ClusterEventListener;
0026: import com.tc.config.Directories;
0027: import com.tc.config.schema.setup.FatalIllegalConfigurationChangeHandler;
0028: import com.tc.config.schema.setup.L1TVSConfigurationSetupManager;
0029: import com.tc.config.schema.setup.StandardTVSConfigurationSetupManagerFactory;
0030: import com.tc.exception.ExceptionWrapper;
0031: import com.tc.exception.ExceptionWrapperImpl;
0032: import com.tc.exception.TCNotSupportedMethodException;
0033: import com.tc.exception.TCObjectNotSharableException;
0034: import com.tc.exception.TCRuntimeException;
0035: import com.tc.geronimo.GeronimoLoaderNaming;
0036: import com.tc.hibernate.HibernateProxyInstance;
0037: import com.tc.ibatis.IBatisAccessPlanInstance;
0038: import com.tc.jboss.JBossLoaderNaming;
0039: import com.tc.jetty.JettyLoaderNaming;
0040: import com.tc.logging.CustomerLogging;
0041: import com.tc.logging.NullTCLogger;
0042: import com.tc.logging.TCLogger;
0043: import com.tc.management.TerracottaMBean;
0044: import com.tc.management.beans.sessions.SessionMonitorMBean;
0045: import com.tc.net.NIOWorkarounds;
0046: import com.tc.object.ObjectID;
0047: import com.tc.object.Portability;
0048: import com.tc.object.PortabilityImpl;
0049: import com.tc.object.SerializationUtil;
0050: import com.tc.object.TCClass;
0051: import com.tc.object.TCObject;
0052: import com.tc.object.bytecode.AbstractStringBuilderAdapter;
0053: import com.tc.object.bytecode.AccessibleObjectAdapter;
0054: import com.tc.object.bytecode.ArrayListAdapter;
0055: import com.tc.object.bytecode.AtomicIntegerAdapter;
0056: import com.tc.object.bytecode.AtomicLongAdapter;
0057: import com.tc.object.bytecode.BufferedWriterAdapter;
0058: import com.tc.object.bytecode.ByteCodeUtil;
0059: import com.tc.object.bytecode.ChangeClassNameHierarchyAdapter;
0060: import com.tc.object.bytecode.ChangeClassNameRootAdapter;
0061: import com.tc.object.bytecode.ClassAdapterFactory;
0062: import com.tc.object.bytecode.Clearable;
0063: import com.tc.object.bytecode.DataOutputStreamAdapter;
0064: import com.tc.object.bytecode.DuplicateMethodAdapter;
0065: import com.tc.object.bytecode.HashtableClassAdapter;
0066: import com.tc.object.bytecode.JavaLangReflectArrayAdapter;
0067: import com.tc.object.bytecode.JavaLangReflectFieldAdapter;
0068: import com.tc.object.bytecode.JavaLangReflectProxyClassAdapter;
0069: import com.tc.object.bytecode.JavaLangStringAdapter;
0070: import com.tc.object.bytecode.JavaLangThrowableDebugClassAdapter;
0071: import com.tc.object.bytecode.JavaNetURLAdapter;
0072: import com.tc.object.bytecode.JavaUtilConcurrentCyclicBarrierDebugClassAdapter;
0073: import com.tc.object.bytecode.JavaUtilConcurrentHashMapAdapter;
0074: import com.tc.object.bytecode.JavaUtilConcurrentHashMapEntryIteratorAdapter;
0075: import com.tc.object.bytecode.JavaUtilConcurrentHashMapHashEntryAdapter;
0076: import com.tc.object.bytecode.JavaUtilConcurrentHashMapSegmentAdapter;
0077: import com.tc.object.bytecode.JavaUtilConcurrentHashMapValueIteratorAdapter;
0078: import com.tc.object.bytecode.JavaUtilConcurrentHashMapWriteThroughEntryAdapter;
0079: import com.tc.object.bytecode.JavaUtilConcurrentLinkedBlockingQueueAdapter;
0080: import com.tc.object.bytecode.JavaUtilConcurrentLinkedBlockingQueueClassAdapter;
0081: import com.tc.object.bytecode.JavaUtilConcurrentLinkedBlockingQueueIteratorClassAdapter;
0082: import com.tc.object.bytecode.JavaUtilConcurrentLinkedBlockingQueueNodeClassAdapter;
0083: import com.tc.object.bytecode.JavaUtilTreeMapAdapter;
0084: import com.tc.object.bytecode.JavaUtilWeakHashMapAdapter;
0085: import com.tc.object.bytecode.LinkedHashMapClassAdapter;
0086: import com.tc.object.bytecode.LinkedListAdapter;
0087: import com.tc.object.bytecode.LogManagerAdapter;
0088: import com.tc.object.bytecode.LogicalClassSerializationAdapter;
0089: import com.tc.object.bytecode.Manageable;
0090: import com.tc.object.bytecode.Manager;
0091: import com.tc.object.bytecode.ManagerUtil;
0092: import com.tc.object.bytecode.MergeTCToJavaClassAdapter;
0093: import com.tc.object.bytecode.NullManager;
0094: import com.tc.object.bytecode.NullTCObject;
0095: import com.tc.object.bytecode.ReentrantLockClassAdapter;
0096: import com.tc.object.bytecode.ReentrantReadWriteLockClassAdapter;
0097: import com.tc.object.bytecode.SetRemoveMethodAdapter;
0098: import com.tc.object.bytecode.StringBufferAdapter;
0099: import com.tc.object.bytecode.StringGetCharsAdapter;
0100: import com.tc.object.bytecode.TCMap;
0101: import com.tc.object.bytecode.TCMapEntry;
0102: import com.tc.object.bytecode.TransparencyClassAdapter;
0103: import com.tc.object.bytecode.TransparentAccess;
0104: import com.tc.object.bytecode.VectorAdapter;
0105: import com.tc.object.bytecode.hook.ClassLoaderPreProcessorImpl;
0106: import com.tc.object.bytecode.hook.ClassPostProcessor;
0107: import com.tc.object.bytecode.hook.ClassPreProcessor;
0108: import com.tc.object.bytecode.hook.ClassProcessor;
0109: import com.tc.object.bytecode.hook.DSOContext;
0110: import com.tc.object.bytecode.hook.impl.ClassProcessorHelper;
0111: import com.tc.object.bytecode.hook.impl.ClassProcessorHelperJDK15;
0112: import com.tc.object.bytecode.hook.impl.JavaLangArrayHelpers;
0113: import com.tc.object.bytecode.hook.impl.SessionsHelper;
0114: import com.tc.object.bytecode.hook.impl.Util;
0115: import com.tc.object.cache.Cacheable;
0116: import com.tc.object.config.DSOClientConfigHelper;
0117: import com.tc.object.config.DSOSpringConfigHelper;
0118: import com.tc.object.config.StandardDSOClientConfigHelperImpl;
0119: import com.tc.object.config.TransparencyClassSpec;
0120: import com.tc.object.dna.impl.ProxyInstance;
0121: import com.tc.object.field.TCField;
0122: import com.tc.object.ibm.SystemInitializationAdapter;
0123: import com.tc.object.loaders.BytecodeProvider;
0124: import com.tc.object.loaders.ClassProvider;
0125: import com.tc.object.loaders.NamedClassLoader;
0126: import com.tc.object.loaders.NamedLoaderAdapter;
0127: import com.tc.object.loaders.Namespace;
0128: import com.tc.object.loaders.StandardClassLoaderAdapter;
0129: import com.tc.object.loaders.StandardClassProvider;
0130: import com.tc.object.logging.InstrumentationLogger;
0131: import com.tc.object.logging.InstrumentationLoggerImpl;
0132: import com.tc.object.util.OverrideCheck;
0133: import com.tc.plugins.ModulesLoader;
0134: import com.tc.properties.TCProperties;
0135: import com.tc.session.SessionSupport;
0136: import com.tc.text.Banner;
0137: import com.tc.tomcat.TomcatLoaderNaming;
0138: import com.tc.util.AbstractIdentifier;
0139: import com.tc.util.Assert;
0140: import com.tc.util.DebugUtil;
0141: import com.tc.util.EnumerationWrapper;
0142: import com.tc.util.FieldUtils;
0143: import com.tc.util.HashtableKeySetWrapper;
0144: import com.tc.util.HashtableValuesWrapper;
0145: import com.tc.util.ListIteratorWrapper;
0146: import com.tc.util.ReflectiveProxy;
0147: import com.tc.util.SetIteratorWrapper;
0148: import com.tc.util.THashMapCollectionWrapper;
0149: import com.tc.util.UnsafeUtil;
0150: import com.tc.util.runtime.Os;
0151: import com.tc.util.runtime.UnknownJvmVersionException;
0152: import com.tc.util.runtime.UnknownRuntimeVersionException;
0153: import com.tc.util.runtime.Vm;
0154: import com.tc.util.runtime.VmVersion;
0155: import com.tc.websphere.WebsphereLoaderNaming;
0156: import com.tcclient.util.HashtableEntrySetWrapper;
0157: import com.tcclient.util.MapEntrySetWrapper;
0158:
0159: import gnu.trove.TLinkable;
0160:
0161: import java.io.BufferedWriter;
0162: import java.io.ByteArrayOutputStream;
0163: import java.io.DataOutputStream;
0164: import java.io.File;
0165: import java.io.FileNotFoundException;
0166: import java.io.IOException;
0167: import java.io.InputStream;
0168: import java.io.PrintWriter;
0169: import java.io.StringWriter;
0170: import java.lang.reflect.AccessibleObject;
0171: import java.util.Collections;
0172: import java.util.HashMap;
0173: import java.util.HashSet;
0174: import java.util.Iterator;
0175: import java.util.List;
0176: import java.util.Map;
0177: import java.util.Set;
0178:
0179: /**
0180: * Tool for creating the DSO boot jar
0181: */
0182: public class BootJarTool {
0183: public static final String TC_DEBUG_THROWABLE_CONSTRUCTION = "tc.debug.throwable.construction";
0184:
0185: private static final String EXCESS_CLASSES = "excess";
0186: private static final String MISSING_CLASSES = "missing";
0187:
0188: private final static String TARGET_FILE_OPTION = "o";
0189: private final static boolean WRITE_OUT_TEMP_FILE = true;
0190:
0191: private static final String DEFAULT_CONFIG_SPEC = "tc-config.xml";
0192:
0193: private final ClassLoader tcLoader;
0194: private final ClassLoader systemLoader;
0195: private final DSOClientConfigHelper config;
0196: private final File outputFile;
0197: private final Portability portability;
0198:
0199: // various sets that are populated while massaging user defined boot jar specs
0200: private final Set notBootstrapClasses = new HashSet();
0201: private final Set notAdaptableClasses = new HashSet();
0202: private final Set logicalSubclasses = new HashSet();
0203: private final Set autoIncludedBootstrapClasses = new HashSet();
0204: private final Set nonExistingClasses = new HashSet();
0205:
0206: private InstrumentationLogger instrumentationLogger;
0207: private BootJar bootJar;
0208: private BootJarHandler bootJarHandler;
0209: private boolean quiet;
0210:
0211: public BootJarTool(DSOClientConfigHelper configuration,
0212: File outputFile, ClassLoader systemProvider, boolean quiet) {
0213: this .config = configuration;
0214: this .outputFile = outputFile;
0215: this .systemLoader = systemProvider;
0216: this .tcLoader = getClass().getClassLoader();
0217: this .bootJarHandler = new BootJarHandler(WRITE_OUT_TEMP_FILE,
0218: this .outputFile);
0219: this .quiet = quiet;
0220: this .portability = new PortabilityImpl(this .config);
0221: ModulesLoader.initModules(this .config, null, true);
0222: }
0223:
0224: public BootJarTool(DSOClientConfigHelper configuration,
0225: File outputFile, ClassLoader systemProvider) {
0226: this (configuration, outputFile, systemProvider, false);
0227: }
0228:
0229: private final void addJdk15SpecificPreInstrumentedClasses() {
0230: if (Vm.isJDK15Compliant()) {
0231: TransparencyClassSpec spec = config
0232: .getOrCreateSpec("java.math.MathContext");
0233: spec.markPreInstrumented();
0234:
0235: addInstrumentedJavaUtilConcurrentLocks();
0236:
0237: addInstrumentedJavaUtilConcurrentLinkedBlockingQueue();
0238: addInstrumentedJavaUtilConcurrentHashMap();
0239: addInstrumentedJavaUtilConcurrentCyclicBarrier();
0240: addInstrumentedJavaUtilConcurrentFutureTask();
0241: }
0242: }
0243:
0244: /**
0245: * Scans the boot JAR file to determine if it is complete and contains only the user-classes that are specified in the
0246: * tc-config's <additional-boot-jar-classes/> section. Program execution halts if it fails these checks.
0247: */
0248: private final void scanJar(File bootJarFile) {
0249: if (!bootJarFile.exists()) {
0250: System.err
0251: .println("\nDSO boot JAR file not found: '"
0252: + bootJarFile
0253: + "'; you can specify the boot JAR file to scan using the -o or --bootjar-file option.");
0254: System.exit(1);
0255: }
0256:
0257: final String MESSAGE0 = "\nYour boot JAR file might be out of date or invalid.";
0258: final String MESSAGE1 = "\nThe following classes was declared in the <additional-boot-jar-classes/> section "
0259: + "of your tc-config file but is not a part of your boot JAR file:";
0260: final String MESSAGE2 = "\nThe following user-classes were found in the boot JAR but was not declared in the "
0261: + "<additional-boot-jar-classes/> section of your tc-config file:";
0262: final String MESSAGE3 = "\nUse the make-boot-jar tool to re-create your boot JAR.";
0263:
0264: try {
0265: final Map result = compareBootJarContentsToUserSpec(bootJarFile);
0266: final Set missing = (Set) result.get(MISSING_CLASSES);
0267: final Set excess = (Set) result.get(EXCESS_CLASSES);
0268:
0269: if (!missing.isEmpty() || !excess.isEmpty()) {
0270: System.err.println(MESSAGE0);
0271:
0272: if (!missing.isEmpty()) {
0273: System.err.println(MESSAGE1);
0274: for (Iterator i = missing.iterator(); i.hasNext();) {
0275: System.err.println("- " + i.next());
0276: }
0277: }
0278:
0279: if (!excess.isEmpty()) {
0280: System.err.println(MESSAGE2);
0281: for (Iterator i = missing.iterator(); i.hasNext();) {
0282: System.err.println("- " + i.next());
0283: }
0284: }
0285:
0286: System.err.println(MESSAGE3);
0287: System.exit(1);
0288: }
0289: } catch (InvalidBootJarMetaDataException e) {
0290: System.err.println(e.getMessage());
0291: System.err.println(MESSAGE3);
0292: System.exit(1);
0293: }
0294: }
0295:
0296: /**
0297: * Checks if the given bootJarFile is complete; meaning: - All the classes declared in the configurations
0298: * <additional-boot-jar-classes/> section is present in the boot jar. - And there are no user-classes present in the
0299: * boot jar that is not declared in the <additional-boot-jar-classes/> section
0300: *
0301: * @return <code>true</code> if the boot jar is complete.
0302: */
0303: private final boolean isBootJarComplete(File bootJarFile) {
0304: try {
0305: final Map result = compareBootJarContentsToUserSpec(bootJarFile);
0306: final Set missing = (Set) result.get(MISSING_CLASSES);
0307: final Set excess = (Set) result.get(EXCESS_CLASSES);
0308: return missing.isEmpty() && excess.isEmpty();
0309: } catch (Exception e) {
0310: return false;
0311: }
0312: }
0313:
0314: /**
0315: * Scans the boot JAR file for: - User-defined classes that are in the boot JAR but is not defined in the
0316: * <additional-boot-jar-classes/> section of the config - Class names declared in the config but are not in the boot
0317: * JAR
0318: *
0319: * @throws InvalidBootJarMetaDataException
0320: */
0321: private final Map compareBootJarContentsToUserSpec(File bootJarFile)
0322: throws InvalidBootJarMetaDataException {
0323: try {
0324: Map result = new HashMap();
0325: final Map internalSpecs = getTCSpecs();
0326: final Map userSpecs = massageSpecs(
0327: getUserDefinedSpecs(internalSpecs), false);
0328: final BootJar bootJarLocal = BootJar
0329: .getBootJarForReading(bootJarFile);
0330: final Set preInstrumented = bootJarLocal
0331: .getAllPreInstrumentedClasses();
0332: final Set missing = new HashSet();
0333: for (final Iterator i = userSpecs.keySet().iterator(); i
0334: .hasNext();) {
0335: final String cn = (String) i.next();
0336: if (!preInstrumented.contains(cn)) {
0337: missing.add(cn);
0338: }
0339: }
0340: result.put(MISSING_CLASSES, missing);
0341:
0342: final Set foreign = bootJarLocal.getAllForeignClasses();
0343: final Set excess = new HashSet();
0344: for (final Iterator i = foreign.iterator(); i.hasNext();) {
0345: final String cn = (String) i.next();
0346: if (!userSpecs.keySet().contains(cn)) {
0347: excess.add(cn);
0348: }
0349: }
0350: result.put(EXCESS_CLASSES, excess);
0351:
0352: return result;
0353: } catch (InvalidBootJarMetaDataException e) {
0354: throw e;
0355: } catch (BootJarException e) {
0356: throw new RuntimeException(e);
0357: } catch (IOException e) {
0358: throw new RuntimeException(e);
0359: }
0360: }
0361:
0362: /**
0363: * verify that all of the reference TC classes are in the bootjar
0364: */
0365: private final void verifyJar(File bootJarFile) {
0366: try {
0367: final BootJar bootJarLocal = BootJar
0368: .getBootJarForReading(bootJarFile);
0369: final Set bootJarClassNames = bootJarLocal.getAllClasses();
0370: Map offendingClasses = new HashMap();
0371: for (Iterator i = bootJarClassNames.iterator(); i.hasNext();) {
0372: final String className = (String) i.next();
0373: final byte[] bytes = bootJarLocal
0374: .getBytesForClass(className);
0375: ClassReader cr = new ClassReader(bytes);
0376: ClassVisitor cv = new BootJarClassDependencyVisitor(
0377: bootJarClassNames, offendingClasses);
0378: cr.accept(cv, ClassReader.SKIP_FRAMES);
0379: }
0380:
0381: String nl = System.getProperty("line.separator");
0382: StringBuffer message = new StringBuffer(
0383: nl
0384: + nl
0385: + "The following Terracotta classes needs to be included in the boot jar:"
0386: + nl + nl);
0387: for (Iterator i = offendingClasses.entrySet().iterator(); i
0388: .hasNext();) {
0389: Map.Entry entry = (Map.Entry) i.next();
0390: message.append(" - " + entry.getKey() + " ["
0391: + entry.getValue() + "]" + nl);
0392: }
0393:
0394: Assert.assertTrue(
0395: message/* .toString().replaceAll(nl+"$", "") */,
0396: offendingClasses.isEmpty());
0397: } catch (BootJarException e) {
0398: throw new RuntimeException(e);
0399: } catch (IOException e) {
0400: throw new RuntimeException(e);
0401: }
0402: }
0403:
0404: public final void generateJar() {
0405: instrumentationLogger = new InstrumentationLoggerImpl(config
0406: .getInstrumentationLoggingOptions());
0407: try {
0408: bootJarHandler.validateDirectoryExists();
0409: } catch (BootJarHandlerException e) {
0410: exit(e.getMessage(), e.getCause());
0411: }
0412:
0413: if (!quiet) {
0414: bootJarHandler.announceCreationStart();
0415: }
0416:
0417: try {
0418: bootJar = bootJarHandler.getBootJar();
0419:
0420: addInstrumentedHashMap();
0421: addInstrumentedHashtable();
0422: addInstrumentedJavaUtilCollection();
0423: addReflectionInstrumentation();
0424:
0425: addJdk15SpecificPreInstrumentedClasses();
0426:
0427: addInstrumentedWeakHashMap();
0428:
0429: loadTerracottaClass(DebugUtil.class.getName());
0430: loadTerracottaClass(SessionSupport.class.getName());
0431: loadTerracottaClass(TCMap.class.getName());
0432: if (Vm.isJDK15Compliant()) {
0433: loadTerracottaClass("com.tc.util.concurrent.locks.TCLock");
0434: }
0435: loadTerracottaClass(com.tc.util.Stack.class.getName());
0436: loadTerracottaClass(TCObjectNotSharableException.class
0437: .getName());
0438:
0439: loadTerracottaClass(THashMapCollectionWrapper.class
0440: .getName());
0441: loadTerracottaClass(THashMapCollectionWrapper.class
0442: .getName()
0443: + "$IteratorWrapper");
0444: loadTerracottaClass(ListIteratorWrapper.class.getName());
0445: loadTerracottaClass(MapEntrySetWrapper.class.getName());
0446: loadTerracottaClass(MapEntrySetWrapper.class.getName()
0447: + "$IteratorWrapper");
0448: loadTerracottaClass(HashtableEntrySetWrapper.class
0449: .getName());
0450: loadTerracottaClass(HashtableEntrySetWrapper.class
0451: .getName()
0452: + "$HashtableIteratorWrapper");
0453: loadTerracottaClass(HashtableKeySetWrapper.class.getName());
0454: loadTerracottaClass(HashtableKeySetWrapper.class.getName()
0455: + "$IteratorWrapper");
0456: loadTerracottaClass(HashtableValuesWrapper.class.getName());
0457: loadTerracottaClass(HashtableValuesWrapper.class.getName()
0458: + "$IteratorWrapper");
0459: loadTerracottaClass(SetIteratorWrapper.class.getName());
0460: loadTerracottaClass(EnumerationWrapper.class.getName());
0461: loadTerracottaClass(NamedClassLoader.class.getName());
0462: loadTerracottaClass(NamedLoaderAdapter.class.getName());
0463: loadTerracottaClass(TransparentAccess.class.getName());
0464: loadTerracottaClass(BytecodeProvider.class.getName());
0465: loadTerracottaClass(ByteCodeUtil.class.getName());
0466:
0467: loadTerracottaClass(Manageable.class.getName());
0468: loadTerracottaClass(Clearable.class.getName());
0469: loadTerracottaClass(Manager.class.getName());
0470: loadTerracottaClass(NullManager.class.getName());
0471: loadTerracottaClass(ManagerUtil.class.getName());
0472: loadTerracottaClass(ManagerUtil.class.getName()
0473: + "$GlobalManagerHolder");
0474: loadTerracottaClass(TCObject.class.getName());
0475: loadTerracottaClass(TCClass.class.getName());
0476: loadTerracottaClass(TCField.class.getName());
0477: loadTerracottaClass(NullTCObject.class.getName());
0478: loadTerracottaClass(Cacheable.class.getName());
0479: loadTerracottaClass(ObjectID.class.getName());
0480: loadTerracottaClass(AbstractIdentifier.class.getName());
0481: loadTerracottaClass(TLinkable.class.getName());
0482: loadTerracottaClass(SessionsHelper.class.getName());
0483: loadTerracottaClass(GeronimoLoaderNaming.class.getName());
0484: loadTerracottaClass(JBossLoaderNaming.class.getName());
0485: loadTerracottaClass(JettyLoaderNaming.class.getName());
0486: loadTerracottaClass(WebsphereLoaderNaming.class.getName());
0487: loadTerracottaClass(TomcatLoaderNaming.class.getName());
0488: loadTerracottaClass(TCLogger.class.getName());
0489: loadTerracottaClass(Banner.class.getName());
0490: loadTerracottaClass(StandardClassProvider.class.getName());
0491: loadTerracottaClass(StandardClassProvider.SystemLoaderHolder.class
0492: .getName());
0493: loadTerracottaClass(Namespace.class.getName());
0494: loadTerracottaClass(ClassProcessorHelper.class.getName());
0495: loadTerracottaClass(ClassProcessorHelperJDK15.class
0496: .getName());
0497: loadTerracottaClass(ClassProcessorHelper.State.class
0498: .getName());
0499: loadTerracottaClass(ClassProcessorHelper.JarFilter.class
0500: .getName());
0501: loadTerracottaClass(ClassProcessor.class.getName());
0502: loadTerracottaClass(ClassPreProcessor.class.getName());
0503: loadTerracottaClass(ClassPostProcessor.class.getName());
0504: loadTerracottaClass(DSOSpringConfigHelper.class.getName());
0505: loadTerracottaClass(DSOContext.class.getName());
0506: loadTerracottaClass(ClassProvider.class.getName());
0507: loadTerracottaClass(TCRuntimeException.class.getName());
0508: loadTerracottaClass(FieldUtils.class.getName());
0509: loadTerracottaClass(UnsafeUtil.class.getName());
0510: loadTerracottaClass(TCNotSupportedMethodException.class
0511: .getName());
0512: loadTerracottaClass(ExceptionWrapper.class.getName());
0513: loadTerracottaClass(ExceptionWrapperImpl.class.getName());
0514: loadTerracottaClass(Os.class.getName());
0515: loadTerracottaClass(Util.class.getName());
0516: loadTerracottaClass(NIOWorkarounds.class.getName());
0517: loadTerracottaClass(TCProperties.class.getName());
0518: loadTerracottaClass(ClusterEventListener.class.getName());
0519: loadTerracottaClass(OverrideCheck.class.getName());
0520:
0521: // These classes need to be specified as literal in order to prevent
0522: // the static block of IdentityWeakHashMap from executing during generating
0523: // the boot jar.
0524: loadTerracottaClass("com.tc.object.util.IdentityWeakHashMap");
0525: loadTerracottaClass("com.tc.object.util.IdentityWeakHashMap$TestKey");
0526: loadTerracottaClass("com.tc.object.bytecode.hook.impl.ArrayManager");
0527: loadTerracottaClass("com.tc.object.bytecode.NonDistributableObjectRegistry");
0528: loadTerracottaClass(ProxyInstance.class.getName());
0529: loadTerracottaClass(JavaLangArrayHelpers.class.getName());
0530:
0531: loadTerracottaClass(Vm.class.getName());
0532: loadTerracottaClass(VmVersion.class.getName());
0533:
0534: loadTerracottaClass(UnknownJvmVersionException.class
0535: .getName());
0536: loadTerracottaClass(UnknownRuntimeVersionException.class
0537: .getName());
0538:
0539: loadTerracottaClass(IBatisAccessPlanInstance.class
0540: .getName());
0541: loadTerracottaClass(HibernateProxyInstance.class.getName());
0542:
0543: loadTerracottaClass(ReflectiveProxy.class.getName());
0544: loadTerracottaClass(ReflectiveProxy.Handler.class.getName());
0545:
0546: addManagementClasses();
0547:
0548: addRuntimeClasses();
0549:
0550: addInstrumentedLogManager();
0551: addSunStandardLoaders();
0552: addInstrumentedAccessibleObject();
0553: addInstrumentedJavaLangThrowable();
0554: addInstrumentedJavaLangStringBuffer();
0555: addInstrumentedClassLoader();
0556: addInstrumentedJavaLangString();
0557: addInstrumentedJavaNetURL();
0558: addInstrumentedProxy();
0559: addTreeMap();
0560: addInstrumentedAtomicInteger();
0561: addInstrumentedAtomicLong();
0562:
0563: addIBMSpecific();
0564:
0565: Map internalSpecs = getTCSpecs();
0566: loadBootJarClasses(removeAlreadyLoaded(massageSpecs(
0567: internalSpecs, true)));
0568:
0569: Map userSpecs = massageSpecs(
0570: getUserDefinedSpecs(internalSpecs), false);
0571: issueWarningsAndErrors();
0572:
0573: // user defined specs should ALWAYS be after internal specs
0574: loadBootJarClasses(removeAlreadyLoaded(userSpecs), true);
0575:
0576: adaptClassIfNotAlreadyIncluded(BufferedWriter.class
0577: .getName(), BufferedWriterAdapter.class);
0578: adaptClassIfNotAlreadyIncluded(DataOutputStream.class
0579: .getName(), DataOutputStreamAdapter.class);
0580: } catch (Exception e) {
0581: exit(bootJarHandler.getCreationErrorMessage(), e);
0582: }
0583:
0584: try {
0585: bootJar.close();
0586: bootJarHandler.announceCreationEnd();
0587: } catch (IOException e) {
0588: exit(bootJarHandler.getCloseErrorMessage(), e);
0589: } catch (BootJarHandlerException e) {
0590: exit(e.getMessage(), e.getCause());
0591: }
0592:
0593: }
0594:
0595: private void addIBMSpecific() {
0596: if (Vm.isIBM()) {
0597: // Yes, the class name is misspelled
0598: adaptAndLoad("com.ibm.misc.SystemIntialization",
0599: new SystemInitializationAdapter());
0600: }
0601: }
0602:
0603: private void addReflectionInstrumentation() {
0604: if (this .config.reflectionEnabled()) {
0605: adaptAndLoad("java.lang.reflect.Field",
0606: new JavaLangReflectFieldAdapter());
0607: adaptAndLoad("java.lang.reflect.Array",
0608: new JavaLangReflectArrayAdapter());
0609: }
0610: }
0611:
0612: private void adaptAndLoad(String name, ClassAdapterFactory factory) {
0613: byte[] bytes = getSystemBytes(name);
0614:
0615: ClassReader cr = new ClassReader(bytes);
0616: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
0617:
0618: ClassVisitor cv = factory.create(cw, null);
0619: cr.accept(cv, ClassReader.SKIP_FRAMES);
0620:
0621: bytes = cw.toByteArray();
0622:
0623: bootJar.loadClassIntoJar(name, bytes, false);
0624: }
0625:
0626: private final void addManagementClasses() {
0627: loadTerracottaClass(SessionMonitorMBean.class.getName());
0628: loadTerracottaClass(SessionMonitorMBean.class.getName()
0629: + "$SessionsComptroller");
0630: loadTerracottaClass(TerracottaMBean.class.getName());
0631: }
0632:
0633: private final boolean shouldIncludeStringBufferAndFriends() {
0634: Map userSpecs = getUserDefinedSpecs(getTCSpecs());
0635: return userSpecs.containsKey("java.lang.StringBuffer")
0636: || userSpecs
0637: .containsKey("java.lang.AbstractStringBuilder")
0638: || userSpecs.containsKey("java.lang.StringBuilder");
0639:
0640: }
0641:
0642: private final void addRuntimeClasses() {
0643: loadTerracottaClass("com.tc.asm.AnnotationVisitor");
0644: loadTerracottaClass("com.tc.asm.AnnotationWriter");
0645: loadTerracottaClass("com.tc.asm.Attribute");
0646: loadTerracottaClass("com.tc.asm.ByteVector");
0647: loadTerracottaClass("com.tc.asm.ClassAdapter");
0648: loadTerracottaClass("com.tc.asm.ClassReader");
0649: loadTerracottaClass("com.tc.asm.ClassVisitor");
0650: loadTerracottaClass("com.tc.asm.ClassWriter");
0651: loadTerracottaClass("com.tc.asm.Edge");
0652: loadTerracottaClass("com.tc.asm.FieldVisitor");
0653: loadTerracottaClass("com.tc.asm.FieldWriter");
0654: loadTerracottaClass("com.tc.asm.Frame");
0655: loadTerracottaClass("com.tc.asm.Handler");
0656: loadTerracottaClass("com.tc.asm.Item");
0657: loadTerracottaClass("com.tc.asm.Label");
0658: loadTerracottaClass("com.tc.asm.MethodAdapter");
0659: loadTerracottaClass("com.tc.asm.MethodVisitor");
0660: loadTerracottaClass("com.tc.asm.MethodWriter");
0661: loadTerracottaClass("com.tc.asm.Opcodes");
0662: loadTerracottaClass("com.tc.asm.Type");
0663:
0664: loadTerracottaClass("com.tc.asm.signature.SignatureReader");
0665: loadTerracottaClass("com.tc.asm.signature.SignatureVisitor");
0666: loadTerracottaClass("com.tc.asm.signature.SignatureWriter");
0667:
0668: loadTerracottaClass("com.tc.asm.commons.EmptyVisitor");
0669: loadTerracottaClass("com.tc.asm.commons.SerialVersionUIDAdder");
0670: loadTerracottaClass("com.tc.asm.commons.SerialVersionUIDAdder$Item");
0671:
0672: // FIXME extract AW runtime classes
0673: loadTerracottaClass("com.tc.aspectwerkz.AspectContext");
0674: loadTerracottaClass("com.tc.aspectwerkz.DeploymentModel$PointcutControlledDeploymentModel");
0675: loadTerracottaClass("com.tc.aspectwerkz.DeploymentModel");
0676: loadTerracottaClass("com.tc.aspectwerkz.WeavedTestCase$WeaverTestRunner");
0677: loadTerracottaClass("com.tc.aspectwerkz.WeavedTestCase");
0678: loadTerracottaClass("com.tc.aspectwerkz.annotation.After");
0679: loadTerracottaClass("com.tc.aspectwerkz.annotation.AfterFinally");
0680: loadTerracottaClass("com.tc.aspectwerkz.annotation.AfterReturning");
0681: loadTerracottaClass("com.tc.aspectwerkz.annotation.AfterThrowing");
0682: loadTerracottaClass("com.tc.aspectwerkz.annotation.AnnotationConstants");
0683: loadTerracottaClass("com.tc.aspectwerkz.annotation.AnnotationInfo");
0684: loadTerracottaClass("com.tc.aspectwerkz.annotation.Around");
0685: loadTerracottaClass("com.tc.aspectwerkz.annotation.AsmAnnotations");
0686: loadTerracottaClass("com.tc.aspectwerkz.annotation.Aspect");
0687: loadTerracottaClass("com.tc.aspectwerkz.annotation.AspectAnnotationParser");
0688: loadTerracottaClass("com.tc.aspectwerkz.annotation.Before");
0689: loadTerracottaClass("com.tc.aspectwerkz.annotation.Expression");
0690: loadTerracottaClass("com.tc.aspectwerkz.annotation.Introduce");
0691: loadTerracottaClass("com.tc.aspectwerkz.annotation.Mixin");
0692: loadTerracottaClass("com.tc.aspectwerkz.annotation.MixinAnnotationParser");
0693: loadTerracottaClass("com.tc.aspectwerkz.aspect.AbstractAspectContainer");
0694: loadTerracottaClass("com.tc.aspectwerkz.aspect.AbstractMixinFactory");
0695: loadTerracottaClass("com.tc.aspectwerkz.aspect.AdviceInfo");
0696: loadTerracottaClass("com.tc.aspectwerkz.aspect.AdviceType");
0697: loadTerracottaClass("com.tc.aspectwerkz.aspect.Aspect");
0698: loadTerracottaClass("com.tc.aspectwerkz.aspect.AspectContainer");
0699: loadTerracottaClass("com.tc.aspectwerkz.aspect.DefaultAspectContainerStrategy");
0700: loadTerracottaClass("com.tc.aspectwerkz.aspect.DefaultMixinFactory");
0701: loadTerracottaClass("com.tc.aspectwerkz.aspect.MixinFactory");
0702: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.AbstractAspectFactoryCompiler");
0703: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.Artifact");
0704: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.AspectFactoryManager");
0705: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.LazyPerXFactoryCompiler$PerClassAspectFactoryCompiler");
0706: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.LazyPerXFactoryCompiler$PerThreadAspectFactoryCompiler");
0707: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.LazyPerXFactoryCompiler");
0708: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.PerCflowXAspectFactoryCompiler");
0709: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.PerJVMAspectFactoryCompiler");
0710: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.PerObjectFactoryCompiler$PerInstanceFactoryCompiler");
0711: loadTerracottaClass("com.tc.aspectwerkz.aspect.container.PerObjectFactoryCompiler");
0712: loadTerracottaClass("com.tc.aspectwerkz.aspect.management.Aspects");
0713: loadTerracottaClass("com.tc.aspectwerkz.aspect.management.HasInstanceLevelAspect");
0714: loadTerracottaClass("com.tc.aspectwerkz.aspect.management.Mixins");
0715: loadTerracottaClass("com.tc.aspectwerkz.aspect.management.NoAspectBoundException");
0716: loadTerracottaClass("com.tc.aspectwerkz.cflow.AbstractCflowSystemAspect$1");
0717: loadTerracottaClass("com.tc.aspectwerkz.cflow.AbstractCflowSystemAspect$Cflow_sample");
0718: loadTerracottaClass("com.tc.aspectwerkz.cflow.AbstractCflowSystemAspect");
0719: loadTerracottaClass("com.tc.aspectwerkz.cflow.CflowAspectExpressionVisitor");
0720: loadTerracottaClass("com.tc.aspectwerkz.cflow.CflowBinding");
0721: loadTerracottaClass("com.tc.aspectwerkz.cflow.CflowCompiler$CompiledCflowAspect");
0722: loadTerracottaClass("com.tc.aspectwerkz.cflow.CflowCompiler");
0723: loadTerracottaClass("com.tc.aspectwerkz.compiler.AspectWerkzC");
0724: loadTerracottaClass("com.tc.aspectwerkz.compiler.AspectWerkzCTask");
0725: loadTerracottaClass("com.tc.aspectwerkz.compiler.CompileException");
0726: loadTerracottaClass("com.tc.aspectwerkz.compiler.Utility");
0727: loadTerracottaClass("com.tc.aspectwerkz.compiler.VerifierClassLoader");
0728: loadTerracottaClass("com.tc.aspectwerkz.connectivity.Command");
0729: loadTerracottaClass("com.tc.aspectwerkz.connectivity.Invoker");
0730: loadTerracottaClass("com.tc.aspectwerkz.connectivity.RemoteProxy");
0731: loadTerracottaClass("com.tc.aspectwerkz.connectivity.RemoteProxyServer");
0732: loadTerracottaClass("com.tc.aspectwerkz.connectivity.RemoteProxyServerManager$1");
0733: loadTerracottaClass("com.tc.aspectwerkz.connectivity.RemoteProxyServerManager");
0734: loadTerracottaClass("com.tc.aspectwerkz.connectivity.RemoteProxyServerThread");
0735: loadTerracottaClass("com.tc.aspectwerkz.definition.AdviceDefinition");
0736: loadTerracottaClass("com.tc.aspectwerkz.definition.AspectDefinition");
0737: loadTerracottaClass("com.tc.aspectwerkz.definition.DefinitionParserHelper");
0738: loadTerracottaClass("com.tc.aspectwerkz.definition.DeploymentScope");
0739: loadTerracottaClass("com.tc.aspectwerkz.definition.DescriptorUtil");
0740: loadTerracottaClass("com.tc.aspectwerkz.definition.DocumentParser$PointcutInfo");
0741: loadTerracottaClass("com.tc.aspectwerkz.definition.DocumentParser");
0742: loadTerracottaClass("com.tc.aspectwerkz.definition.InterfaceIntroductionDefinition");
0743: loadTerracottaClass("com.tc.aspectwerkz.definition.MixinDefinition");
0744: loadTerracottaClass("com.tc.aspectwerkz.definition.Pointcut");
0745: loadTerracottaClass("com.tc.aspectwerkz.definition.PointcutDefinition");
0746: loadTerracottaClass("com.tc.aspectwerkz.definition.SystemDefinition");
0747: loadTerracottaClass("com.tc.aspectwerkz.definition.SystemDefinitionContainer");
0748: loadTerracottaClass("com.tc.aspectwerkz.definition.Virtual");
0749: loadTerracottaClass("com.tc.aspectwerkz.definition.XmlParser$1");
0750: loadTerracottaClass("com.tc.aspectwerkz.definition.XmlParser");
0751: loadTerracottaClass("com.tc.aspectwerkz.definition.aspectj5.Definition$ConcreteAspect");
0752: loadTerracottaClass("com.tc.aspectwerkz.definition.aspectj5.Definition$Pointcut");
0753: loadTerracottaClass("com.tc.aspectwerkz.definition.aspectj5.Definition");
0754: loadTerracottaClass("com.tc.aspectwerkz.definition.aspectj5.DocumentParser");
0755: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.AdviceDefinitionBuilder");
0756: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.AspectDefinitionBuilder");
0757: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.AspectModule");
0758: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.AspectModuleDeployer");
0759: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.DefinitionBuilder");
0760: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.MixinDefinitionBuilder");
0761: loadTerracottaClass("com.tc.aspectwerkz.definition.deployer.PointcutDefinitionBuilder");
0762: loadTerracottaClass("com.tc.aspectwerkz.env.EnvironmentDetector");
0763: loadTerracottaClass("com.tc.aspectwerkz.exception.DefinitionException");
0764: loadTerracottaClass("com.tc.aspectwerkz.exception.DefinitionNotFoundException");
0765: loadTerracottaClass("com.tc.aspectwerkz.exception.ExpressionException");
0766: loadTerracottaClass("com.tc.aspectwerkz.exception.WrappedRuntimeException");
0767: loadTerracottaClass("com.tc.aspectwerkz.expression.AdvisedClassFilterExpressionVisitor");
0768: loadTerracottaClass("com.tc.aspectwerkz.expression.ArgsIndexVisitor");
0769: loadTerracottaClass("com.tc.aspectwerkz.expression.DumpVisitor");
0770: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionContext");
0771: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionException");
0772: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionInfo");
0773: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionNamespace");
0774: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionValidateVisitor");
0775: loadTerracottaClass("com.tc.aspectwerkz.expression.ExpressionVisitor");
0776: loadTerracottaClass("com.tc.aspectwerkz.expression.PointcutType");
0777: loadTerracottaClass("com.tc.aspectwerkz.expression.SubtypePatternType");
0778: loadTerracottaClass("com.tc.aspectwerkz.expression.Undeterministic");
0779: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTAnd");
0780: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTArgParameter");
0781: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTArgs");
0782: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTAttribute");
0783: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTCall");
0784: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTCflow");
0785: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTCflowBelow");
0786: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTClassPattern");
0787: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTConstructorPattern");
0788: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTExecution");
0789: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTExpression");
0790: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTFieldPattern");
0791: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTGet");
0792: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTHandler");
0793: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTHasField");
0794: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTHasMethod");
0795: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTIf");
0796: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTMethodPattern");
0797: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTModifier");
0798: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTNot");
0799: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTOr");
0800: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTParameter");
0801: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTPointcutReference");
0802: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTRoot");
0803: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTSet");
0804: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTStaticInitialization");
0805: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTTarget");
0806: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTThis");
0807: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTWithin");
0808: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ASTWithinCode");
0809: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParser$JJCalls");
0810: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParser$LookaheadSuccess");
0811: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParser");
0812: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParserConstants");
0813: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParserTokenManager");
0814: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParserTreeConstants");
0815: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ExpressionParserVisitor");
0816: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.JJTExpressionParserState");
0817: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.Node");
0818: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.ParseException");
0819: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.SimpleCharStream");
0820: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.SimpleNode");
0821: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.Token");
0822: loadTerracottaClass("com.tc.aspectwerkz.expression.ast.TokenMgrError");
0823: loadTerracottaClass("com.tc.aspectwerkz.expression.regexp.NamePattern");
0824: loadTerracottaClass("com.tc.aspectwerkz.expression.regexp.Pattern");
0825: loadTerracottaClass("com.tc.aspectwerkz.expression.regexp.TypePattern");
0826: loadTerracottaClass("com.tc.aspectwerkz.hook.AbstractStarter");
0827: loadTerracottaClass("com.tc.aspectwerkz.hook.BootClasspathStarter");
0828: loadTerracottaClass("com.tc.aspectwerkz.hook.ClassLoaderPatcher");
0829: loadTerracottaClass("com.tc.aspectwerkz.hook.ClassLoaderPreProcessor");
0830: loadTerracottaClass("com.tc.aspectwerkz.hook.ClassPreProcessor");
0831: loadTerracottaClass("com.tc.aspectwerkz.hook.StreamRedirectThread");
0832: loadTerracottaClass("com.tc.aspectwerkz.hook.impl.ClassPreProcessorHelper");
0833: loadTerracottaClass("com.tc.aspectwerkz.hook.impl.StdoutPreProcessor");
0834: loadTerracottaClass("com.tc.aspectwerkz.hook.impl.WeavingClassLoader");
0835: loadTerracottaClass("com.tc.aspectwerkz.intercept.Advice");
0836: loadTerracottaClass("com.tc.aspectwerkz.intercept.Advisable");
0837: loadTerracottaClass("com.tc.aspectwerkz.intercept.AdvisableImpl");
0838: loadTerracottaClass("com.tc.aspectwerkz.intercept.AfterAdvice");
0839: loadTerracottaClass("com.tc.aspectwerkz.intercept.AfterReturningAdvice");
0840: loadTerracottaClass("com.tc.aspectwerkz.intercept.AfterThrowingAdvice");
0841: loadTerracottaClass("com.tc.aspectwerkz.intercept.AroundAdvice");
0842: loadTerracottaClass("com.tc.aspectwerkz.intercept.BeforeAdvice");
0843: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.CatchClauseRtti");
0844: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.CatchClauseSignature");
0845: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.CodeRtti");
0846: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.CodeSignature");
0847: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.ConstructorRtti");
0848: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.ConstructorSignature");
0849: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.EnclosingStaticJoinPoint");
0850: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.FieldRtti");
0851: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.FieldSignature");
0852: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.JoinPoint");
0853: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.MemberRtti");
0854: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.MemberSignature");
0855: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.MethodRtti");
0856: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.MethodSignature");
0857: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.Rtti");
0858: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.Signature");
0859: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.StaticJoinPoint");
0860: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.CatchClauseRttiImpl");
0861: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.CatchClauseSignatureImpl");
0862: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.ConstructorRttiImpl");
0863: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.ConstructorSignatureImpl");
0864: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.EnclosingStaticJoinPointImpl");
0865: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.FieldRttiImpl");
0866: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.FieldSignatureImpl");
0867: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.MethodRttiImpl");
0868: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.MethodSignatureImpl");
0869: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.MethodTuple");
0870: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.StaticInitializationRttiImpl");
0871: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.impl.StaticInitializerSignatureImpl");
0872: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.management.AdviceInfoContainer");
0873: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.management.JoinPointManager$CompiledJoinPoint");
0874: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.management.JoinPointManager");
0875: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.management.JoinPointType");
0876: loadTerracottaClass("com.tc.aspectwerkz.joinpoint.management.SignatureFactory");
0877: loadTerracottaClass("com.tc.aspectwerkz.perx.PerObjectAspect");
0878: loadTerracottaClass("com.tc.aspectwerkz.proxy.ClassBytecodeRepository");
0879: loadTerracottaClass("com.tc.aspectwerkz.proxy.Proxy");
0880: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyCompilerHelper$1");
0881: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyCompilerHelper");
0882: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyDelegationCompiler$ProxyCompilerClassVisitor");
0883: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyDelegationCompiler");
0884: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyDelegationStrategy$CompositeClassKey");
0885: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxyDelegationStrategy");
0886: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxySubclassingCompiler$ProxyCompilerClassVisitor");
0887: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxySubclassingCompiler");
0888: loadTerracottaClass("com.tc.aspectwerkz.proxy.ProxySubclassingStrategy");
0889: loadTerracottaClass("com.tc.aspectwerkz.proxy.Uuid");
0890: loadTerracottaClass("com.tc.aspectwerkz.reflect.CflowMetaData");
0891: loadTerracottaClass("com.tc.aspectwerkz.reflect.NullClassInfo");
0892: loadTerracottaClass("com.tc.aspectwerkz.reflect.ClassInfo");
0893: loadTerracottaClass("com.tc.aspectwerkz.reflect.ClassInfoHelper");
0894: loadTerracottaClass("com.tc.aspectwerkz.reflect.ClassInfoRepository");
0895: loadTerracottaClass("com.tc.aspectwerkz.reflect.ClassList");
0896: loadTerracottaClass("com.tc.aspectwerkz.reflect.ConstructorInfo");
0897: loadTerracottaClass("com.tc.aspectwerkz.reflect.FieldInfo");
0898: loadTerracottaClass("com.tc.aspectwerkz.reflect.MemberInfo");
0899: loadTerracottaClass("com.tc.aspectwerkz.reflect.MetaDataInspector");
0900: loadTerracottaClass("com.tc.aspectwerkz.reflect.MethodComparator");
0901: loadTerracottaClass("com.tc.aspectwerkz.reflect.MethodInfo");
0902: loadTerracottaClass("com.tc.aspectwerkz.reflect.ReflectHelper");
0903: loadTerracottaClass("com.tc.aspectwerkz.reflect.ReflectionInfo");
0904: loadTerracottaClass("com.tc.aspectwerkz.reflect.StaticInitializationInfo");
0905: loadTerracottaClass("com.tc.aspectwerkz.reflect.StaticInitializationInfoImpl");
0906: loadTerracottaClass("com.tc.aspectwerkz.reflect.TypeConverter");
0907: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmClassInfo$ClassInfoClassAdapter");
0908: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmClassInfo$MethodParameterNamesCodeAdapter");
0909: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmClassInfo");
0910: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmClassInfoRepository");
0911: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmConstructorInfo");
0912: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmFieldInfo");
0913: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmMemberInfo");
0914: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.AsmMethodInfo");
0915: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.FieldStruct");
0916: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.MemberStruct");
0917: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.asm.MethodStruct");
0918: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaClassInfo");
0919: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaClassInfoRepository");
0920: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaConstructorInfo");
0921: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaFieldInfo");
0922: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaMemberInfo");
0923: loadTerracottaClass("com.tc.aspectwerkz.reflect.impl.java.JavaMethodInfo");
0924: loadTerracottaClass("com.tc.aspectwerkz.transform.AspectWerkzPreProcessor$Output");
0925: loadTerracottaClass("com.tc.aspectwerkz.transform.AspectWerkzPreProcessor");
0926: loadTerracottaClass("com.tc.aspectwerkz.transform.ByteArray");
0927: loadTerracottaClass("com.tc.aspectwerkz.transform.ClassCacheTuple");
0928: loadTerracottaClass("com.tc.aspectwerkz.transform.InstrumentationContext");
0929: loadTerracottaClass("com.tc.aspectwerkz.transform.JoinPointCompiler");
0930: loadTerracottaClass("com.tc.aspectwerkz.transform.Properties");
0931: loadTerracottaClass("com.tc.aspectwerkz.transform.TransformationConstants");
0932: loadTerracottaClass("com.tc.aspectwerkz.transform.TransformationUtil");
0933: loadTerracottaClass("com.tc.aspectwerkz.transform.WeavingStrategy");
0934: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AdviceMethodInfo");
0935: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmCopyAdapter$CopyAnnotationAdapter");
0936: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmCopyAdapter$CopyMethodAnnotationElseNullAdapter");
0937: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmCopyAdapter");
0938: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmHelper$1");
0939: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmHelper$2");
0940: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmHelper");
0941: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmNullAdapter$NullAnnotationVisitor");
0942: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmNullAdapter$NullClassAdapter");
0943: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmNullAdapter$NullFieldAdapter");
0944: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmNullAdapter$NullMethodAdapter");
0945: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AsmNullAdapter");
0946: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AspectInfo");
0947: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.AspectModelManager");
0948: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.EmittedJoinPoint");
0949: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.ProxyWeavingStrategy");
0950: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.AbstractJoinPointCompiler");
0951: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.CompilationInfo$Model");
0952: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.CompilationInfo");
0953: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.CompilerHelper");
0954: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.CompilerInput");
0955: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.ConstructorCallJoinPointCompiler");
0956: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.ConstructorCallJoinPointRedefiner");
0957: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.ConstructorExecutionJoinPointCompiler");
0958: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.ConstructorExecutionJoinPointRedefiner");
0959: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.FieldGetJoinPointCompiler");
0960: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.FieldGetJoinPointRedefiner");
0961: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.FieldSetJoinPointCompiler");
0962: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.FieldSetJoinPointRedefiner");
0963: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.HandlerJoinPointCompiler");
0964: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.HandlerJoinPointRedefiner");
0965: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.MatchingJoinPointInfo");
0966: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.MethodCallJoinPointCompiler");
0967: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.MethodCallJoinPointRedefiner");
0968: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.MethodExecutionJoinPointCompiler");
0969: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.MethodExecutionJoinPointRedefiner");
0970: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.RuntimeCheckVisitor");
0971: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.compiler.StaticInitializationJoinPointCompiler");
0972: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.ChangeSet$Element");
0973: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.ChangeSet");
0974: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.Deployer");
0975: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.DeploymentHandle$DefinitionChangeElement");
0976: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.DeploymentHandle");
0977: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.Redefiner");
0978: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.RedefinerFactory$Type");
0979: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.deployer.RedefinerFactory");
0980: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.model.AopAllianceAspectModel");
0981: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.model.AspectWerkzAspectModel$CustomProceedMethodStruct");
0982: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.model.AspectWerkzAspectModel");
0983: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.model.SpringAspectModel");
0984: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.spi.AspectModel$AroundClosureClassInfo$Type");
0985: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.spi.AspectModel$AroundClosureClassInfo");
0986: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.spi.AspectModel");
0987: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddInterfaceVisitor");
0988: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddMixinMethodsVisitor$AppendToInitMethodCodeAdapter");
0989: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddMixinMethodsVisitor$MixinFieldInfo");
0990: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddMixinMethodsVisitor$PrependToClinitMethodCodeAdapter");
0991: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddMixinMethodsVisitor");
0992: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AddWrapperVisitor");
0993: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AfterObjectInitializationCodeAdapter");
0994: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AlreadyAddedMethodAdapter");
0995: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.AlreadyAddedMethodVisitor");
0996: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorBodyVisitor$DispatchCtorBodyCodeAdapter");
0997: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorBodyVisitor");
0998: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorCallVisitor$LookaheadNewDupInvokeSpecialInstructionClassAdapter");
0999: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorCallVisitor$LookaheadNewDupInvokeSpecialInstructionCodeAdapter");
1000: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorCallVisitor$NewInvocationStruct");
1001: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorCallVisitor$ReplaceNewInstructionCodeAdapter");
1002: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.ConstructorCallVisitor");
1003: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.FieldSetFieldGetVisitor$ReplacePutFieldAndGetFieldInstructionCodeAdapter");
1004: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.FieldSetFieldGetVisitor");
1005: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.HandlerVisitor$CatchClauseCodeAdapter");
1006: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.HandlerVisitor$CatchLabelStruct");
1007: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.HandlerVisitor$LookaheadCatchLabelsClassAdapter");
1008: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.HandlerVisitor$LookaheadCatchLabelsMethodAdapter");
1009: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.HandlerVisitor");
1010: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.InstanceLevelAspectVisitor$AppendToInitMethodCodeAdapter");
1011: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.InstanceLevelAspectVisitor");
1012: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.JoinPointInitVisitor$InsertBeforeClinitCodeAdapter");
1013: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.JoinPointInitVisitor$InsertBeforeInitJoinPointsCodeAdapter");
1014: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.JoinPointInitVisitor");
1015: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.LabelToLineNumberVisitor$1");
1016: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.LabelToLineNumberVisitor");
1017: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.MethodCallVisitor$ReplaceInvokeInstructionCodeAdapter");
1018: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.MethodCallVisitor");
1019: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.MethodExecutionVisitor$1");
1020: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.MethodExecutionVisitor");
1021: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.SerialVersionUidVisitor$Add");
1022: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.SerialVersionUidVisitor$FieldItem");
1023: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.SerialVersionUidVisitor$Item");
1024: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.SerialVersionUidVisitor$MethodItem");
1025: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.SerialVersionUidVisitor");
1026: loadTerracottaClass("com.tc.aspectwerkz.transform.inlining.weaver.StaticInitializationVisitor");
1027: loadTerracottaClass("com.tc.aspectwerkz.util.ContextClassLoader");
1028: loadTerracottaClass("com.tc.aspectwerkz.util.EnvironmentDetect");
1029: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap$1");
1030: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap$2");
1031: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap$3");
1032: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap$Entry");
1033: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap$OrderedIterator");
1034: loadTerracottaClass("com.tc.aspectwerkz.util.SequencedHashMap");
1035: loadTerracottaClass("com.tc.aspectwerkz.util.SerializableThreadLocal");
1036: loadTerracottaClass("com.tc.aspectwerkz.util.Strings");
1037: loadTerracottaClass("com.tc.aspectwerkz.util.Util");
1038: loadTerracottaClass("com.tc.aspectwerkz.util.UuidGenerator");
1039:
1040: loadTerracottaClass("com.tc.backport175.Annotation");
1041: loadTerracottaClass("com.tc.backport175.Annotations");
1042: loadTerracottaClass("com.tc.backport175.ReaderException");
1043:
1044: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationDefaults");
1045: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationDefaults$AnnotationDefaultsClassVisitor");
1046: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationDefaults$AnnotationDefaultsMethodVisitor");
1047: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationDefaults$DefaultAnnotationBuilderVisitor");
1048: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement");
1049: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$Annotation");
1050: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$Array");
1051: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$Enum");
1052: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$NamedValue");
1053: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$NestedAnnotationElement");
1054: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationElement$Type");
1055: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader");
1056: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$AnnotationBuilderVisitor");
1057: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$AnnotationRetrievingConstructorVisitor");
1058: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$AnnotationRetrievingFieldVisitor");
1059: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$AnnotationRetrievingMethodVisitor");
1060: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$AnnotationRetrievingVisitor");
1061: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$ClassKey");
1062: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$MemberKey");
1063: loadTerracottaClass("com.tc.backport175.bytecode.AnnotationReader$TraceAnnotationVisitor");
1064: loadTerracottaClass("com.tc.backport175.bytecode.DefaultBytecodeProvider");
1065: loadTerracottaClass("com.tc.backport175.bytecode.SignatureHelper");
1066:
1067: loadTerracottaClass("com.tc.backport175.bytecode.spi.BytecodeProvider");
1068:
1069: loadTerracottaClass("com.tc.backport175.proxy.JavaDocAnnotationInvocationHander");
1070: loadTerracottaClass("com.tc.backport175.proxy.ProxyFactory");
1071: loadTerracottaClass("com.tc.backport175.proxy.ResolveAnnotationException");
1072:
1073: // FIXME remove unused stuff and move to com.tc. namespace
1074: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$IChangedListener");
1075: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$IState");
1076: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$IStateChangedListener");
1077: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$IStateVisitedListener");
1078: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$ITransitionVisitedListener");
1079: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$LinkedSet_State");
1080: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$State$Transition");
1081: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$State");
1082: loadTerracottaClass("com.tc.jrexx.automaton.Automaton$Wrapper_State");
1083: loadTerracottaClass("com.tc.jrexx.automaton.Automaton");
1084: loadTerracottaClass("com.tc.jrexx.automaton.IProperties");
1085: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$IPState");
1086: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$LinkedSet_PState");
1087: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$PProperties");
1088: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$PState");
1089: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat");
1090: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_GroupBegin");
1091: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_GroupEnd");
1092: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_LABEL");
1093: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_LITERAL");
1094: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_LITERALSET");
1095: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_RegExp");
1096: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern$TerminalFormat_REPETITION");
1097: loadTerracottaClass("com.tc.jrexx.regex.Automaton_Pattern");
1098: loadTerracottaClass("com.tc.jrexx.regex.InvalidExpression");
1099: loadTerracottaClass("com.tc.jrexx.regex.ParseException");
1100: loadTerracottaClass("com.tc.jrexx.regex.Pattern");
1101: loadTerracottaClass("com.tc.jrexx.regex.PatternPro");
1102: loadTerracottaClass("com.tc.jrexx.regex.PAutomaton$1");
1103: loadTerracottaClass("com.tc.jrexx.regex.PAutomaton$2");
1104: loadTerracottaClass("com.tc.jrexx.regex.PAutomaton");
1105: loadTerracottaClass("com.tc.jrexx.regex.PScanner");
1106: loadTerracottaClass("com.tc.jrexx.regex.Terminal_AndOp");
1107: loadTerracottaClass("com.tc.jrexx.regex.Terminal_EOF");
1108: loadTerracottaClass("com.tc.jrexx.regex.Terminal_GroupBegin");
1109: loadTerracottaClass("com.tc.jrexx.regex.Terminal_GroupEnd");
1110: loadTerracottaClass("com.tc.jrexx.regex.Terminal_NotOp");
1111: loadTerracottaClass("com.tc.jrexx.regex.Terminal_OrOp");
1112: loadTerracottaClass("com.tc.jrexx.regex.Terminal_RegExp");
1113: loadTerracottaClass("com.tc.jrexx.regex.Terminal_Repetition");
1114:
1115: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String");
1116: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$EClosureSet");
1117: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$Tupel");
1118: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$EClosure");
1119: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$Transition");
1120: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$ISState");
1121: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$ISStateChangedListener");
1122: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$LinkedSet_SState");
1123: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$SProperties");
1124: loadTerracottaClass("com.tc.jrexx.set.AutomatonSet_String$SState");
1125: loadTerracottaClass("com.tc.jrexx.set.CharSet");
1126: loadTerracottaClass("com.tc.jrexx.set.CharSet$IAbstract");
1127: loadTerracottaClass("com.tc.jrexx.set.CharSet$LongMap");
1128: loadTerracottaClass("com.tc.jrexx.set.CharSet$LongMapIterator");
1129: loadTerracottaClass("com.tc.jrexx.set.CharSet$Wrapper");
1130: loadTerracottaClass("com.tc.jrexx.set.DFASet");
1131: loadTerracottaClass("com.tc.jrexx.set.DFASet$State");
1132: loadTerracottaClass("com.tc.jrexx.set.DFASet$State$Transition");
1133: loadTerracottaClass("com.tc.jrexx.set.FSAData");
1134: loadTerracottaClass("com.tc.jrexx.set.FSAData$State");
1135: loadTerracottaClass("com.tc.jrexx.set.FSAData$State$Transition");
1136: loadTerracottaClass("com.tc.jrexx.set.ISet_char");
1137: loadTerracottaClass("com.tc.jrexx.set.ISet_char$Iterator");
1138: loadTerracottaClass("com.tc.jrexx.set.IState");
1139: loadTerracottaClass("com.tc.jrexx.set.IStatePro");
1140: loadTerracottaClass("com.tc.jrexx.set.IStatePro$IChangeListener");
1141: loadTerracottaClass("com.tc.jrexx.set.IStatePro$ITransition");
1142: loadTerracottaClass("com.tc.jrexx.set.IStatePro$IVisitListener");
1143:
1144: loadTerracottaClass("com.tc.jrexx.set.SAutomaton");
1145: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$IChangeListener");
1146: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$SAutomatonChangeListener");
1147: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$State");
1148: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$StatePro");
1149: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$StateProChangedListener");
1150: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$StateProVisitedListener");
1151: loadTerracottaClass("com.tc.jrexx.set.SAutomaton$Transition");
1152:
1153: loadTerracottaClass("com.tc.jrexx.set.SAutomatonData");
1154: loadTerracottaClass("com.tc.jrexx.set.SAutomatonData$State");
1155: loadTerracottaClass("com.tc.jrexx.set.SAutomatonData$State$Transition");
1156: loadTerracottaClass("com.tc.jrexx.set.StateProSet");
1157: loadTerracottaClass("com.tc.jrexx.set.StateProSet$Iterator");
1158: loadTerracottaClass("com.tc.jrexx.set.StateProSet$Wrapper_State");
1159: loadTerracottaClass("com.tc.jrexx.set.XML");
1160:
1161: loadTerracottaClass("com.tc.object.applicator.TCURL");
1162: loadTerracottaClass("com.tc.object.bytecode.TCMapEntry");
1163:
1164: // DEV-116; Some of these probably should'nt be in the boot jar
1165: loadTerracottaClass("com.tc.exception.ImplementMe");
1166: loadTerracottaClass("com.tc.exception.TCClassNotFoundException");
1167: loadTerracottaClass("com.tc.object.dna.api.DNAException");
1168: loadTerracottaClass("com.tc.util.Assert");
1169: loadTerracottaClass("com.tc.util.StringUtil");
1170: loadTerracottaClass("com.tc.util.TCAssertionError");
1171:
1172: // this class needed for ibm-jdk-15 branch
1173: loadTerracottaClass("com.tc.object.bytecode.ClassAdapterFactory");
1174: }
1175:
1176: private final void addTreeMap() {
1177: String className = "java.util.TreeMap";
1178: byte[] orig = getSystemBytes(className);
1179:
1180: TransparencyClassSpec spec = config.getSpec(className);
1181:
1182: byte[] transformed = doDSOTransform(className, orig);
1183:
1184: ClassReader cr = new ClassReader(transformed);
1185: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1186:
1187: ClassVisitor cv = new JavaUtilTreeMapAdapter(cw);
1188: cr.accept(cv, ClassReader.SKIP_FRAMES);
1189:
1190: bootJar.loadClassIntoJar(className, cw.toByteArray(), spec
1191: .isPreInstrumented());
1192: }
1193:
1194: private final void issueWarningsAndErrors() {
1195: issueErrors(nonExistingClasses, "could not be found",
1196: "remove or correct",
1197: "Attempt to add classes that cannot be found: ");
1198: issueErrors(
1199: notBootstrapClasses,
1200: "are not loaded by the bootstap classloader and have not been included in the boot jar",
1201: "remove",
1202: "Attempt to add classes that are not loaded by bootstrap classloader: ");
1203: issueErrors(
1204: notAdaptableClasses,
1205: "are non-adaptable types and have not been included in the boot jar",
1206: "remove", "Attempt to add non-adaptable classes: ");
1207: issueErrors(
1208: logicalSubclasses,
1209: "are subclasses of logically managed types and have not been included in the boot jar",
1210: "remove",
1211: "Attempt to add subclasses of logically manages classes: ");
1212: issueWarnings(
1213: autoIncludedBootstrapClasses,
1214: "were automatically included in the boot jar since they are required super classes",
1215: "add");
1216: }
1217:
1218: private final void issueErrors(Set classes, String desc,
1219: String verb, String shortDesc) {
1220: if (!classes.isEmpty()) {
1221: Banner
1222: .errorBanner("Boot jar creation failed. The following set of classes "
1223: + desc
1224: + ". Please "
1225: + verb
1226: + " them in the <additional-boot-jar-classes> section of the terracotta config: "
1227: + classes);
1228: exit(shortDesc + classes, null);
1229: }
1230: }
1231:
1232: private final void issueWarnings(Set classes, String desc,
1233: String verb) {
1234: if (!classes.isEmpty()) {
1235: Banner
1236: .warnBanner("The following set of classes "
1237: + desc
1238: + ". Please "
1239: + verb
1240: + " them in the <additional-boot-jar-classes> section of the terracotta config: "
1241: + classes);
1242: }
1243: }
1244:
1245: private final Map removeAlreadyLoaded(Map specs) {
1246: Map rv = new HashMap(specs);
1247: for (Iterator i = rv.keySet().iterator(); i.hasNext();) {
1248: String className = (String) i.next();
1249: if (bootJar.classLoaded(className)) {
1250: i.remove();
1251: }
1252: }
1253:
1254: return Collections.unmodifiableMap(rv);
1255: }
1256:
1257: private final Map massageSpecs(Map specs, boolean tcSpecs) {
1258: Map rv = new HashMap();
1259:
1260: for (Iterator i = specs.values().iterator(); i.hasNext();) {
1261: final TransparencyClassSpec spec = (TransparencyClassSpec) i
1262: .next();
1263:
1264: final Class topClass = getBootstrapClass(spec
1265: .getClassName());
1266: if (topClass == null) {
1267: if (tcSpecs && !spec.isHonorJDKSubVersionSpecific())
1268: throw new AssertionError("Class not found: "
1269: + spec.getClassName());
1270: if (!tcSpecs) {
1271: nonExistingClasses.add(spec.getClassName());
1272: }
1273: continue;
1274: } else if (topClass.getClassLoader() != null) {
1275: if (!tcSpecs) {
1276: notBootstrapClasses.add(topClass.getName());
1277: continue;
1278: }
1279: }
1280:
1281: Set super s = new HashSet();
1282: boolean add = true;
1283: if (!config.isLogical(topClass.getName())) {
1284: Class clazz = topClass;
1285: while ((clazz != null)
1286: && (!portability
1287: .isInstrumentationNotNeeded(clazz
1288: .getName()))) {
1289: if (config.isNeverAdaptable(JavaClassInfo
1290: .getClassInfo(clazz))) {
1291: if (tcSpecs) {
1292: throw new AssertionError("Not adaptable: "
1293: + clazz);
1294: }
1295:
1296: add = false;
1297: notAdaptableClasses.add(topClass.getName());
1298: break;
1299: }
1300:
1301: if ((clazz != topClass)
1302: && config.isLogical(clazz.getName())) {
1303: if (tcSpecs) {
1304: throw new AssertionError(topClass
1305: + " is subclass of logical type "
1306: + clazz.getName());
1307: }
1308:
1309: add = false;
1310: logicalSubclasses.add(topClass.getName());
1311: break;
1312: }
1313:
1314: if (!specs.containsKey(clazz.getName())
1315: && ((bootJar == null) || !bootJar
1316: .classLoaded(clazz.getName()))) {
1317: if (tcSpecs) {
1318: throw new AssertionError(
1319: "Missing super class "
1320: + clazz.getName()
1321: + " for type "
1322: + spec.getClassName());
1323: }
1324: super s.add(clazz.getName());
1325: }
1326:
1327: clazz = clazz.getSuperclass();
1328: }
1329: }
1330:
1331: if (add) {
1332: // include orignal class
1333: rv.put(topClass.getName(), spec);
1334:
1335: // include supers (if found)
1336: for (Iterator supes = super s.iterator(); supes
1337: .hasNext();) {
1338: String name = (String) supes.next();
1339: autoIncludedBootstrapClasses.add(name);
1340: TransparencyClassSpec super Spec = config
1341: .getOrCreateSpec(name);
1342: super Spec.markPreInstrumented();
1343: rv.put(name, super Spec);
1344: }
1345: }
1346: }
1347:
1348: return Collections.unmodifiableMap(rv);
1349: }
1350:
1351: private final static Class getBootstrapClass(String className) {
1352: try {
1353: return Class.forName(className, false, ClassLoader
1354: .getSystemClassLoader());
1355: } catch (ClassNotFoundException e) {
1356: return null;
1357: }
1358: }
1359:
1360: private final void loadBootJarClasses(Map specs,
1361: boolean foreignClass) {
1362: for (Iterator iter = specs.values().iterator(); iter.hasNext();) {
1363: TransparencyClassSpec spec = (TransparencyClassSpec) iter
1364: .next();
1365: byte[] classBytes = doDSOTransform(spec.getClassName(),
1366: getSystemBytes(spec.getClassName()));
1367: announce("Adapting: " + spec.getClassName());
1368: bootJar.loadClassIntoJar(spec.getClassName(), classBytes,
1369: spec.isPreInstrumented(), foreignClass);
1370: }
1371: }
1372:
1373: private final void loadBootJarClasses(Map specs) {
1374: loadBootJarClasses(specs, false);
1375: }
1376:
1377: private final Map getTCSpecs() {
1378: Map map = new HashMap();
1379:
1380: TransparencyClassSpec[] allSpecs = config.getAllSpecs();
1381: for (int i = 0; i < allSpecs.length; i++) {
1382: TransparencyClassSpec spec = allSpecs[i];
1383:
1384: if (!spec.isPreInstrumented()) {
1385: continue;
1386: }
1387: map.put(spec.getClassName(), spec);
1388: }
1389:
1390: return Collections.unmodifiableMap(map);
1391: }
1392:
1393: private final Map getUserDefinedSpecs(Map internalSpecs) {
1394: Map rv = new HashMap();
1395:
1396: for (Iterator i = config.getAllUserDefinedBootSpecs(); i
1397: .hasNext();) {
1398: TransparencyClassSpec spec = (TransparencyClassSpec) i
1399: .next();
1400: Assert.assertTrue(spec.isPreInstrumented());
1401:
1402: // Take out classes that don't need instrumentation (but the user included anyway)
1403: if (!portability.isInstrumentationNotNeeded(spec
1404: .getClassName())) {
1405: rv.put(spec.getClassName(), spec);
1406: }
1407: }
1408:
1409: // substract TC specs from the user set (overlaps are bad)
1410: rv.keySet().removeAll(internalSpecs.keySet());
1411:
1412: return Collections.unmodifiableMap(rv);
1413: }
1414:
1415: private final void loadTerracottaClass(String className) {
1416: bootJar.loadClassIntoJar(className,
1417: getTerracottaBytes(className), false);
1418: }
1419:
1420: private final byte[] getTerracottaBytes(String className) {
1421: return getBytes(className, tcLoader);
1422: }
1423:
1424: private final byte[] getSystemBytes(String className) {
1425: return getBytes(className, systemLoader);
1426: }
1427:
1428: private final byte[] getBytes(String className, ClassLoader provider) {
1429: try {
1430: return getBytesForClass(className, provider);
1431: } catch (ClassNotFoundException e) {
1432: throw exit("Error sourcing bytes for class " + className, e);
1433: }
1434: }
1435:
1436: public final byte[] getBytesForClass(String className,
1437: ClassLoader loader) throws ClassNotFoundException {
1438: String resource = BootJar.classNameToFileName(className);
1439: InputStream is = loader.getResourceAsStream(resource);
1440: if (is == null) {
1441: throw new ClassNotFoundException(
1442: "No resource found for class: " + className);
1443: }
1444: final int size = 4096;
1445: byte[] buffer = new byte[size];
1446: ByteArrayOutputStream baos = new ByteArrayOutputStream(size);
1447:
1448: int read;
1449: try {
1450: while ((read = is.read(buffer, 0, size)) > 0) {
1451: baos.write(buffer, 0, read);
1452: }
1453: } catch (IOException ioe) {
1454: throw new ClassNotFoundException("Error reading bytes for "
1455: + resource, ioe);
1456: } finally {
1457: if (is != null) {
1458: try {
1459: is.close();
1460: } catch (IOException ioe) {
1461: // ignore
1462: }
1463: }
1464: }
1465:
1466: return baos.toByteArray();
1467: }
1468:
1469: private final RuntimeException exit(String msg, Throwable t) {
1470: if (!WRITE_OUT_TEMP_FILE) {
1471: bootJar.setCreationErrorOccurred(true);
1472: }
1473:
1474: if (bootJar != null) {
1475: try {
1476: bootJar.close();
1477: } catch (Exception e) {
1478: e.printStackTrace();
1479: }
1480: }
1481:
1482: StringWriter sw = new StringWriter();
1483: PrintWriter pw = new PrintWriter(sw);
1484:
1485: if (t != null) {
1486: t.printStackTrace(pw);
1487: }
1488:
1489: if (msg != null) {
1490: pw.println("\n*************** ERROR ***************\n* "
1491: + msg + "\n*************************************");
1492: }
1493:
1494: String output = sw.toString();
1495: if (output.length() == 0) {
1496: new Throwable("Unspecified error creating boot jar")
1497: .printStackTrace(pw);
1498: output = sw.toString();
1499: }
1500:
1501: System.err.println(output);
1502: System.err.flush();
1503: System.exit(1);
1504:
1505: return new RuntimeException("VM Should have exited");
1506: }
1507:
1508: private final void addInstrumentedJavaLangStringBuffer() {
1509: boolean makePortable = shouldIncludeStringBufferAndFriends();
1510:
1511: if (makePortable) {
1512: addPortableStringBuffer();
1513: } else {
1514: addNonPortableStringBuffer();
1515: }
1516: }
1517:
1518: private void addInstrumentedAccessibleObject() {
1519: String classname = AccessibleObject.class.getName();
1520: byte[] bytes = getSystemBytes(classname);
1521:
1522: // instrument the state changing methods in AccessibleObject
1523: ClassReader cr = new ClassReader(bytes);
1524: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1525: ClassVisitor cv = new AccessibleObjectAdapter(cw);
1526: cr.accept(cv, ClassReader.SKIP_FRAMES);
1527: bytes = cw.toByteArray();
1528:
1529: // regular DSO instrumentation
1530: TransparencyClassSpec spec = config.getOrCreateSpec(classname);
1531: spec.markPreInstrumented();
1532:
1533: bootJar.loadClassIntoJar(spec.getClassName(), bytes, spec
1534: .isPreInstrumented());
1535: }
1536:
1537: private void addInstrumentedAtomicInteger() {
1538: if (!Vm.isJDK15Compliant()) {
1539: return;
1540: }
1541:
1542: String classname = "java.util.concurrent.atomic.AtomicInteger";
1543: byte[] bytes = getSystemBytes(classname);
1544:
1545: // instrument the state changing methods in AtomicInteger
1546: ClassReader cr = new ClassReader(bytes);
1547: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1548: ClassVisitor cv = new AtomicIntegerAdapter(cw);
1549: cr.accept(cv, ClassReader.SKIP_FRAMES);
1550: bytes = cw.toByteArray();
1551:
1552: // regular DSO instrumentation
1553: TransparencyClassSpec spec = config.getOrCreateSpec(classname);
1554: spec.markPreInstrumented();
1555:
1556: bootJar.loadClassIntoJar(spec.getClassName(), bytes, spec
1557: .isPreInstrumented());
1558: }
1559:
1560: private void addInstrumentedAtomicLong() {
1561: if (!Vm.isJDK15Compliant()) {
1562: return;
1563: }
1564:
1565: String classname = "java.util.concurrent.atomic.AtomicLong";
1566: byte[] bytes = getSystemBytes(classname);
1567:
1568: // instrument the state changing methods in AtomicLong
1569: ClassReader cr = new ClassReader(bytes);
1570: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1571: ClassVisitor cv = new AtomicLongAdapter(cw);
1572: cr.accept(cv, ClassReader.SKIP_FRAMES);
1573: bytes = cw.toByteArray();
1574:
1575: // regular DSO instrumentation
1576: TransparencyClassSpec spec = config.getOrCreateSpec(classname);
1577: spec.markPreInstrumented();
1578:
1579: bootJar.loadClassIntoJar(spec.getClassName(), bytes, spec
1580: .isPreInstrumented());
1581: }
1582:
1583: private final void addPortableStringBuffer() {
1584: boolean isJDK15 = Vm.isJDK15Compliant();
1585: if (isJDK15) {
1586: addAbstractStringBuilder();
1587: }
1588:
1589: byte[] bytes = getSystemBytes("java.lang.StringBuffer");
1590:
1591: // 1st pass
1592: ClassReader cr = new ClassReader(bytes);
1593: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1594: ClassVisitor cv = new StringBufferAdapter(cw, Vm.VERSION);
1595: cr.accept(cv, ClassReader.SKIP_FRAMES);
1596: bytes = cw.toByteArray();
1597:
1598: // 2nd pass
1599: cr = new ClassReader(bytes);
1600: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1601: cv = new DuplicateMethodAdapter(cw, Collections
1602: .singleton("getChars(II[CI)V"));
1603: cr.accept(cv, ClassReader.SKIP_FRAMES);
1604: bytes = cw.toByteArray();
1605:
1606: // 3rd pass (regular DSO instrumentation)
1607: TransparencyClassSpec spec = config
1608: .getOrCreateSpec("java.lang.StringBuffer");
1609: spec.markPreInstrumented();
1610: config.addWriteAutolock("* java.lang.StringBuffer.*(..)");
1611: bytes = doDSOTransform(spec.getClassName(), bytes);
1612:
1613: // 4th pass (String.getChars(..) calls)
1614: cr = new ClassReader(bytes);
1615: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1616: cv = new StringGetCharsAdapter(cw, new String[] { "^"
1617: + DuplicateMethodAdapter.UNMANAGED_PREFIX + ".*" });
1618: cr.accept(cv, ClassReader.SKIP_FRAMES);
1619: bytes = cw.toByteArray();
1620:
1621: // 5th pass (fixups)
1622: cr = new ClassReader(bytes);
1623: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1624: cv = new StringBufferAdapter.FixUp(cw, Vm.VERSION);
1625: cr.accept(cv, ClassReader.SKIP_FRAMES);
1626: bytes = cw.toByteArray();
1627:
1628: bootJar.loadClassIntoJar(spec.getClassName(), bytes, spec
1629: .isPreInstrumented());
1630: }
1631:
1632: private final void addNonPortableStringBuffer() {
1633: // even if we aren't making StringBu[ild|ff]er portable, we still need to make
1634: // sure it calls the fast getChars() methods on String
1635:
1636: boolean isJDK15 = Vm.isJDK15Compliant();
1637:
1638: if (isJDK15) {
1639: if (Vm.isIBM()) {
1640: addNonPortableStringBuffer("java.lang.StringBuilder");
1641: } else {
1642: addNonPortableStringBuffer("java.lang.AbstractStringBuilder");
1643: }
1644: }
1645:
1646: addNonPortableStringBuffer("java.lang.StringBuffer");
1647: }
1648:
1649: private void addNonPortableStringBuffer(String className) {
1650: TransparencyClassSpec spec = config.getOrCreateSpec(className);
1651: spec.markPreInstrumented();
1652:
1653: byte[] bytes = getSystemBytes(className);
1654:
1655: ClassReader cr = new ClassReader(bytes);
1656: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1657: ClassVisitor cv = new StringGetCharsAdapter(cw,
1658: new String[] { ".*" });
1659: cr.accept(cv, ClassReader.SKIP_FRAMES);
1660: bytes = cw.toByteArray();
1661:
1662: bootJar.loadClassIntoJar(className, bytes, spec
1663: .isPreInstrumented());
1664: }
1665:
1666: private final void addAbstractStringBuilder() {
1667: String className;
1668: if (Vm.isIBM()) {
1669: className = "java.lang.StringBuilder";
1670: } else {
1671: className = "java.lang.AbstractStringBuilder";
1672: }
1673:
1674: byte[] classBytes = getSystemBytes(className);
1675:
1676: ClassReader cr = new ClassReader(classBytes);
1677: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1678: ClassVisitor cv = new DuplicateMethodAdapter(cw, Collections
1679: .singleton("getChars(II[CI)V"));
1680: cr.accept(cv, ClassReader.SKIP_FRAMES);
1681: classBytes = cw.toByteArray();
1682:
1683: TransparencyClassSpec spec = config.getOrCreateSpec(className);
1684: spec.markPreInstrumented();
1685:
1686: classBytes = doDSOTransform(className, classBytes);
1687:
1688: cr = new ClassReader(classBytes);
1689: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1690: cv = new AbstractStringBuilderAdapter(cw, className);
1691: cr.accept(cv, ClassReader.SKIP_FRAMES);
1692:
1693: cr = new ClassReader(cw.toByteArray());
1694: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1695: cv = new StringGetCharsAdapter(cw, new String[] { "^"
1696: + DuplicateMethodAdapter.UNMANAGED_PREFIX + ".*" });
1697: cr.accept(cv, ClassReader.SKIP_FRAMES);
1698:
1699: bootJar.loadClassIntoJar(className, cw.toByteArray(), spec
1700: .isPreInstrumented());
1701: }
1702:
1703: private final void addInstrumentedProxy() {
1704: String className = "java.lang.reflect.Proxy";
1705: byte[] bytes = getSystemBytes(className);
1706:
1707: ClassReader cr = new ClassReader(bytes);
1708: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1709:
1710: ClassVisitor cv = new JavaLangReflectProxyClassAdapter(cw);
1711: cr.accept(cv, ClassReader.SKIP_FRAMES);
1712:
1713: bytes = cw.toByteArray();
1714:
1715: TransparencyClassSpec spec = config.getOrCreateSpec(className);
1716: bytes = doDSOTransform(spec.getClassName(), bytes);
1717: bootJar.loadClassIntoJar(className, bytes, true);
1718: }
1719:
1720: private final void addInstrumentedLogManager() {
1721: String className = "java.util.logging.LogManager";
1722: byte[] bytes = getSystemBytes(className);
1723:
1724: ClassReader cr = new ClassReader(bytes);
1725: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1726:
1727: ClassVisitor cv = new LogManagerAdapter(cw);
1728: cr.accept(cv, ClassReader.SKIP_FRAMES);
1729:
1730: bytes = cw.toByteArray();
1731:
1732: bootJar.loadClassIntoJar(className, bytes, false);
1733: }
1734:
1735: private final void addInstrumentedJavaLangString() {
1736: byte[] orig = getSystemBytes("java.lang.String");
1737:
1738: ClassReader cr = new ClassReader(orig);
1739: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1740:
1741: ClassVisitor cv = new JavaLangStringAdapter(cw, Vm.VERSION,
1742: shouldIncludeStringBufferAndFriends());
1743: cr.accept(cv, ClassReader.SKIP_FRAMES);
1744:
1745: bootJar.loadClassIntoJar("java.lang.String", cw.toByteArray(),
1746: false);
1747: }
1748:
1749: private final void addInstrumentedJavaNetURL() {
1750: String className = "java.net.URL";
1751: byte[] bytes = getSystemBytes(className);
1752:
1753: ClassReader cr = new ClassReader(bytes);
1754: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1755:
1756: ClassVisitor cv = new JavaNetURLAdapter(cw);
1757: cr.accept(cv, ClassReader.SKIP_FRAMES);
1758:
1759: TransparencyClassSpec spec = config.getOrCreateSpec(className,
1760: "com.tc.object.applicator.URLApplicator");
1761: spec.markPreInstrumented();
1762: spec.setHonorTransient(true);
1763: spec.addAlwaysLogSpec(SerializationUtil.URL_SET_SIGNATURE);
1764: // note that there's another set method, that is actually never referenced
1765: // from URLStreamHandler, so it's not accessible from classes that extend
1766: // URLStreamHandler, so I'm not supporting it here
1767:
1768: bytes = doDSOTransform(className, cw.toByteArray());
1769:
1770: bootJar.loadClassIntoJar(className, bytes, spec
1771: .isPreInstrumented());
1772: }
1773:
1774: private final void addSunStandardLoaders() {
1775: byte[] orig = getSystemBytes("sun.misc.Launcher$AppClassLoader");
1776: ClassReader cr = new ClassReader(orig);
1777: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1778: ClassVisitor cv = new StandardClassLoaderAdapter(cw, Namespace
1779: .getStandardSystemLoaderName());
1780: cr.accept(cv, ClassReader.SKIP_FRAMES);
1781: bootJar.loadClassIntoJar("sun.misc.Launcher$AppClassLoader", cw
1782: .toByteArray(), false);
1783:
1784: orig = getSystemBytes("sun.misc.Launcher$ExtClassLoader");
1785: cr = new ClassReader(orig);
1786: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1787: cv = new StandardClassLoaderAdapter(cw, Namespace
1788: .getStandardExtensionsLoaderName());
1789: cr.accept(cv, ClassReader.SKIP_FRAMES);
1790: bootJar.loadClassIntoJar("sun.misc.Launcher$ExtClassLoader", cw
1791: .toByteArray(), false);
1792: }
1793:
1794: private final void addInstrumentedJavaLangThrowable() {
1795: String className = "java.lang.Throwable";
1796: byte[] bytes = getSystemBytes(className);
1797:
1798: if (System.getProperty(TC_DEBUG_THROWABLE_CONSTRUCTION) != null) {
1799: ClassReader cr = new ClassReader(bytes);
1800: ClassWriter cw = new ClassWriter(cr,
1801: ClassWriter.COMPUTE_MAXS);
1802: ClassVisitor cv = new JavaLangThrowableDebugClassAdapter(cw);
1803: cr.accept(cv, ClassReader.SKIP_FRAMES);
1804: bytes = cw.toByteArray();
1805: }
1806:
1807: TransparencyClassSpec spec = config.getOrCreateSpec(className);
1808: spec.markPreInstrumented();
1809: spec.setHonorTransient(true);
1810:
1811: byte[] instrumented = doDSOTransform(className, bytes);
1812:
1813: bootJar.loadClassIntoJar(className, instrumented, spec
1814: .isPreInstrumented());
1815: }
1816:
1817: /**
1818: * This instrumentation is temporary to add debug statements to the CyclicBarrier class.
1819: */
1820: private final void addInstrumentedJavaUtilConcurrentCyclicBarrier() {
1821: if (!Vm.isJDK15Compliant()) {
1822: return;
1823: }
1824:
1825: byte[] bytes = getSystemBytes("java.util.concurrent.CyclicBarrier");
1826:
1827: ClassReader cr = new ClassReader(bytes);
1828: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1829: ClassVisitor cv = new JavaUtilConcurrentCyclicBarrierDebugClassAdapter(
1830: cw);
1831: cr.accept(cv, ClassReader.SKIP_FRAMES);
1832:
1833: bytes = cw.toByteArray();
1834:
1835: TransparencyClassSpec spec = config
1836: .getOrCreateSpec("java.util.concurrent.CyclicBarrier");
1837: bytes = doDSOTransform(spec.getClassName(), bytes);
1838: bootJar.loadClassIntoJar("java.util.concurrent.CyclicBarrier",
1839: bytes, true);
1840: }
1841:
1842: private final void addInstrumentedJavaUtilConcurrentHashMap() {
1843: if (!Vm.isJDK15Compliant()) {
1844: return;
1845: }
1846:
1847: loadTerracottaClass("com.tcclient.util.ConcurrentHashMapEntrySetWrapper");
1848: loadTerracottaClass("com.tcclient.util.ConcurrentHashMapEntrySetWrapper$IteratorWrapper");
1849:
1850: // java.util.concurrent.ConcurrentHashMap
1851: String jClassNameDots = "java.util.concurrent.ConcurrentHashMap";
1852: String tcClassNameDots = "java.util.concurrent.ConcurrentHashMapTC";
1853:
1854: byte[] tcData = getSystemBytes(tcClassNameDots);
1855: ClassReader tcCR = new ClassReader(tcData);
1856: ClassNode tcCN = new ClassNode();
1857: tcCR.accept(tcCN, ClassReader.SKIP_DEBUG
1858: | ClassReader.SKIP_FRAMES);
1859:
1860: byte[] jData = getSystemBytes(jClassNameDots);
1861: ClassReader jCR = new ClassReader(jData);
1862: ClassWriter cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
1863: ClassVisitor cv1 = new JavaUtilConcurrentHashMapAdapter(cw);
1864:
1865: jCR.accept(cv1, ClassReader.SKIP_DEBUG
1866: | ClassReader.SKIP_FRAMES);
1867: jData = cw.toByteArray();
1868:
1869: jCR = new ClassReader(jData);
1870: cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
1871:
1872: ClassInfo jClassInfo = AsmClassInfo.getClassInfo(
1873: jClassNameDots, systemLoader);
1874: TransparencyClassAdapter dsoAdapter = config
1875: .createDsoClassAdapterFor(cw, jClassInfo,
1876: instrumentationLogger, getClass()
1877: .getClassLoader(), true, true);
1878: Map instrumentedContext = new HashMap();
1879: ClassVisitor cv = new SerialVersionUIDAdder(
1880: new MergeTCToJavaClassAdapter(cw, dsoAdapter,
1881: jClassNameDots, tcClassNameDots, tcCN,
1882: instrumentedContext));
1883: jCR.accept(cv, ClassReader.SKIP_FRAMES);
1884: jData = cw.toByteArray();
1885: jData = doDSOTransform(jClassNameDots, jData);
1886: bootJar.loadClassIntoJar(jClassNameDots, jData, true);
1887:
1888: // java.util.concurrent.ConcurrentHashMap$HashEntry
1889: byte[] bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$HashEntry");
1890: ClassReader cr = new ClassReader(bytes);
1891: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1892: cv = new JavaUtilConcurrentHashMapHashEntryAdapter(cw);
1893: cr.accept(cv, ClassReader.SKIP_FRAMES);
1894:
1895: bytes = cw.toByteArray();
1896:
1897: TransparencyClassSpec spec = config
1898: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$HashEntry");
1899: spec.addDoNotInstrument(TCMapEntry.TC_RAWSETVALUE_METHOD_NAME);
1900: spec
1901: .addDoNotInstrument(TCMapEntry.TC_ISVALUEFAULTEDIN_METHOD_NAME);
1902: spec.setHonorTransient(true);
1903: spec.markPreInstrumented();
1904: spec.setCallConstructorOnLoad(true);
1905: bytes = doDSOTransform(spec.getClassName(), bytes);
1906: bootJar.loadClassIntoJar(
1907: "java.util.concurrent.ConcurrentHashMap$HashEntry",
1908: bytes, spec.isPreInstrumented());
1909:
1910: // java.util.concurrent.ConcurrentHashMap$Segment
1911: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$Segment");
1912: cr = new ClassReader(bytes);
1913: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1914: cv = new JavaUtilConcurrentHashMapSegmentAdapter(cw);
1915: cr.accept(cv, ClassReader.SKIP_FRAMES);
1916:
1917: bytes = cw.toByteArray();
1918:
1919: spec = config
1920: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$Segment");
1921: spec.setHonorTransient(true);
1922: spec.markPreInstrumented();
1923: spec.setCallConstructorOnLoad(true);
1924: bytes = doDSOTransform(spec.getClassName(), bytes);
1925: bootJar.loadClassIntoJar(
1926: "java.util.concurrent.ConcurrentHashMap$Segment",
1927: bytes, spec.isPreInstrumented());
1928:
1929: // java.util.concurrent.ConcurrentHashMap$ValueIterator
1930: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$ValueIterator");
1931: cr = new ClassReader(bytes);
1932: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1933: cv = new JavaUtilConcurrentHashMapValueIteratorAdapter(cw);
1934: cr.accept(cv, ClassReader.SKIP_FRAMES);
1935:
1936: bytes = cw.toByteArray();
1937:
1938: spec = config
1939: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$ValueIterator");
1940: spec.setHonorTransient(true);
1941: spec.markPreInstrumented();
1942: bytes = doDSOTransform(spec.getClassName(), bytes);
1943: bootJar.loadClassIntoJar(
1944: "java.util.concurrent.ConcurrentHashMap$ValueIterator",
1945: bytes, spec.isPreInstrumented());
1946:
1947: // java.util.concurrent.ConcurrentHashMap$EntryIterator
1948: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$EntryIterator");
1949: cr = new ClassReader(bytes);
1950: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1951: cv = new JavaUtilConcurrentHashMapEntryIteratorAdapter(cw);
1952: cr.accept(cv, ClassReader.SKIP_FRAMES);
1953:
1954: bytes = cw.toByteArray();
1955:
1956: spec = config
1957: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$EntryIterator");
1958: spec.setHonorTransient(true);
1959: spec.markPreInstrumented();
1960: bytes = doDSOTransform(spec.getClassName(), bytes);
1961: bootJar.loadClassIntoJar(
1962: "java.util.concurrent.ConcurrentHashMap$EntryIterator",
1963: bytes, spec.isPreInstrumented());
1964:
1965: if (Vm.isJDK16Compliant()) {
1966: // java.util.concurrent.ConcurrentHashMap$EntryIterator
1967: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$WriteThroughEntry");
1968: cr = new ClassReader(bytes);
1969: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
1970: cv = new JavaUtilConcurrentHashMapWriteThroughEntryAdapter(
1971: cw);
1972: cr.accept(cv, ClassReader.SKIP_FRAMES);
1973:
1974: bytes = cw.toByteArray();
1975:
1976: spec = config
1977: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$WriteThroughEntry");
1978: spec.setHonorTransient(true);
1979: spec.markPreInstrumented();
1980: bytes = doDSOTransform(spec.getClassName(), bytes);
1981: bootJar
1982: .loadClassIntoJar(
1983: "java.util.concurrent.ConcurrentHashMap$WriteThroughEntry",
1984: bytes, spec.isPreInstrumented());
1985:
1986: // java.util.AbstractMap$SimpleEntry
1987: bytes = getTerracottaBytes("java.util.AbstractMap$SimpleEntry");
1988: spec = config
1989: .getOrCreateSpec("java.util.AbstractMap$SimpleEntry");
1990: bytes = doDSOTransform(spec.getClassName(), bytes);
1991: bootJar.loadClassIntoJar(
1992: "java.util.AbstractMap$SimpleEntry", bytes, spec
1993: .isPreInstrumented());
1994: }
1995:
1996: // com.tcclient.util.ConcurrentHashMapEntrySetWrapper$EntryWrapper
1997: bytes = getTerracottaBytes("com.tcclient.util.ConcurrentHashMapEntrySetWrapper$EntryWrapper");
1998: spec = config
1999: .getOrCreateSpec("com.tcclient.util.ConcurrentHashMapEntrySetWrapper$EntryWrapper");
2000: spec.markPreInstrumented();
2001: bytes = doDSOTransform(spec.getClassName(), bytes);
2002: bootJar
2003: .loadClassIntoJar(
2004: "com.tcclient.util.ConcurrentHashMapEntrySetWrapper$EntryWrapper",
2005: bytes, spec.isPreInstrumented());
2006:
2007: // java.util.concurrent.ConcurrentHashMap$Values
2008: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$Values");
2009: spec = config
2010: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$Values");
2011: spec
2012: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2013: spec.markPreInstrumented();
2014: bytes = doDSOTransform(spec.getClassName(), bytes);
2015: bootJar.loadClassIntoJar(
2016: "java.util.concurrent.ConcurrentHashMap$Values", bytes,
2017: spec.isPreInstrumented());
2018:
2019: // java.util.concurrent.ConcurrentHashMap$KeySet
2020: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$KeySet");
2021: spec = config
2022: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$KeySet");
2023: spec
2024: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2025: spec.markPreInstrumented();
2026: bytes = doDSOTransform(spec.getClassName(), bytes);
2027: bootJar.loadClassIntoJar(
2028: "java.util.concurrent.ConcurrentHashMap$KeySet", bytes,
2029: spec.isPreInstrumented());
2030:
2031: // java.util.concurrent.ConcurrentHashMap$HashIterator
2032: bytes = getSystemBytes("java.util.concurrent.ConcurrentHashMap$HashIterator");
2033: spec = config
2034: .getOrCreateSpec("java.util.concurrent.ConcurrentHashMap$HashIterator");
2035: spec
2036: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2037: spec.markPreInstrumented();
2038: bytes = doDSOTransform(spec.getClassName(), bytes);
2039: bootJar.loadClassIntoJar(
2040: "java.util.concurrent.ConcurrentHashMap$HashIterator",
2041: bytes, spec.isPreInstrumented());
2042: }
2043:
2044: private final void addInstrumentedJavaUtilConcurrentLinkedBlockingQueue() {
2045: if (!Vm.isJDK15Compliant()) {
2046: return;
2047: }
2048:
2049: // Instrumentation for Itr inner class
2050: byte[] bytes = getSystemBytes("java.util.concurrent.LinkedBlockingQueue$Itr");
2051:
2052: ClassReader cr = new ClassReader(bytes);
2053: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2054: ClassVisitor cv = new JavaUtilConcurrentLinkedBlockingQueueIteratorClassAdapter(
2055: cw);
2056: cr.accept(cv, ClassReader.SKIP_FRAMES);
2057:
2058: bytes = cw.toByteArray();
2059: bootJar.loadClassIntoJar(
2060: "java.util.concurrent.LinkedBlockingQueue$Itr", bytes,
2061: true);
2062:
2063: // Instrumentation for Node inner class
2064: bytes = getSystemBytes("java.util.concurrent.LinkedBlockingQueue$Node");
2065:
2066: cr = new ClassReader(bytes);
2067: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2068: cv = new JavaUtilConcurrentLinkedBlockingQueueNodeClassAdapter(
2069: cw);
2070: cr.accept(cv, ClassReader.SKIP_FRAMES);
2071:
2072: bytes = cw.toByteArray();
2073: bootJar.loadClassIntoJar(
2074: "java.util.concurrent.LinkedBlockingQueue$Node", bytes,
2075: true);
2076:
2077: // Instrumentation for LinkedBlockingQueue class
2078: bytes = getSystemBytes("java.util.concurrent.LinkedBlockingQueue");
2079:
2080: cr = new ClassReader(bytes);
2081: cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2082: cv = new JavaUtilConcurrentLinkedBlockingQueueClassAdapter(cw);
2083: cr.accept(cv, ClassReader.SKIP_FRAMES);
2084:
2085: bytes = cw.toByteArray();
2086:
2087: TransparencyClassSpec spec = config
2088: .getOrCreateSpec(
2089: "java.util.concurrent.LinkedBlockingQueue",
2090: "com.tc.object.applicator.LinkedBlockingQueueApplicator");
2091: // spec.addMethodAdapter(SerializationUtil.QUEUE_PUT_SIGNATURE,
2092: // new JavaUtilConcurrentLinkedBlockingQueueAdapter.PutAdapter());
2093: spec
2094: .addMethodAdapter(
2095: SerializationUtil.TAKE_SIGNATURE,
2096: new JavaUtilConcurrentLinkedBlockingQueueAdapter.TakeAdapter());
2097: spec
2098: .addMethodAdapter(
2099: SerializationUtil.POLL_TIMEOUT_SIGNATURE,
2100: new JavaUtilConcurrentLinkedBlockingQueueAdapter.TakeAdapter());
2101: spec
2102: .addMethodAdapter(
2103: SerializationUtil.POLL_SIGNATURE,
2104: new JavaUtilConcurrentLinkedBlockingQueueAdapter.TakeAdapter());
2105: spec
2106: .addMethodAdapter(
2107: SerializationUtil.CLEAR_SIGNATURE,
2108: new JavaUtilConcurrentLinkedBlockingQueueAdapter.ClearAdapter());
2109: spec
2110: .addMethodAdapter(
2111: SerializationUtil.DRAIN_TO_SIGNATURE,
2112: new JavaUtilConcurrentLinkedBlockingQueueAdapter.ClearAdapter());
2113: spec
2114: .addMethodAdapter(
2115: SerializationUtil.DRAIN_TO_N_SIGNATURE,
2116: new JavaUtilConcurrentLinkedBlockingQueueAdapter.RemoveFirstNAdapter());
2117: spec
2118: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2119: spec.markPreInstrumented();
2120: bytes = doDSOTransform(spec.getClassName(), bytes);
2121: bootJar.loadClassIntoJar(
2122: "java.util.concurrent.LinkedBlockingQueue", bytes, spec
2123: .isPreInstrumented());
2124: }
2125:
2126: private final void addInstrumentedJavaUtilConcurrentFutureTask() {
2127:
2128: if (!Vm.isJDK15Compliant()) {
2129: return;
2130: }
2131: Map instrumentedContext = new HashMap();
2132:
2133: TransparencyClassSpec spec = config
2134: .getOrCreateSpec("java.util.concurrent.FutureTask");
2135: spec.setHonorTransient(true);
2136: spec.setCallConstructorOnLoad(true);
2137: spec.markPreInstrumented();
2138: changeClassName("java.util.concurrent.FutureTaskTC",
2139: "java.util.concurrent.FutureTaskTC",
2140: "java.util.concurrent.FutureTask", instrumentedContext,
2141: true);
2142:
2143: config
2144: .addWriteAutolock("* java.util.concurrent.FutureTask$Sync.*(..)");
2145:
2146: spec = config
2147: .getOrCreateSpec("java.util.concurrent.FutureTask$Sync");
2148: spec.setHonorTransient(true);
2149: spec.markPreInstrumented();
2150: spec
2151: .addDistributedMethodCall("managedInnerCancel", "()V",
2152: true);
2153: changeClassName("java.util.concurrent.FutureTaskTC$Sync",
2154: "java.util.concurrent.FutureTaskTC",
2155: "java.util.concurrent.FutureTask", instrumentedContext,
2156: true);
2157: }
2158:
2159: private final void addInstrumentedJavaUtilCollection() {
2160: TransparencyClassSpec spec = config.getOrCreateSpec(
2161: "java.util.HashSet",
2162: "com.tc.object.applicator.HashSetApplicator");
2163: spec.addIfTrueLogSpec(SerializationUtil.ADD_SIGNATURE);
2164: spec
2165: .addMethodAdapter(SerializationUtil.REMOVE_SIGNATURE,
2166: new SetRemoveMethodAdapter("java/util/HashSet",
2167: "java/util/HashMap", "map",
2168: "java/util/HashMap"));
2169: spec.addAlwaysLogSpec(SerializationUtil.CLEAR_SIGNATURE);
2170: spec
2171: .addSetIteratorWrapperSpec(SerializationUtil.ITERATOR_SIGNATURE);
2172: addSerializationInstrumentedCode(spec);
2173:
2174: spec = config.getOrCreateSpec("java.util.LinkedHashSet",
2175: "com.tc.object.applicator.HashSetApplicator");
2176: addSerializationInstrumentedCode(spec);
2177:
2178: spec = config.getOrCreateSpec("java.util.TreeSet",
2179: "com.tc.object.applicator.TreeSetApplicator");
2180: spec.addIfTrueLogSpec(SerializationUtil.ADD_SIGNATURE);
2181: spec
2182: .addMethodAdapter(
2183: SerializationUtil.REMOVE_SIGNATURE,
2184: new SetRemoveMethodAdapter(
2185: "java/util/TreeSet",
2186: "java/util/TreeMap",
2187: "m",
2188: Vm.getMajorVersion() >= 6 ? "java/util/NavigableMap"
2189: : "java/util/SortedMap"));
2190:
2191: spec.addAlwaysLogSpec(SerializationUtil.CLEAR_SIGNATURE);
2192: spec
2193: .addSetIteratorWrapperSpec(SerializationUtil.ITERATOR_SIGNATURE);
2194: spec.addViewSetWrapperSpec(SerializationUtil.SUBSET_SIGNATURE);
2195: spec.addViewSetWrapperSpec(SerializationUtil.HEADSET_SIGNATURE);
2196: spec.addViewSetWrapperSpec(SerializationUtil.TAILSET_SIGNATURE);
2197: addSerializationInstrumentedCode(spec);
2198:
2199: spec = config.getOrCreateSpec("java.util.LinkedList",
2200: "com.tc.object.applicator.ListApplicator");
2201: spec.addAlwaysLogSpec(SerializationUtil.ADD_AT_SIGNATURE);
2202: spec.addAlwaysLogSpec(SerializationUtil.ADD_SIGNATURE);
2203: spec.addAlwaysLogSpec(SerializationUtil.ADD_ALL_AT_SIGNATURE);
2204: spec.addAlwaysLogSpec(SerializationUtil.ADD_FIRST_SIGNATURE);
2205: spec.addAlwaysLogSpec(SerializationUtil.ADD_LAST_SIGNATURE);
2206: spec.addAlwaysLogSpec(SerializationUtil.SET_SIGNATURE);
2207: spec.addAlwaysLogSpec(SerializationUtil.CLEAR_SIGNATURE);
2208: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_FIRST_SIGNATURE);
2209: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_LAST_SIGNATURE);
2210: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_AT_SIGNATURE);
2211: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_RANGE_SIGNATURE);
2212: spec.addMethodAdapter(
2213: "listIterator(I)Ljava/util/ListIterator;",
2214: new LinkedListAdapter.ListIteratorAdapter());
2215: spec.addMethodAdapter(SerializationUtil.REMOVE_SIGNATURE,
2216: new LinkedListAdapter.RemoveAdapter());
2217: spec
2218: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2219: spec
2220: .addSupportMethodCreator(new LinkedListAdapter.RemoveMethodCreator());
2221: addSerializationInstrumentedCode(spec);
2222:
2223: spec = config.getOrCreateSpec("java.util.Vector",
2224: "com.tc.object.applicator.ListApplicator");
2225: spec
2226: .addAlwaysLogSpec(SerializationUtil.INSERT_ELEMENT_AT_SIGNATURE);
2227: spec.addAlwaysLogSpec(SerializationUtil.ADD_SIGNATURE);
2228: spec.addAlwaysLogSpec(SerializationUtil.ADD_ALL_AT_SIGNATURE);
2229: // the Vector.addAll(Collection) implementation in the IBM JDK simply delegates
2230: // to Vector.addAllAt(int, Collection), if addAll is instrumented as well, the
2231: // vector elements are added twice to the collection
2232: if (!Vm.isIBM()) {
2233: spec.addAlwaysLogSpec(SerializationUtil.ADD_ALL_SIGNATURE);
2234: }
2235: spec.addAlwaysLogSpec(SerializationUtil.ADD_ELEMENT_SIGNATURE);
2236: spec
2237: .addAlwaysLogSpec(SerializationUtil.REMOVE_ALL_ELEMENTS_SIGNATURE);
2238: spec
2239: .addAlwaysLogSpec(SerializationUtil.REMOVE_ELEMENT_AT_SIGNATURE);
2240: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_AT_SIGNATURE);
2241: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_RANGE_SIGNATURE);
2242: spec.addAlwaysLogSpec(SerializationUtil.SET_SIGNATURE);
2243: spec.addAlwaysLogSpec(SerializationUtil.SET_ELEMENT_SIGNATURE);
2244: spec.addAlwaysLogSpec(SerializationUtil.TRIM_TO_SIZE_SIGNATURE);
2245: spec.addAlwaysLogSpec(SerializationUtil.SET_SIZE_SIGNATURE);
2246: spec.addMethodAdapter(SerializationUtil.ELEMENTS_SIGNATURE,
2247: new VectorAdapter.ElementsAdapter());
2248: spec
2249: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2250: spec
2251: .addArrayCopyMethodCodeSpec(SerializationUtil.COPY_INTO_SIGNATURE);
2252: addSerializationInstrumentedCode(spec);
2253:
2254: spec = config.getOrCreateSpec("java.util.Stack",
2255: "com.tc.object.applicator.ListApplicator");
2256: spec
2257: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2258: addSerializationInstrumentedCode(spec);
2259:
2260: spec = config.getOrCreateSpec("java.util.ArrayList",
2261: "com.tc.object.applicator.ListApplicator");
2262: spec.addAlwaysLogSpec(SerializationUtil.ADD_AT_SIGNATURE);
2263: spec.addAlwaysLogSpec(SerializationUtil.ADD_SIGNATURE);
2264: spec.addAlwaysLogSpec(SerializationUtil.ADD_ALL_AT_SIGNATURE);
2265: spec.addAlwaysLogSpec(SerializationUtil.ADD_ALL_SIGNATURE);
2266: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_AT_SIGNATURE);
2267: spec.addAlwaysLogSpec(SerializationUtil.REMOVE_RANGE_SIGNATURE);
2268: spec.addAlwaysLogSpec(SerializationUtil.SET_SIGNATURE);
2269: spec.addAlwaysLogSpec(SerializationUtil.CLEAR_SIGNATURE);
2270: if (Vm.isJDK15Compliant()) {
2271: spec.addMethodAdapter(SerializationUtil.REMOVE_SIGNATURE,
2272: new ArrayListAdapter.RemoveAdaptor());
2273: spec
2274: .addSupportMethodCreator(new ArrayListAdapter.FastRemoveMethodCreator());
2275: }
2276: spec
2277: .addArrayCopyMethodCodeSpec(SerializationUtil.TO_ARRAY_SIGNATURE);
2278: addSerializationInstrumentedCode(spec);
2279: }
2280:
2281: private final void addSerializationInstrumentedCode(
2282: TransparencyClassSpec spec) {
2283: byte[] bytes = getSystemBytes(spec.getClassName());
2284: spec.markPreInstrumented();
2285: bytes = doDSOTransform(spec.getClassName(), bytes);
2286:
2287: ClassReader cr = new ClassReader(bytes);
2288: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2289: ClassVisitor cv = new LogicalClassSerializationAdapter.LogicalClassSerializationClassAdapter(
2290: cw, spec.getClassName());
2291: cr.accept(cv, ClassReader.SKIP_FRAMES);
2292:
2293: bytes = cw.toByteArray();
2294: bootJar.loadClassIntoJar(spec.getClassName(), bytes, spec
2295: .isPreInstrumented());
2296: }
2297:
2298: private final void addInstrumentedHashtable() {
2299: String jMapClassNameDots = "java.util.Hashtable";
2300: String tcMapClassNameDots = "java.util.HashtableTC";
2301: Map instrumentedContext = new HashMap();
2302: mergeClass(tcMapClassNameDots, jMapClassNameDots,
2303: instrumentedContext, HashtableClassAdapter.getMethods());
2304: }
2305:
2306: private final void addInstrumentedLinkedHashMap(
2307: Map instrumentedContext) {
2308: String jMapClassNameDots = "java.util.LinkedHashMap";
2309: String tcMapClassNameDots = "java.util.LinkedHashMapTC";
2310: mergeClass(tcMapClassNameDots, jMapClassNameDots,
2311: instrumentedContext);
2312: }
2313:
2314: private void addInstrumentedReentrantReadWriteLock() {
2315: String methodPrefix = "__RWL" + ByteCodeUtil.TC_METHOD_PREFIX;
2316:
2317: TransparencyClassSpec spec = config
2318: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock");
2319: spec.setCallConstructorOnLoad(true);
2320:
2321: String jClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLock";
2322: String tcClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLockTC";
2323: Map instrumentedContext = new HashMap();
2324: mergeReentrantReadWriteLock(tcClassNameDots, jClassNameDots,
2325: instrumentedContext, methodPrefix);
2326:
2327: spec = config
2328: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock");
2329: spec.markPreInstrumented();
2330: spec = config
2331: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock$WriteLock");
2332: spec.markPreInstrumented();
2333:
2334: String jInnerClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock";
2335: String tcInnerClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLockTC$ReadLock";
2336: instrumentedContext = new HashMap();
2337: mergeReadWriteLockInnerClass(tcInnerClassNameDots,
2338: jInnerClassNameDots, tcClassNameDots, jClassNameDots,
2339: "ReadLock", "ReadLock", instrumentedContext,
2340: methodPrefix);
2341:
2342: jInnerClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLock$WriteLock";
2343: tcInnerClassNameDots = "java.util.concurrent.locks.ReentrantReadWriteLockTC$WriteLock";
2344: instrumentedContext = new HashMap();
2345: mergeReadWriteLockInnerClass(tcInnerClassNameDots,
2346: jInnerClassNameDots, tcClassNameDots, jClassNameDots,
2347: "WriteLock", "WriteLock", instrumentedContext,
2348: methodPrefix);
2349:
2350: spec = config
2351: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock$Sync");
2352: spec.setHonorTransient(true);
2353: spec.setCallConstructorOnLoad(true);
2354: spec.markPreInstrumented();
2355: spec = config
2356: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock$FairSync");
2357: spec.setCallConstructorOnLoad(true);
2358: spec.markPreInstrumented();
2359: spec = config
2360: .getOrCreateSpec("java.util.concurrent.locks.ReentrantReadWriteLock$NonfairSync");
2361: spec.setCallConstructorOnLoad(true);
2362: spec.markPreInstrumented();
2363:
2364: makeAbstractSynchronizerAdaptable();
2365: }
2366:
2367: private void makeAbstractSynchronizerAdaptable() {
2368: TransparencyClassSpec spec = config
2369: .getOrCreateSpec("java.util.concurrent.locks.AbstractQueuedSynchronizer");
2370: spec.setHonorTransient(true);
2371: spec.addTransient("state");
2372: spec.setInstrumentationAction(TransparencyClassSpec.ADAPTABLE);
2373: spec.markPreInstrumented();
2374:
2375: spec = config
2376: .getOrCreateSpec("java.util.concurrent.locks.AbstractQueuedSynchronizer$Node");
2377: spec.setInstrumentationAction(TransparencyClassSpec.ADAPTABLE);
2378: spec.markPreInstrumented();
2379:
2380: if (Vm.isJDK16Compliant()) {
2381: spec = config
2382: .getOrCreateSpec("java.util.concurrent.locks.AbstractOwnableSynchronizer");
2383: spec
2384: .setInstrumentationAction(TransparencyClassSpec.ADAPTABLE);
2385: spec.setHonorTransient(true);
2386: spec.markPreInstrumented();
2387: }
2388: }
2389:
2390: private void mergeReadWriteLockInnerClass(
2391: String tcInnerClassNameDots, String jInnerClassNameDots,
2392: String tcClassNameDots, String jClassNameDots,
2393: String srcInnerClassName, String targetInnerClassName,
2394: Map instrumentedContext, String methodPrefix) {
2395: String tcInnerClassNameSlashes = tcInnerClassNameDots.replace(
2396: ChangeClassNameHierarchyAdapter.DOT_DELIMITER,
2397: ChangeClassNameHierarchyAdapter.SLASH_DELIMITER);
2398: byte[] tcData = getSystemBytes(tcInnerClassNameDots);
2399: ClassReader tcCR = new ClassReader(tcData);
2400: ClassNode tcCN = new ClassNode();
2401: tcCR.accept(tcCN, ClassReader.SKIP_DEBUG
2402: | ClassReader.SKIP_FRAMES);
2403:
2404: byte[] jData = getSystemBytes(jInnerClassNameDots);
2405:
2406: // jData = doDSOTransform(jInnerClassNameDots, jData);
2407:
2408: ClassReader jCR = new ClassReader(jData);
2409: ClassWriter cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2410:
2411: ClassInfo jClassInfo = AsmClassInfo.getClassInfo(
2412: jInnerClassNameDots, systemLoader);
2413: TransparencyClassAdapter dsoAdapter = config
2414: .createDsoClassAdapterFor(cw, jClassInfo,
2415: instrumentationLogger, getClass()
2416: .getClassLoader(), true, false);
2417: ClassVisitor cv = new SerialVersionUIDAdder(
2418: new MergeTCToJavaClassAdapter(cw, dsoAdapter,
2419: jInnerClassNameDots, tcInnerClassNameDots,
2420: tcCN, instrumentedContext, methodPrefix, false));
2421: jCR.accept(cv, ClassReader.SKIP_FRAMES);
2422: jData = cw.toByteArray();
2423:
2424: jData = changeClassNameAndGetBytes(jData,
2425: tcInnerClassNameSlashes, tcClassNameDots,
2426: jClassNameDots, srcInnerClassName,
2427: targetInnerClassName, instrumentedContext);
2428:
2429: jData = doDSOTransform(jInnerClassNameDots, jData);
2430: bootJar.loadClassIntoJar(jInnerClassNameDots, jData, true);
2431: }
2432:
2433: private void mergeReentrantReadWriteLock(String tcClassNameDots,
2434: String jClassNameDots, Map instrumentedContext,
2435: String methodPrefix) {
2436: byte[] tcData = getSystemBytes(tcClassNameDots);
2437: ClassReader tcCR = new ClassReader(tcData);
2438: ClassNode tcCN = new ClassNode();
2439: tcCR.accept(tcCN, ClassReader.SKIP_DEBUG
2440: | ClassReader.SKIP_FRAMES);
2441:
2442: byte[] jData = getSystemBytes(jClassNameDots);
2443:
2444: // jData = doDSOTransform(jClassNameDots, jData);
2445:
2446: ClassReader jCR = new ClassReader(jData);
2447: ClassWriter cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2448: ClassVisitor cv1 = new ReentrantReadWriteLockClassAdapter(cw);
2449:
2450: jCR.accept(cv1, ClassReader.SKIP_DEBUG
2451: | ClassReader.SKIP_FRAMES);
2452: jData = cw.toByteArray();
2453:
2454: jCR = new ClassReader(jData);
2455: cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2456:
2457: ClassInfo jClassInfo = AsmClassInfo.getClassInfo(
2458: jClassNameDots, systemLoader);
2459: TransparencyClassAdapter dsoAdapter = config
2460: .createDsoClassAdapterFor(cw, jClassInfo,
2461: instrumentationLogger, getClass()
2462: .getClassLoader(), true, true);
2463: ClassVisitor cv = new SerialVersionUIDAdder(
2464: new MergeTCToJavaClassAdapter(cw, dsoAdapter,
2465: jClassNameDots, tcClassNameDots, tcCN,
2466: instrumentedContext, methodPrefix, true));
2467: jCR.accept(cv, ClassReader.SKIP_FRAMES);
2468: jData = cw.toByteArray();
2469: jData = doDSOTransform(jClassNameDots, jData);
2470: bootJar.loadClassIntoJar(jClassNameDots, jData, true);
2471:
2472: String innerClassName = "java/util/concurrent/locks/ReentrantReadWriteLockTC$DsoLock";
2473: changeClassNameAndGetBytes(innerClassName, tcClassNameDots,
2474: jClassNameDots, instrumentedContext);
2475: changeClassName(innerClassName, tcClassNameDots,
2476: jClassNameDots, instrumentedContext, true);
2477: }
2478:
2479: private void addInstrumentedHashMap() {
2480: String jMapClassNameDots = "java.util.HashMap";
2481: String tcMapClassNameDots = "java.util.HashMapTC";
2482: Map instrumentedContext = new HashMap();
2483: mergeClass(tcMapClassNameDots, jMapClassNameDots,
2484: instrumentedContext);
2485:
2486: addInstrumentedLinkedHashMap(instrumentedContext);
2487: }
2488:
2489: private final void mergeClass(String tcClassNameDots,
2490: String jClassNameDots, Map instrumentedContext) {
2491: mergeClass(tcClassNameDots, jClassNameDots,
2492: instrumentedContext, null);
2493: }
2494:
2495: private final void mergeClass(String tcClassNameDots,
2496: String jClassNameDots, Map instrumentedContext,
2497: final MethodNode[] replacedMethods) {
2498: byte[] tcData = getSystemBytes(tcClassNameDots);
2499:
2500: ClassReader tcCR = new ClassReader(tcData);
2501: ClassNode tcCN = new ClassNode() {
2502: public MethodVisitor visitMethod(int maccess, String mname,
2503: String mdesc, String msignature,
2504: String[] mexceptions) {
2505: if (replacedMethods != null) {
2506: for (int i = 0; i < replacedMethods.length; i++) {
2507: MethodNode replacedMethod = replacedMethods[i];
2508: if (mname.equals(replacedMethod.name)
2509: && mdesc.equals(replacedMethod.desc)) {
2510: methods.add(replacedMethod);
2511: return null;
2512: }
2513: }
2514: }
2515: return super .visitMethod(maccess, mname, mdesc,
2516: msignature, mexceptions);
2517: }
2518: };
2519: tcCR.accept(tcCN, ClassReader.SKIP_DEBUG
2520: | ClassReader.SKIP_FRAMES);
2521:
2522: byte[] jData = getSystemBytes(jClassNameDots);
2523: ClassReader jCR = new ClassReader(jData);
2524: ClassWriter cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2525:
2526: ClassVisitor cv1 = new LinkedHashMapClassAdapter(cw);
2527: jCR.accept(cv1, ClassReader.SKIP_DEBUG
2528: | ClassReader.SKIP_FRAMES);
2529: jData = cw.toByteArray();
2530:
2531: jCR = new ClassReader(jData);
2532: cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2533: ClassNode jCN = new ClassNode();
2534: jCR.accept(jCN, ClassReader.SKIP_DEBUG
2535: | ClassReader.SKIP_FRAMES);
2536:
2537: ClassInfo jClassInfo = AsmClassInfo.getClassInfo(
2538: jClassNameDots, systemLoader);
2539: TransparencyClassAdapter dsoAdapter = config
2540: .createDsoClassAdapterFor(cw, jClassInfo,
2541: instrumentationLogger, getClass()
2542: .getClassLoader(), true, false);
2543: ClassVisitor cv = new SerialVersionUIDAdder(
2544: new MergeTCToJavaClassAdapter(cw, dsoAdapter,
2545: jClassNameDots, tcClassNameDots, tcCN,
2546: instrumentedContext));
2547: jCR.accept(cv, ClassReader.SKIP_FRAMES);
2548: bootJar
2549: .loadClassIntoJar(jClassNameDots, cw.toByteArray(),
2550: true);
2551:
2552: List innerClasses = tcCN.innerClasses;
2553: // load ClassInfo for all inner classes
2554: for (Iterator i = innerClasses.iterator(); i.hasNext();) {
2555: InnerClassNode innerClass = (InnerClassNode) i.next();
2556:
2557: if (innerClass.outerName.equals(tcClassNameDots.replace(
2558: ChangeClassNameHierarchyAdapter.DOT_DELIMITER,
2559: ChangeClassNameHierarchyAdapter.SLASH_DELIMITER))) {
2560: changeClassNameAndGetBytes(innerClass.name,
2561: tcClassNameDots, jClassNameDots,
2562: instrumentedContext);
2563: }
2564: }
2565: // transform and add inner classes to the boot jar
2566: for (Iterator i = innerClasses.iterator(); i.hasNext();) {
2567: InnerClassNode innerClass = (InnerClassNode) i.next();
2568: if (innerClass.outerName.equals(tcClassNameDots.replace(
2569: ChangeClassNameHierarchyAdapter.DOT_DELIMITER,
2570: ChangeClassNameHierarchyAdapter.SLASH_DELIMITER))) {
2571: changeClassName(innerClass.name, tcClassNameDots,
2572: jClassNameDots, instrumentedContext, false);
2573: }
2574: }
2575: }
2576:
2577: private void changeClassName(String fullClassNameDots,
2578: String classNameDotsToBeChanged,
2579: String classNameDotsReplaced, Map instrumentedContext,
2580: boolean honorTransient) {
2581: byte[] data = changeClassNameAndGetBytes(fullClassNameDots,
2582: classNameDotsToBeChanged, classNameDotsReplaced,
2583: instrumentedContext);
2584:
2585: String replacedClassName = ChangeClassNameRootAdapter
2586: .replaceClassName(fullClassNameDots,
2587: classNameDotsToBeChanged,
2588: classNameDotsReplaced, null, null);
2589: ClassInfo replacedClassInfo = AsmClassInfo.getClassInfo(
2590: replacedClassName, systemLoader);
2591:
2592: ClassReader cr = new ClassReader(data);
2593: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2594: ClassVisitor dsoAdapter = config.createDsoClassAdapterFor(cw,
2595: replacedClassInfo, instrumentationLogger, //
2596: getClass().getClassLoader(), true, honorTransient);
2597: cr.accept(dsoAdapter, ClassReader.SKIP_FRAMES);
2598:
2599: bootJar.loadClassIntoJar(replacedClassName, cw.toByteArray(),
2600: true);
2601: }
2602:
2603: private final byte[] changeClassNameAndGetBytes(
2604: String fullClassNameDots, String classNameDotsToBeChanged,
2605: String classNameDotsReplaced, Map instrumentedContext) {
2606: return changeClassNameAndGetBytes(fullClassNameDots,
2607: classNameDotsToBeChanged, classNameDotsReplaced, null,
2608: null, instrumentedContext);
2609: }
2610:
2611: private final byte[] changeClassNameAndGetBytes(
2612: String fullClassNameDots, String classNameDotsToBeChanged,
2613: String classNameDotsReplaced, String srcInnerClassName,
2614: String targetInnerClassName, Map instrumentedContext) {
2615: return changeClassNameAndGetBytes(
2616: getSystemBytes(fullClassNameDots), fullClassNameDots,
2617: classNameDotsToBeChanged, classNameDotsReplaced,
2618: srcInnerClassName, targetInnerClassName,
2619: instrumentedContext);
2620: }
2621:
2622: private final byte[] changeClassNameAndGetBytes(byte[] data,
2623: String fullClassNameDots, String classNameDotsToBeChanged,
2624: String classNameDotsReplaced, String srcInnerClassName,
2625: String targetInnerClassName, Map instrumentedContext) {
2626: ClassReader cr = new ClassReader(data);
2627: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2628: ClassVisitor cv = new ChangeClassNameRootAdapter(cw,
2629: fullClassNameDots, classNameDotsToBeChanged,
2630: classNameDotsReplaced, srcInnerClassName,
2631: targetInnerClassName, instrumentedContext, null);
2632: cr.accept(cv, ClassReader.SKIP_FRAMES);
2633:
2634: data = cw.toByteArray();
2635:
2636: AsmClassInfo.getClassInfo(data, systemLoader);
2637:
2638: return data;
2639: }
2640:
2641: private void addInstrumentedJavaUtilConcurrentLocks() {
2642: if (!Vm.isJDK15Compliant()) {
2643: return;
2644: }
2645: addInstrumentedReentrantReadWriteLock();
2646: addInstrumentedReentrantLock();
2647: addInstrumentedConditionObject();
2648: }
2649:
2650: private void addInstrumentedConditionObject() {
2651: String classNameDots = "com.tcclient.util.concurrent.locks.ConditionObject";
2652: byte[] bytes = getSystemBytes(classNameDots);
2653: TransparencyClassSpec spec = config
2654: .getOrCreateSpec(classNameDots);
2655: spec.disableWaitNotifyCodeSpec("signal()V");
2656: spec.disableWaitNotifyCodeSpec("signalAll()V");
2657: spec.setHonorTransient(true);
2658: spec.markPreInstrumented();
2659: bytes = doDSOTransform(classNameDots, bytes);
2660: bootJar.loadClassIntoJar(classNameDots, bytes, spec
2661: .isPreInstrumented());
2662: config.removeSpec(classNameDots);
2663:
2664: classNameDots = "com.tcclient.util.concurrent.locks.ConditionObject$SyncCondition";
2665: bytes = getSystemBytes(classNameDots);
2666: spec = config.getOrCreateSpec(classNameDots);
2667: spec.markPreInstrumented();
2668: bytes = doDSOTransform(classNameDots, bytes);
2669: bootJar.loadClassIntoJar(classNameDots, bytes, spec
2670: .isPreInstrumented());
2671: config.removeSpec(classNameDots);
2672:
2673: }
2674:
2675: private void addInstrumentedReentrantLock() {
2676: TransparencyClassSpec spec = config
2677: .getOrCreateSpec("java.util.concurrent.locks.ReentrantLock");
2678: spec.addTransient("sync");
2679: spec.setCallConstructorOnLoad(true);
2680:
2681: String jClassNameDots = "java.util.concurrent.locks.ReentrantLock";
2682: String tcClassNameDots = "java.util.concurrent.locks.ReentrantLockTC";
2683: Map instrumentedContext = new HashMap();
2684: mergeReentrantLock(tcClassNameDots, jClassNameDots,
2685: instrumentedContext);
2686: }
2687:
2688: private void mergeReentrantLock(String tcClassNameDots,
2689: String jClassNameDots, Map instrumentedContext) {
2690: byte[] tcData = getSystemBytes(tcClassNameDots);
2691: ClassReader tcCR = new ClassReader(tcData);
2692: ClassNode tcCN = new ClassNode();
2693: tcCR.accept(tcCN, ClassReader.SKIP_DEBUG
2694: | ClassReader.SKIP_FRAMES);
2695:
2696: byte[] jData = getSystemBytes(jClassNameDots);
2697: ClassReader jCR = new ClassReader(jData);
2698: ClassWriter cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2699: ClassVisitor cv1 = new ReentrantLockClassAdapter(cw);
2700:
2701: jCR.accept(cv1, ClassReader.SKIP_DEBUG
2702: | ClassReader.SKIP_FRAMES);
2703: jData = cw.toByteArray();
2704:
2705: jCR = new ClassReader(jData);
2706: cw = new ClassWriter(jCR, ClassWriter.COMPUTE_MAXS);
2707:
2708: ClassInfo jClassInfo = AsmClassInfo.getClassInfo(
2709: jClassNameDots, systemLoader);
2710: TransparencyClassAdapter dsoAdapter = config
2711: .createDsoClassAdapterFor(cw, jClassInfo,
2712: instrumentationLogger, getClass()
2713: .getClassLoader(), true, true);
2714: ClassVisitor cv = new SerialVersionUIDAdder(
2715: new MergeTCToJavaClassAdapter(cw, dsoAdapter,
2716: jClassNameDots, tcClassNameDots, tcCN,
2717: instrumentedContext));
2718: jCR.accept(cv, ClassReader.SKIP_FRAMES);
2719: jData = cw.toByteArray();
2720: jData = doDSOTransform(jClassNameDots, jData);
2721: bootJar.loadClassIntoJar(jClassNameDots, jData, true);
2722: }
2723:
2724: private final void addInstrumentedWeakHashMap() {
2725: ClassReader reader = new ClassReader(
2726: getSystemBytes("java.util.WeakHashMap"));
2727: ClassWriter writer = new ClassWriter(reader,
2728: ClassWriter.COMPUTE_MAXS);
2729:
2730: ClassVisitor cv = new JavaUtilWeakHashMapAdapter().create(
2731: writer, null);
2732:
2733: reader.accept(cv, ClassReader.SKIP_FRAMES);
2734:
2735: bootJar.loadClassIntoJar("java.util.WeakHashMap", writer
2736: .toByteArray(), false);
2737: }
2738:
2739: private final void addInstrumentedClassLoader() {
2740: // patch the java.lang.ClassLoader
2741: ClassLoaderPreProcessorImpl adapter = new ClassLoaderPreProcessorImpl();
2742: byte[] patched = adapter
2743: .preProcess(getSystemBytes("java.lang.ClassLoader"));
2744:
2745: ClassReader cr = new ClassReader(patched);
2746: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2747: ClassVisitor cv = new NamedLoaderAdapter().create(cw, null);
2748: cr.accept(cv, ClassReader.SKIP_FRAMES);
2749:
2750: bootJar.loadClassIntoJar("java.lang.ClassLoader", cw
2751: .toByteArray(), false);
2752: }
2753:
2754: protected final byte[] doDSOTransform(String name, byte[] data) {
2755: // adapts the class on the fly
2756: ClassReader cr = new ClassReader(data);
2757: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2758: ClassInfo classInfo = AsmClassInfo.getClassInfo(data, tcLoader);
2759: ClassVisitor cv = config.createClassAdapterFor(cw, classInfo,
2760: instrumentationLogger, getClass().getClassLoader(),
2761: true);
2762: cr.accept(cv, ClassReader.SKIP_FRAMES);
2763:
2764: return cw.toByteArray();
2765: }
2766:
2767: private final void adaptClassIfNotAlreadyIncluded(String className,
2768: Class adapter) {
2769: if (bootJar.classLoaded(className)) {
2770: return;
2771: }
2772:
2773: byte[] orig = getSystemBytes(className);
2774:
2775: ClassReader cr = new ClassReader(orig);
2776: ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
2777:
2778: ClassVisitor cv;
2779: try {
2780: cv = (ClassVisitor) adapter.getConstructor(
2781: new Class[] { ClassVisitor.class }).newInstance(
2782: new Object[] { cw });
2783: } catch (Exception e) {
2784: throw exit("Can't instaniate class apapter using class "
2785: + adapter, e);
2786: }
2787: cr.accept(cv, ClassReader.SKIP_FRAMES);
2788:
2789: bootJar.loadClassIntoJar(className, cw.toByteArray(), false);
2790: }
2791:
2792: protected void announce(String msg) {
2793: if (!quiet)
2794: System.out.println(msg);
2795: }
2796:
2797: private final static File getInstallationDir() {
2798: try {
2799: return Directories.getInstallationRoot();
2800: } catch (FileNotFoundException fnfe) {
2801: return null;
2802: }
2803: }
2804:
2805: private static final String MAKE_MODE = "make";
2806: private static final String SCAN_MODE = "scan";
2807:
2808: public final static void main(String[] args) throws Exception {
2809: File installDir = getInstallationDir();
2810: String outputFileOptionMsg = "path to boot JAR file"
2811: + (installDir != null ? "\ndefault: [TC_INSTALL_DIR]/lib/dso-boot"
2812: : "");
2813: Option targetFileOption = new Option(TARGET_FILE_OPTION, true,
2814: outputFileOptionMsg);
2815: targetFileOption.setArgName("file");
2816: targetFileOption.setLongOpt("bootjar-file");
2817: targetFileOption.setArgs(1);
2818: targetFileOption.setRequired(installDir == null);
2819: targetFileOption.setType(String.class);
2820:
2821: Option configFileOption = new Option("f", "config", true,
2822: "configuration file (optional)");
2823: configFileOption.setArgName("file-or-URL");
2824: configFileOption.setType(String.class);
2825: configFileOption.setRequired(false);
2826:
2827: Option overwriteOption = new Option("w", "overwrite", false,
2828: "always make the boot JAR file");
2829: overwriteOption.setType(String.class);
2830: overwriteOption.setRequired(false);
2831:
2832: Option verboseOption = new Option("v", "verbose");
2833: verboseOption.setType(String.class);
2834: verboseOption.setRequired(false);
2835:
2836: Option helpOption = new Option("h", "help");
2837: helpOption.setType(String.class);
2838: helpOption.setRequired(false);
2839:
2840: Options options = new Options();
2841: options.addOption(targetFileOption);
2842: options.addOption(configFileOption);
2843: options.addOption(overwriteOption);
2844: options.addOption(verboseOption);
2845: options.addOption(helpOption);
2846:
2847: String mode = MAKE_MODE;
2848: CommandLine commandLine = null;
2849: try {
2850: commandLine = new PosixParser().parse(options, args);
2851: if (commandLine.getArgList().size() > 0) {
2852: mode = commandLine.getArgList().get(0).toString()
2853: .toLowerCase();
2854: }
2855: } catch (ParseException pe) {
2856: new HelpFormatter().printHelp("java "
2857: + BootJarTool.class.getName(), options);
2858: System.exit(1);
2859: }
2860:
2861: final String MAKE_OR_SCAN_MODE = "<" + MAKE_MODE + "|"
2862: + SCAN_MODE + ">";
2863: if (!mode.equals(MAKE_MODE) && !mode.equals(SCAN_MODE)) {
2864: new HelpFormatter().printHelp("java "
2865: + BootJarTool.class.getName() + " "
2866: + MAKE_OR_SCAN_MODE, options);
2867: System.exit(1);
2868: }
2869:
2870: if (commandLine.hasOption("h")) {
2871: new HelpFormatter().printHelp("java "
2872: + BootJarTool.class.getName() + " "
2873: + MAKE_OR_SCAN_MODE, options);
2874: System.exit(1);
2875: }
2876:
2877: if (!commandLine.hasOption("f")) {
2878: String cwd = System.getProperty("user.dir");
2879: File localConfig = new File(cwd, DEFAULT_CONFIG_SPEC);
2880: String configSpec;
2881:
2882: if (localConfig.exists()) {
2883: configSpec = localConfig.getAbsolutePath();
2884: } else {
2885: configSpec = StandardTVSConfigurationSetupManagerFactory.DEFAULT_CONFIG_URI;
2886: }
2887:
2888: String[] newArgs = new String[args.length + 2];
2889: System.arraycopy(args, 0, newArgs, 0, args.length);
2890: newArgs[newArgs.length - 2] = "-f";
2891: newArgs[newArgs.length - 1] = configSpec;
2892:
2893: commandLine = new PosixParser().parse(options, newArgs);
2894: }
2895:
2896: StandardTVSConfigurationSetupManagerFactory factory;
2897: factory = new StandardTVSConfigurationSetupManagerFactory(
2898: commandLine, false,
2899: new FatalIllegalConfigurationChangeHandler());
2900: boolean verbose = commandLine.hasOption("v");
2901: TCLogger logger = verbose ? CustomerLogging.getConsoleLogger()
2902: : new NullTCLogger();
2903: L1TVSConfigurationSetupManager config = factory
2904: .createL1TVSConfigurationSetupManager(logger);
2905:
2906: File targetFile;
2907:
2908: if (!commandLine.hasOption(TARGET_FILE_OPTION)) {
2909: File libDir = new File(installDir, "lib");
2910: targetFile = new File(libDir, "dso-boot");
2911: if (!targetFile.exists()) {
2912: targetFile.mkdirs();
2913: }
2914: } else {
2915: targetFile = new File(commandLine
2916: .getOptionValue(TARGET_FILE_OPTION))
2917: .getAbsoluteFile();
2918: }
2919:
2920: if (targetFile.isDirectory()) {
2921: targetFile = new File(targetFile, BootJarSignature
2922: .getBootJarNameForThisVM());
2923: }
2924:
2925: // This used to be a provider that read from a specified rt.jar (to let us create boot jars for other platforms).
2926: // That requirement is no more, but might come back, so I'm leaving at least this much scaffolding in place
2927: // WAS: systemProvider = new RuntimeJarBytesProvider(...)
2928: ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
2929: BootJarTool bjTool = new BootJarTool(
2930: new StandardDSOClientConfigHelperImpl(config, false),
2931: targetFile, systemLoader, !verbose);
2932:
2933: if (mode.equals(MAKE_MODE)) {
2934: boolean makeItAnyway = commandLine.hasOption("w");
2935: if (makeItAnyway
2936: || !targetFile.exists()
2937: || (targetFile.exists() && !bjTool
2938: .isBootJarComplete(targetFile))) {
2939: // Don't reuse boot jar tool instance since its config might have been mutated by isBootJarComplete()
2940: bjTool = new BootJarTool(
2941: new StandardDSOClientConfigHelperImpl(config,
2942: false), targetFile, systemLoader,
2943: !verbose);
2944: bjTool.generateJar();
2945: }
2946: bjTool.verifyJar(targetFile);
2947: } else if (mode.equals(SCAN_MODE)) {
2948: bjTool.scanJar(targetFile);
2949: } else {
2950: System.err
2951: .println("\nInvalid mode specified, valid modes are: '"
2952: + MAKE_MODE
2953: + "' and '"
2954: + SCAN_MODE
2955: + "';"
2956: + "use the -h option to view the options for this tool.");
2957: System.exit(1);
2958: }
2959: }
2960: }
|