[FAB-6415] Replace org.reflections with classgraph

The org.reflections package we use for finding contract
classes does not work with Java 9+, because in Java 9+
classloaders are no longer instances of URLClassLoader.

The classgraph package is a heavily maintained, MIT licensed
package that does work with Java 9+.

Signed-off-by: Simon Stone <sstone1@uk.ibm.com>
Change-Id: I2e5938e08779607a4322446cbcb2e3263fb3ee21

Author: Simon Stone

fabric-chaincode-shim/build.gradle

@@ -18,15 +18,15 @@ tasks.withType(org.gradle.api.tasks.testing.Test) {
 test {
     // Always run tests, even when nothing changed.
     dependsOn 'cleanTest'
-    
+
     // Show test results. Potentially useful for debugging. Comment this block
     // testLogging {
     //     events "passed", "skipped", "failed"
     //     showExceptions true
     //     showCauses true
     //     showStandardStreams true
     //     exceptionFormat "full"
-        
+
     // }
 }
 
@@ -35,7 +35,7 @@ dependencies {
     compile 'io.netty:netty-tcnative-boringssl-static:2.0.25.Final'
     compile 'org.bouncycastle:bcpkix-jdk15on:1.62'
     compile 'org.bouncycastle:bcprov-jdk15on:1.62'
-    compile 'org.reflections:reflections:0.9.11'
+    compile group: 'io.github.classgraph', name: 'classgraph', version: '4.8.47'
     implementation 'com.github.everit-org.json-schema:org.everit.json.schema:1.11.1'
     compile 'io.swagger.core.v3:swagger-annotations:2.0.0'
     implementation group: 'org.json', name: 'json', version: '20180813'
@@ -94,6 +94,7 @@ jacocoTestCoverageVerification {
                         'org.hyperledger.fabric.contract.ContractRouter',
                         'org.hyperledger.fabric.contract.routing.impl.ContractDefinitionImpl',
                         'org.hyperledger.fabric.contract.routing.RoutingRegistry',
+                        'org.hyperledger.fabric.contract.routing.impl.RoutingRegistryImpl',
                         'org.hyperledger.fabric.contract.execution.impl.ContractInvocationRequest',
                         'org.hyperledger.fabric.contract.routing.TransactionType',
                         'org.hyperledger.fabric.contract.metadata.MetadataBuilder',
@@ -117,6 +118,7 @@ jacocoTestCoverageVerification {
                         'org.hyperledger.fabric.contract.execution.impl.ContractInvocationRequest',
                         'org.hyperledger.fabric.contract.routing.impl.ContractDefinitionImpl',
                         'org.hyperledger.fabric.contract.routing.RoutingRegistry',
+                        'org.hyperledger.fabric.contract.routing.impl.RoutingRegistryImpl',
                         'org.hyperledger.fabric.shim.impl.Handler',
                         'org.hyperledger.fabric.shim.ChaincodeBase',
                         'org.hyperledger.fabric.contract.metadata.MetadataBuilder',

fabric-chaincode-shim/src/main/java/org/hyperledger/fabric/contract/routing/impl/RoutingRegistryImpl.java

@@ -6,13 +6,11 @@
 package org.hyperledger.fabric.contract.routing.impl;
 
 import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.logging.Logger;
@@ -27,9 +25,10 @@
 import org.hyperledger.fabric.contract.routing.RoutingRegistry;
 import org.hyperledger.fabric.contract.routing.TxFunction;
 import org.hyperledger.fabric.contract.routing.TypeRegistry;
-import org.reflections.Reflections;
-import org.reflections.util.ClasspathHelper;
-import org.reflections.util.ConfigurationBuilder;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.ScanResult;
 
 /**
  * Registry to hold permit access to the routing definitions. This is the
@@ -143,61 +142,80 @@ public Collection<ContractDefinition> getAllDefinitions() {
      */
     @SuppressWarnings("unchecked")
     @Override
-    public void findAndSetContracts(final TypeRegistry typeRegistry) {
-        final ArrayList<URL> urls = new ArrayList<>();
-        final ClassLoader[] classloaders = { getClass().getClassLoader(),
-                Thread.currentThread().getContextClassLoader() };
-        for (int i = 0; i < classloaders.length; i++) {
-            if (classloaders[i] instanceof URLClassLoader) {
-                urls.addAll(Arrays.asList(((URLClassLoader) classloaders[i]).getURLs()));
-            } else {
-                throw new RuntimeException("classLoader is not an instanceof URLClassLoader");
+    public void findAndSetContracts(TypeRegistry typeRegistry) {
+
+        // Find all classes that are valid contract or data type instances.
+        ClassGraph classGraph = new ClassGraph()
+            .enableClassInfo()
+            .enableAnnotationInfo();
+        List<Class<ContractInterface>> contractClasses = new ArrayList<>();
+        List<Class<?>> dataTypeClasses = new ArrayList<>();
+        try (ScanResult scanResult = classGraph.scan()) {
+            for (ClassInfo classInfo : scanResult.getClassesWithAnnotation(Contract.class.getCanonicalName())) {
+                logger.fine("Found class with contract annotation: " + classInfo.getName());
+                try {
+                    Class<?> contractClass = classInfo.loadClass();
+                    logger.fine("Loaded class");
+                    Contract annotation = contractClass.getAnnotation(Contract.class);
+                    if (annotation == null) {
+                        // Since we check by name above, it makes sense to check it's actually compatible,
+                        // and not some random class with the same name.
+                        logger.fine("Class does not have compatible contract annotation");
+                    } else if (!ContractInterface.class.isAssignableFrom(contractClass)) {
+                        logger.fine("Class is not assignable from ContractInterface");
+                    } else {
+                        logger.fine("Class is assignable from ContractInterface");
+                        contractClasses.add((Class<ContractInterface>) contractClass);
+                    }
+                } catch (IllegalArgumentException e) {
+                    logger.fine("Failed to load class: " + e);
+                }
+            }
+            for (ClassInfo classInfo : scanResult.getClassesWithAnnotation(DataType.class.getCanonicalName())) {
+                logger.fine("Found class with data type annotation: " + classInfo.getName());
+                try {
+                    Class<?> dataTypeClass = classInfo.loadClass();
+                    logger.fine("Loaded class");
+                    DataType annotation = dataTypeClass.getAnnotation(DataType.class);
+                    if (annotation == null) {
+                        // Since we check by name above, it makes sense to check it's actually compatible,
+                        // and not some random class with the same name.
+                        logger.fine("Class does not have compatible data type annotation");
+                    } else {
+                        logger.fine("Class has compatible data type annotation");
+                        dataTypeClasses.add(dataTypeClass);
+                    }
+                } catch (IllegalArgumentException e) {
+                    logger.fine("Failed to load class: " + e);
+                }
             }
         }
 
-        final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
-        configurationBuilder.addUrls(urls);
-        configurationBuilder.addUrls(ClasspathHelper.forJavaClassPath());
-        configurationBuilder.addUrls(ClasspathHelper.forManifest());
-        final Reflections ref = new Reflections(configurationBuilder);
-
-        logger.info("Searching chaincode class in urls: " + configurationBuilder.getUrls());
-
         // set to ensure that we don't scan the same class twice
         final Set<String> seenClass = new HashSet<>();
 
         // loop over all the classes that have the Contract annotation
-        for (final Class<?> cl : ref.getTypesAnnotatedWith(Contract.class)) {
-            logger.info("Found class: " + cl.getCanonicalName());
-            if (ContractInterface.class.isAssignableFrom(cl)) {
-                logger.fine("Inheritance ok");
-                final String className = cl.getCanonicalName();
-
-                if (!seenClass.contains(className)) {
-                    final ContractDefinition contract = addNewContract((Class<ContractInterface>) cl);
+        for (Class<ContractInterface> contractClass : contractClasses) {
+            String className = contractClass.getCanonicalName();
+            if (!seenClass.contains(className)) {
+                ContractDefinition contract = addNewContract((Class<ContractInterface>) contractClass);
 
-                    logger.fine("Searching annotated methods");
-                    for (final Method m : cl.getMethods()) {
-                        if (m.getAnnotation(Transaction.class) != null) {
-                            logger.fine("Found annotated method " + m.getName());
+                logger.fine("Searching annotated methods");
+                for (Method m : contractClass.getMethods()) {
+                    if (m.getAnnotation(Transaction.class) != null) {
+                        logger.fine("Found annotated method " + m.getName());
 
-                            contract.addTxFunction(m);
+                        contract.addTxFunction(m);
 
-                        }
                     }
-
-                    seenClass.add(className);
                 }
-            } else {
-                logger.fine("Class is not assignabled from Contract");
+
+                seenClass.add(className);
             }
         }
 
         // now need to look for the data types have been set with the
-        logger.info("Looking for the data types");
-        final Set<Class<?>> czs = ref.getTypesAnnotatedWith(DataType.class);
-        logger.info("found " + czs.size());
-        czs.forEach(typeRegistry::addDataType);
+        dataTypeClasses.forEach(typeRegistry::addDataType);
 
     }