Refactor irrelevant code from ClasspathResourceLoader to InstrumentationUtils

Author: vsilaev

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

@@ -75,32 +75,4 @@ public ClassMatcher createVeto() throws IOException {
         }
         return matchers.isEmpty() ? ClassMatchers.MATCH_NONE : ClassMatchers.whenAny(matchers);
     }
-    
-    public static String packageNameOfClass(Class<?> clazz) {
-        String className = clazz.getName();
-        int lastDot = className.lastIndexOf('.');
-        if (lastDot > 0) {
-            return className.substring(0, lastDot);
-        } else {
-            return null;
-        }
-    }
-    
-    /**
-     * Check if <code>maybeParent</code> is a parent (probably inderect) of the <code>classLoader</code>
-     * @param classLoader The classloader whose parents are checked, may not be null
-     * @param maybeParent Possible parent, may be null for boot class loader
-     * @return
-     */
-    public static boolean isClassLoaderParent(ClassLoader classLoader, ClassLoader maybeParent) {
-        ClassLoader cl = classLoader;
-        do {
-            cl = cl.getParent();
-            if (maybeParent == cl) {
-                // Check includes null == null for bootstrap classloader
-                return true;
-            }
-        } while (cl != null);
-        return false;
-    }
 }

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

@@ -0,0 +1,69 @@
+/**
+ * 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.spi;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public final class InstrumentationUtils {
+    
+    private InstrumentationUtils() {}
+    
+    public static String packageNameOf(Class<?> clazz) {
+        String className = clazz.getName();
+        int lastDot = className.lastIndexOf('.');
+        if (lastDot > 0) {
+            return className.substring(0, lastDot);
+        } else {
+            return null;
+        }
+    }
+    
+    public static Set<String> packagePrefixesOf(Class<?>... classes) {
+        Set<String> packagePrefixes = new HashSet<String>();
+        for (Class<?> clazz : classes) {
+            packagePrefixes.add( packageNameOf(clazz) + '.');
+        }    
+        return packagePrefixes;
+    }
+    
+    /**
+     * Check if <code>maybeParent</code> is a parent (probably inderect) of the <code>classLoader</code>
+     * @param classLoader The classloader whose parents are checked, may not be null
+     * @param maybeParent Possible parent, may be null for boot class loader
+     * @return
+     */
+    public static boolean isClassLoaderParent(ClassLoader classLoader, ClassLoader maybeParent) {
+        ClassLoader cl = classLoader;
+        do {
+            cl = cl.getParent();
+            if (maybeParent == cl) {
+                // Check includes null == null for bootstrap classloader
+                return true;
+            }
+        } while (cl != null);
+        return false;
+    }
+    
+}

net.tascalate.javaflow.tools.instrument/src/main/java/org/apache/commons/javaflow/instrumentation/common/AbstractInstrumentationAgent.java

@@ -15,17 +15,21 @@
  */
 package org.apache.commons.javaflow.instrumentation.common;
 
+import static org.apache.commons.javaflow.spi.InstrumentationUtils.isClassLoaderParent;
+import static org.apache.commons.javaflow.spi.InstrumentationUtils.packageNameOf;
+import static org.apache.commons.javaflow.spi.InstrumentationUtils.packagePrefixesOf;
+
 import java.lang.instrument.ClassFileTransformer;
 import java.lang.instrument.Instrumentation;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
+import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
 
 public abstract class AbstractInstrumentationAgent {
 
@@ -45,7 +49,7 @@ protected void attach(String args, Instrumentation instrumentation) throws Excep
 
         // Collect classes before ever adding transformer!
         Set<String> ownPackages = new HashSet<String>(FIXED_OWN_PACKAGES);
-        ownPackages.add(ClasspathResourceLoader.packageNameOfClass(getClass()) + '.');
+        ownPackages.add(packageNameOf(getClass()) + '.');
 
         ClassFileTransformer transformer = createTransformer();
         instrumentation.addTransformer(transformer);
@@ -67,7 +71,7 @@ protected void retransformClasses(Instrumentation instrumentation, Set<String> o
         for (Class<?> clazz : instrumentation.getAllLoadedClasses()) {
             String className = clazz.getName();
             if (instrumentation.isModifiableClass(clazz)) {
-                if (ClasspathResourceLoader.isClassLoaderParent(systemClassLoader, clazz.getClassLoader())) {
+                if (isClassLoaderParent(systemClassLoader, clazz.getClassLoader())) {
                     if (log.isTraceEnabled()) {
                         log.trace("Skip re-transforming boot or extension/platform class: " + className);
                     }
@@ -108,18 +112,11 @@ protected void retransformClasses(Instrumentation instrumentation, Set<String> o
 
     protected abstract ClassFileTransformer createTransformer();
 
-    private static final Collection<String> FIXED_OWN_PACKAGES;
-    static {
-        Class<?>[] sampleClasses = {
-                Logger.class, 
-                ClasspathResourceLoader.class, 
-                AbstractInstrumentationAgent.class
-            };
-        
-        Set<String> fixedOwnPackages = new HashSet<String>();
-        for (Class<?> sampleClass : sampleClasses) {
-            fixedOwnPackages.add(ClasspathResourceLoader.packageNameOfClass(sampleClass) + '.');
-        }
-        FIXED_OWN_PACKAGES = Collections.unmodifiableSet(fixedOwnPackages);
-    }
+    private static final Collection<String> FIXED_OWN_PACKAGES = Collections.unmodifiableSet(
+        packagePrefixesOf(
+            Logger.class, 
+            ClasspathResourceLoader.class, 
+            AbstractInstrumentationAgent.class
+        )
+    );
 }

net.tascalate.javaflow.tools.instrument/src/main/java/org/apache/commons/javaflow/instrumentation/common/ConfigurableClassFileTransformer.java

@@ -21,8 +21,10 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.apache.commons.javaflow.spi.Cache;
 import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
+import org.apache.commons.javaflow.spi.InstrumentationUtils;
 import org.apache.commons.javaflow.spi.MorphingResourceLoader;
 import org.apache.commons.javaflow.spi.ResourceTransformationFactory;
 import org.apache.commons.javaflow.spi.ResourceTransformer;
@@ -104,7 +106,7 @@ protected ClassLoader getSafeClassLoader(ClassLoader classLoader) {
     }
 
     private boolean isSystemClassLoaderParent(ClassLoader maybeParent) {
-        return ClasspathResourceLoader.isClassLoaderParent(systemClassLoader, maybeParent);
+        return InstrumentationUtils.isClassLoaderParent(systemClassLoader, maybeParent);
     }
 
     private String resolveClassName(String className,

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

@@ -31,7 +31,7 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
+import org.apache.commons.javaflow.spi.InstrumentationUtils;
 import org.apache.commons.javaflow.spi.ResourceTransformationFactory;
 
 public final class ApplicationWeaver {
@@ -161,7 +161,7 @@ private static boolean _trampoline(ResourceTransformationFactory factory,
                 Set<String> filteredPackageRoots = new HashSet<String>(continuablePackageRoots);
                 for (String s : filteredPackageRoots) {
                     if ("*".equals(s)) {
-                        s = ClasspathResourceLoader.packageNameOfClass(originalClass);
+                        s = InstrumentationUtils.packageNameOf(originalClass);
                     }
                     builder.addLoaderPackageRoot(s);
                 }

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

@@ -35,15 +35,14 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import org.apache.commons.javaflow.spi.ClasspathResourceLoader;
 import org.apache.commons.javaflow.spi.FastByteArrayOutputStream;
+import org.apache.commons.javaflow.spi.InstrumentationUtils;
 import org.apache.commons.javaflow.spi.MorphingResourceLoader;
 import org.apache.commons.javaflow.spi.ResourceTransformationFactory;
 import org.apache.commons.javaflow.spi.ResourceTransformer;
@@ -675,18 +674,11 @@ private static boolean findInPackages(String resourceName, Collection<String> su
         return false;
     }
 
-    private static Collection<String> OWN_PACKAGES;
-    static {
-        Class<?>[] ownClasses = {
+    private static Collection<String> OWN_PACKAGES = Collections.unmodifiableSet(
+        InstrumentationUtils.packagePrefixesOf(
             ContinuableClassLoader.class,
             ResourceTransformer.class,
             Logger.class
-        };
-        
-        Set<String> ownPackages = new HashSet<String>();
-        for (Class<?> cls : ownClasses) {
-            ownPackages.add( ClasspathResourceLoader.packageNameOfClass(cls) + '.');
-        }
-        OWN_PACKAGES = Collections.unmodifiableSet(ownPackages);
-    }
+        )
+    );
 }