Handle continuable Java and CGLib proxies

Author: vsilaev

net.tascalate.javaflow.api/src/main/java/org/apache/commons/javaflow/core/ContinuableProxy.java

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2013-2019 Valery Silaev (http://vsilaev.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.javaflow.core;
+
+import java.lang.reflect.Proxy;
+
+/**
+ * Marker interface for dynamic proxy classes like standard Java {@link Proxy} or CGLib Proxy.
+ * Run-time instrumentation agent is capable to correctly decorate such proxies so continuable methods works correctly 
+ * 
+ * @author vsilaev
+ *
+ */
+public interface ContinuableProxy {}

net.tascalate.javaflow.api/src/main/java/org/apache/commons/javaflow/core/CustomContinuableProxy.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2013-2019 Valery Silaev (http://vsilaev.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.javaflow.core;
+
+import java.lang.reflect.Proxy;
+
+/**
+ * Generic interface for continuable dynamic proxy classes.
+ * Unlike standard Java {@link Proxy} or CGLib Proxy where it's possible to resolve proxy -> handler 
+ * dependency via API, custom continuable proxies should provide implementation of this interface to get 
+ * corresponding "handler" from the proxied object, in the same manner as {@link Proxy#getInvocationHandler(Object)}. 
+ * 
+ * @author vsilaev
+ *
+ */
+public interface CustomContinuableProxy {
+    /**
+     * Get a real continuable invocation handler for the proxy method descrived via <code>methodName</code>
+     * and <code>methodDescription</code>.
+     * 
+     * @param methodName name of the continuable method that is proxied
+     * @param methodDescription arguments/return type of the method in internal JVM format
+     * @return the continuable handler that processed invocation 
+     */
+    public Object getInvocationHandler(String methodName, String methodDescription);
+}

net.tascalate.javaflow.api/src/main/java/org/apache/commons/javaflow/core/ReflectionUtils.java

@@ -22,7 +22,6 @@
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
@@ -168,33 +167,4 @@ public static final String descriptionOfObject(Object o) {
     public static final String descriptionOfClass(Object o) {
         return getClassName(o) + "/" + getClassLoaderName(o);
     }
-
-
-    public static Class<?> defineClass(ClassLoader cl, byte[] b) {
-        try {
-            return (Class<?>) defineClassMethod.invoke(cl, null, b, 0, b.length);
-        } catch (InvocationTargetException ex) {
-            log.error("Could not define class", ex.getTargetException());
-            throw new RuntimeException(ex.getTargetException());
-        } catch (Exception ex) {
-            log.error("Could not invoke method \"defineClass\"", ex);
-            throw new RuntimeException(ex);
-        }
-    }
-
-    private static final Method defineClassMethod;
-
-    static {
-        // defineClass(String name, byte[] b, int off, int len)
-        try {
-            defineClassMethod = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class,
-                    int.class, int.class);
-            defineClassMethod.setAccessible(true);
-        } catch (NoSuchMethodException ex) {
-            throw new IllegalStateException("Could not find method \"defineClass\"", ex);
-        } catch (SecurityException ex) {
-            throw new IllegalStateException("Could not find method \"defineClass\"", ex);
-        }
-    }
-
 }

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/InheritanceLookup.java

@@ -49,20 +49,26 @@
  * @author Eric Bruneton
  * @author vsilaev
  */
-class InheritanceLookup {
+public class InheritanceLookup {
 
     private final ResourceLoader loader;
     private final Map<Key, String> lookupCache = new HashMap<Key, String>();
 
-    InheritanceLookup(ResourceLoader loader) {
+    public InheritanceLookup(ResourceLoader loader) {
         this.loader = loader;
     }
 
-    Type getCommonSuperType(Type type1, Type type2) {
-        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    public boolean isSuperClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type1.equals(commonSuperClass);
     }
 
-    String getCommonSuperClass(String type1, String type2) {
+    public boolean isSubClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type2.equals(commonSuperClass);
+    }
+
+    public String getCommonSuperClass(String type1, String type2) {
         Key key = new Key(type1, type2);
         String result;
         synchronized (lookupCache) {
@@ -75,6 +81,20 @@ String getCommonSuperClass(String type1, String type2) {
         return result;
     }
 
+    public boolean isClassAvailable(String type) {
+        try {
+            InputStream in = loader.getResourceAsStream(type + ".class");
+            try { in.close(); } catch (IOException ex) {}
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+    
+    Type getCommonSuperType(Type type1, Type type2) {
+        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    }
+    
     private String calculateCommonSuperClass(final String type1, final String type2) {
         try {
             ClassReader info1 = typeInfo(type1);

net.tascalate.javaflow.providers.asm4/src/main/java/org/apache/commons/javaflow/providers/asm4/InheritanceLookup.java

@@ -49,20 +49,26 @@
  * @author Eric Bruneton
  * @author vsilaev
  */
-class InheritanceLookup {
+public class InheritanceLookup {
 
     private final ResourceLoader loader;
     private final Map<Key, String> lookupCache = new HashMap<Key, String>();
 
-    InheritanceLookup(ResourceLoader loader) {
+    public InheritanceLookup(ResourceLoader loader) {
         this.loader = loader;
     }
 
-    Type getCommonSuperType(Type type1, Type type2) {
-        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    public boolean isSuperClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type1.equals(commonSuperClass);
     }
 
-    String getCommonSuperClass(String type1, String type2) {
+    public boolean isSubClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type2.equals(commonSuperClass);
+    }
+
+    public String getCommonSuperClass(String type1, String type2) {
         Key key = new Key(type1, type2);
         String result;
         synchronized (lookupCache) {
@@ -75,6 +81,20 @@ String getCommonSuperClass(String type1, String type2) {
         return result;
     }
 
+    public boolean isClassAvailable(String type) {
+        try {
+            InputStream in = loader.getResourceAsStream(type + ".class");
+            try { in.close(); } catch (IOException ex) {}
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+    
+    Type getCommonSuperType(Type type1, Type type2) {
+        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    }
+    
     private String calculateCommonSuperClass(final String type1, final String type2) {
         try {
             ClassReader info1 = typeInfo(type1);

net.tascalate.javaflow.providers.asm5/src/main/java/org/apache/commons/javaflow/providers/asm5/InheritanceLookup.java

@@ -49,20 +49,26 @@
  * @author Eric Bruneton
  * @author vsilaev
  */
-class InheritanceLookup {
+public class InheritanceLookup {
 
     private final ResourceLoader loader;
     private final Map<Key, String> lookupCache = new HashMap<Key, String>();
 
-    InheritanceLookup(ResourceLoader loader) {
+    public InheritanceLookup(ResourceLoader loader) {
         this.loader = loader;
     }
 
-    Type getCommonSuperType(Type type1, Type type2) {
-        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    public boolean isSuperClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type1.equals(commonSuperClass);
     }
 
-    String getCommonSuperClass(String type1, String type2) {
+    public boolean isSubClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type2.equals(commonSuperClass);
+    }
+
+    public String getCommonSuperClass(String type1, String type2) {
         Key key = new Key(type1, type2);
         String result;
         synchronized (lookupCache) {
@@ -75,6 +81,20 @@ String getCommonSuperClass(String type1, String type2) {
         return result;
     }
 
+    public boolean isClassAvailable(String type) {
+        try {
+            InputStream in = loader.getResourceAsStream(type + ".class");
+            try { in.close(); } catch (IOException ex) {}
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+    
+    Type getCommonSuperType(Type type1, Type type2) {
+        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    }
+    
     private String calculateCommonSuperClass(final String type1, final String type2) {
         try {
             ClassReader info1 = typeInfo(type1);

net.tascalate.javaflow.providers.asmx/src/main/java/org/apache/commons/javaflow/providers/asmx/InheritanceLookup.java

@@ -49,20 +49,26 @@
  * @author Eric Bruneton
  * @author vsilaev
  */
-class InheritanceLookup {
+public class InheritanceLookup {
 
     private final ResourceLoader loader;
     private final Map<Key, String> lookupCache = new HashMap<Key, String>();
 
-    InheritanceLookup(ResourceLoader loader) {
+    public InheritanceLookup(ResourceLoader loader) {
         this.loader = loader;
     }
 
-    Type getCommonSuperType(Type type1, Type type2) {
-        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    public boolean isSuperClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type1.equals(commonSuperClass);
     }
 
-    String getCommonSuperClass(String type1, String type2) {
+    public boolean isSubClass(String type1, String type2) {
+        String commonSuperClass = getCommonSuperClass(type1, type2);
+        return type2.equals(commonSuperClass);
+    }
+
+    public String getCommonSuperClass(String type1, String type2) {
         Key key = new Key(type1, type2);
         String result;
         synchronized (lookupCache) {
@@ -75,6 +81,20 @@ String getCommonSuperClass(String type1, String type2) {
         return result;
     }
 
+    public boolean isClassAvailable(String type) {
+        try {
+            InputStream in = loader.getResourceAsStream(type + ".class");
+            try { in.close(); } catch (IOException ex) {}
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+    
+    Type getCommonSuperType(Type type1, Type type2) {
+        return Type.getObjectType(getCommonSuperClass(type1.getInternalName(), type2.getInternalName()));
+    }
+    
     private String calculateCommonSuperClass(final String type1, final String type2) {
         try {
             ClassReader info1 = typeInfo(type1);

net.tascalate.javaflow.providers.asmx/src/test/java/net/tascalate/javaflow/providers/asmx/InheritanceLookupTest.java

@@ -0,0 +1,25 @@
+package net.tascalate.javaflow.providers.asmx;
+
+import static org.junit.Assert.assertTrue;
+
+import org.apache.commons.javaflow.providers.asmx.InheritanceLookup;
+import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
+import org.junit.Test;
+
+public class InheritanceLookupTest {
+
+    @Test
+    public void testInheritance() {
+        InheritanceLookup lookup = new InheritanceLookup(new ClasspathResourceLoader(ClassLoader.getSystemClassLoader()));
+        String sAbstractCollection = lookup.getCommonSuperClass("java/util/ArrayList", "java/util/HashSet");
+        assertTrue("java/util/AbstractCollection".equals(sAbstractCollection));
+        
+        String sIterable1 = lookup.getCommonSuperClass("java/util/List", "java/lang/Iterable");
+        assertTrue("java/lang/Iterable".equals(sIterable1));
+        
+        String sIterable2 = lookup.getCommonSuperClass("java/util/LinkedList", "java/lang/Iterable");
+        assertTrue("java/lang/Iterable".equals(sIterable2));
+
+    }
+    
+}