Fix error in FastByteArrayOutputStream; fix ContinuableClassLoader to avoid load platform classes and own classes (SPI + tools); creating proto of application trampoline

Author: vsilaev

net.tascalate.javaflow.spi/src/main/java/org/apache/commons/javaflow/spi/FastByteArrayOutputStream.java

@@ -18,7 +18,6 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
-import java.util.Arrays;
 
 public class FastByteArrayOutputStream extends OutputStream {
 
@@ -103,11 +102,17 @@ public void reset() {
      * @return  the current contents of this output stream, as a byte array.
      */    
     public byte[] toByteArray() {
-        return buf.clone();
+        byte[] result = new byte[count];
+        System.arraycopy(buf, 0, result, 0, count);
+        return result;
     }
 
     public byte[] unsafeBytes() {
-        return buf;
+        if (count == buf.length) {
+            return buf;
+        } else {
+            return toByteArray();
+        }
     }
 
     /**
@@ -186,7 +191,10 @@ private void grow(int minCapacity) {
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
-        buf = Arrays.copyOf(buf, newCapacity);
+        
+        byte[] newBuf = new byte[newCapacity];
+        System.arraycopy(buf, 0, newBuf, 0, count);
+        buf = newBuf;
     }
 
     private static int hugeCapacity(int minCapacity) {

net.tascalate.javaflow.tools.runtime/src/main/java/org/apache/commons/javaflow/tools/runtime/ApplicationLoader.java

@@ -0,0 +1,90 @@
+/**
+ * Original work: copyright 1999-2004 The Apache Software Foundation
+ * (http://www.apache.org/)
+ *
+ * This project is based on the work licensed to the Apache Software
+ * Foundation (ASF) under one or more contributor license agreements.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Modified work: 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.tools.runtime;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+import org.apache.commons.javaflow.spi.ResourceTransformationFactory;
+
+public final class ApplicationLoader {
+    private ApplicationLoader() {}
+    
+    public static boolean trampoline(ResourceTransformationFactory factory, Object source, String...args) {
+        StackTraceElement ste = new Exception().getStackTrace()[1];
+        Class<?> clazz;
+        ClassLoader originalLoader;
+        
+        if (null == source) {
+            clazz = null;
+            originalLoader = Thread.currentThread().getContextClassLoader();
+            if (null == originalLoader) {
+                originalLoader = ClassLoader.getSystemClassLoader();
+            }
+        } else if (source instanceof Class) {
+            clazz = (Class<?>)source;
+            originalLoader = clazz.getClassLoader();
+        } else {
+            clazz = source.getClass();
+            originalLoader = clazz.getClassLoader();
+        }
+                
+        if (originalLoader instanceof ContinuableClassLoader)
+            return false;
+
+        try {
+            try {
+                Class<?> check = null != clazz ? clazz : originalLoader.loadClass(ste.getClassName());
+                for (Annotation a : check.getAnnotations()) {
+                    if ("org.apache.commons.javaflow.core.Skip".equals(a.getClass().getName())) {
+                        return false;
+                    }
+                }
+            } catch (ClassNotFoundException ex) {
+            }
+            
+            ContinuableClassLoader loader = new ContinuableClassLoader.Builder(factory)
+                                                                      .parent(originalLoader)
+                                                                      .parentFirst(false)
+                                                                      //.addLoaderPackageRoot(clazz.getPackage().getName())
+                                                                      .create();
+            
+            run(loader, ste.getClassName(), ste.getMethodName(), args);
+        }
+        catch (RuntimeException ex) { 
+            throw ex; 
+        }
+        catch (Exception ex) { 
+            throw new RuntimeException(ex); 
+        }
+        return true;
+    }
+    
+    private static void run(ContinuableClassLoader classLoader, String className, String method, String... args) throws Exception {
+        Class<?> mainClass = classLoader.forceLoadClass(className);
+        Method mainMethod = mainClass.getMethod(method, String[].class);
+        mainMethod.invoke(null, new Object[] {args});
+    }
+
+}

net.tascalate.javaflow.tools.runtime/src/main/java/org/apache/commons/javaflow/tools/runtime/ContinuableClassLoader.java

@@ -182,7 +182,7 @@ public static class Builder extends AbstractBuilder<ContinuableClassLoader, Buil
          *            resolver/transformer to perform the byte-code enhancement.
          *            May not be null.
          */
-        Builder(ResourceTransformationFactory transformationFactory) {
+        public Builder(ResourceTransformationFactory transformationFactory) {
             super(transformationFactory);
         }
 
@@ -227,6 +227,8 @@ public ContinuableClassLoader create() {
 
     /* The context to be used when loading classes and resources */
     protected final AccessControlContext acc;
+    
+    protected final ClassLoader platformClassLoader;
 
     /**
      * Creates a classloader to define classes dynamically.
@@ -292,6 +294,8 @@ public ContinuableClassLoader(ClassLoader parent,
         this.isolated = isolated;
         this.systemPackages = dotEndingPackageNames(systemPackages);
         this.loaderPackages = dotEndingPackageNames(loaderPackages);
+        
+        this.platformClassLoader = ClassLoader.getSystemClassLoader().getParent();
     }
 
     public static Builder builder(ResourceTransformationFactory transformationFactory) {
@@ -346,6 +350,15 @@ private boolean isParentFirst(String resourceName) {
         // designated to use a specific loader first
         // (this one or the parent one)
 
+        if (resourceName.startsWith("org.apache.commons.javaflow.tools.runtime.") || 
+            resourceName.startsWith("org.apache.commons.javaflow.spi.")) {
+            return true;
+        }
+        
+//        if (resourceName.startsWith("org.apache.commons.javaflow.") && !resourceName.startsWith("org.apache.commons.javaflow.examples.")) {
+//            return true;
+//        }
+        
         boolean useParentFirst = parentFirst;
 
         for (String packageName : systemPackages) {
@@ -400,24 +413,41 @@ protected Class<?> loadClass(String className, boolean resolve) throws ClassNotF
                 return theClass;
             }
 
+            ClassLoader parentClassLoader = getParent();
+            if (null == parentClassLoader) {
+                parentClassLoader = platformClassLoader;
+            }
+            
             if (isParentFirst(className)) {
                 try {
-                    theClass = getParent().loadClass(className);
+                    theClass = parentClassLoader.loadClass(className);
                     log.debug("Class " + className + " loaded from parent loader " + "(parentFirst)");
                 } catch (ClassNotFoundException cnfe) {
                     theClass = findClass(className);
                     log.debug("Class " + className + " loaded from own loader " + "(parentFirst)");
                 }
             } else {
-                try {
-                    theClass = findClass(className);
-                    log.debug("Class " + className + " loaded from own loader");
-                } catch (ClassNotFoundException cnfe) {
-                    if (isolated) {
-                        throw cnfe;
+                // It's an error to load anything from platform
+                if (null != platformClassLoader) {
+                    try {
+                        theClass = platformClassLoader.loadClass(className); 
+                        log.debug("Class " + className + " is platform class");
+                    } catch (ClassNotFoundException ex) {
+                        log.debug("Class " + className + " is not visible to platform, will try to load on own loader");
+                    }
+                }
+                // Not found among platform classes
+                if (null == theClass) {
+                    try {
+                        theClass = findClass(className);
+                        log.debug("Class " + className + " loaded from own loader");
+                    } catch (ClassNotFoundException cnfe) {
+                        if (isolated) {
+                            throw cnfe;
+                        }
+                        theClass = parentClassLoader.loadClass(className);
+                        log.debug("Class " + className + " loaded from parent loader");
                     }
-                    theClass = getParent().loadClass(className);
-                    log.debug("Class " + className + " loaded from parent loader");
                 }
             }
 
@@ -463,7 +493,7 @@ public Class<?> run() {
                 int i = classNameFromData.lastIndexOf('.');
                 if (i > 0) {
                     final String packageName = classNameFromData.substring(0, i);
-                    @SuppressWarnings("deprecation")
+                    @SuppressWarnings("all")
                     final Package pkg = getPackage(packageName);
                     if (pkg == null) {
                         definePackage(packageName, null, null, null, null, null, null, null);
@@ -508,17 +538,16 @@ public Class<?> run() {
      *                from the stream.
      */
     private Class<?> getClassFromStream(InputStream stream, String className) throws IOException, SecurityException {
-
-        FastByteArrayOutputStream baos = new FastByteArrayOutputStream();
+        FastByteArrayOutputStream baos = new FastByteArrayOutputStream(BUFFER_SIZE);
         try {
 
             int bytesRead;
             byte[] buffer = new byte[BUFFER_SIZE];
 
-            while ((bytesRead = stream.read(buffer, 0, BUFFER_SIZE)) != -1) {
+            while ((bytesRead = stream.read(buffer, 0, BUFFER_SIZE)) > 0) {
                 baos.write(buffer, 0, bytesRead);
             }
-
+            
             byte[] classData = baos.unsafeBytes();
             return defineClassFromData(classData, className);