org.hotswap.agent.plugin.jvm

Class AnonymousClassPatchPlugin

java.lang.Object

org.hotswap.agent.plugin.jvm.AnonymousClassPatchPlugin

@Plugin(name="AnonymousClassPatch",
        description="Swap anonymous inner class names to avoid not compatible changes.",
        testedVersions="DCEVM")
public class AnonymousClassPatchPlugin
extends Object

Class names MyClass$1, MyClass$2 are created in the order as anonymous class appears in the source code. After anonymous class insertion/deletion the indexes are shifted producing not compatible hot swap.

This patch will create class state info before the change (from current ClassLoader via reflection) and after the change (from filesystem using javassist) find all compatible transitions.

For example if you exchange order the anonymous class appears in the source code, Transition may produce something like:

• MyClass$1 -> MyClass$2
• MyClass$2 -> MyClass$3
• MyClass$3 -> MyClass$1

Then the transformation will behave:

• When the class MyClass$1 is hot swapped, the bytecode from MyClass$2 is returned (and renamed to MyClass$1)
• When the class MyClass$2 is hot swapped, the bytecode from MyClass$3 is returned (and renamed to MyClass$2)
• When the class MyClass$3 is hot swapped, the bytecode from MyClass$1 is returned (and renamed to MyClass$3)
• When the class MyClass is hot swapped, all occurences of MyClass$1 are exchanged for MyClass$3
• , all occurences of MyClass$2 are exchanged for MyClass$1
• , all occurences of MyClass$3 are exchanged for MyClass$2

Swap may produce even to not compatible change. Consider existing MyClass$1 and MyClass$2, then MyClass$1 is removed. Then hotswap is called only on MyClass$1, which contains different class to MyClass$2. Then MyClass$1 is on hotswap replaced with empty implementation and new class MyClass$1000x is created to contain code from the new MyClass$1 (class compatible with old MyClass$2). Not that because this is not a true hotswap, old existing instances of MyClass$1 are updated to an empty class, not the new one. When calling a method on this class, AbstractErrorMethod is thrown (this should be replaced to some more clear error in the future).

Author:

Jiri Bubnik

Constructor Summary

Constructors

Constructor and Description
AnonymousClassPatchPlugin()

Method Summary

Modifier and Type	Method and Description
static CtClass	patchAnonymousClass(ClassLoader classLoader, ClassPool classPool, String className, Class original) Replace an anonymous class with an compatible change (from another class according to state info).
static byte[]	patchMainClass(String className, ClassPool classPool, CtClass ctClass, ClassLoader classLoader, ProtectionDomain protectionDomain) If class contains anonymous classes, rename class references to compatible transition classes.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AnonymousClassPatchPlugin

public AnonymousClassPatchPlugin()

Method Detail

patchAnonymousClass

@OnClassLoadEvent(classNameRegexp=".*\\$\\d+",
                  events=REDEFINE)
public static CtClass patchAnonymousClass(ClassLoader classLoader,
                                                                                                                              ClassPool classPool,
                                                                                                                              String className,
                                                                                                                              Class original)
                                                                                                                       throws IOException,
                                                                                                                              NotFoundException,
                                                                                                                              CannotCompileException

Replace an anonymous class with an compatible change (from another class according to state info). If no compatible class exists, replace with compatible empty implementation.

Throws:

IOException

NotFoundException

CannotCompileException

patchMainClass

@OnClassLoadEvent(classNameRegexp=".*",
                  events=REDEFINE)
public static byte[] patchMainClass(String className,
                                                                                                                 ClassPool classPool,
                                                                                                                 CtClass ctClass,
                                                                                                                 ClassLoader classLoader,
                                                                                                                 ProtectionDomain protectionDomain)
                                                                                                          throws IOException,
                                                                                                                 CannotCompileException,
                                                                                                                 NotFoundException

If class contains anonymous classes, rename class references to compatible transition classes.

If the transitioned class is not loaded by hotswap replace, catch class define event to do the replacement.

Define new synthetic classes for not compatible changes.

Throws:

IOException

CannotCompileException

NotFoundException