use standard lib component to discover classes on the boot classpath

Author: epickrram

affinity/src/main/java/net/openhft/affinity/BootClassPath.java

@@ -19,41 +19,97 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import sun.misc.URLClassPath;
 
-import java.io.File;
-import java.net.MalformedURLException;
-import java.net.URL;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
 
 enum BootClassPath {
     INSTANCE;
 
-    private final URLClassPath bootClassPath = new URLClassPath(getBootClassPathURLs());
+    private final Set<String> bootClassPathResources = Collections.unmodifiableSet(getResourcesOnBootClasspath());
 
     public final boolean has(String binaryClassName) {
-        String resourceClassName = binaryClassName.replace('.', '/').concat(".class");
-        return bootClassPath.getResource(resourceClassName, false) != null;
+        final String resourceClassName = binaryClassName.replace('.', '/').concat(".class");
+        return bootClassPathResources.contains(resourceClassName);
     }
 
-    private URL[] getBootClassPathURLs() {
-        Logger LOGGER = LoggerFactory.getLogger(BootClassPath.class);
-        try {
-            String bootClassPath = System.getProperty("sun.boot.class.path");
-            LOGGER.trace("Boot class-path is: {}", bootClassPath);
+    private static Set<String> getResourcesOnBootClasspath() {
+        final Logger logger = LoggerFactory.getLogger(BootClassPath.class);
+        final Set<String> resources = new HashSet<>();
+        final String bootClassPath = System.getProperty("sun.boot.class.path");
+        logger.trace("Boot class-path is: {}", bootClassPath);
+
+        final String pathSeparator = System.getProperty("path.separator");
+        logger.trace("Path separator is: '{}'", pathSeparator);
+
+        final String[] pathElements = bootClassPath.split(pathSeparator);
+
+        for (final String pathElement : pathElements) {
+            resources.addAll(findResources(Paths.get(pathElement), logger));
+        }
+
+        return resources;
+    }
+
+    private static Set<String> findResources(final Path path, final Logger logger) {
+        if (!Files.exists(path)) {
+            return Collections.emptySet();
+        }
+
+        if (Files.isDirectory(path)) {
+            return findResourcesInDirectory(path, logger);
+        }
 
-            String pathSeparator = System.getProperty("path.separator");
-            LOGGER.trace("Path separator is: '{}'", pathSeparator);
+        return findResourcesInJar(path, logger);
+    }
 
-            String[] pathElements = bootClassPath.split(pathSeparator);
-            URL[] pathURLs = new URL[pathElements.length];
-            for (int i = 0; i < pathElements.length; i++) {
-                pathURLs[i] = new File(pathElements[i]).toURI().toURL();
+    private static Set<String> findResourcesInJar(final Path path, final Logger logger) {
+        final Set<String> jarResources = new HashSet<>();
+        try {
+            final JarFile jarFile = new JarFile(path.toFile());
+            final Enumeration<JarEntry> entries = jarFile.entries();
+            while (entries.hasMoreElements()) {
+                final JarEntry jarEntry = entries.nextElement();
+                if (jarEntry.getName().endsWith(".class")) {
+                    jarResources.add(jarEntry.getName());
+                }
             }
 
-            return pathURLs;
-        } catch (MalformedURLException e) {
-            LOGGER.warn("Parsing the boot class-path failed! Reason: {}", e.getMessage());
-            return new URL[0];
+
+        } catch (IOException e) {
+            logger.warn("Not a jar file: {}", path);
+        }
+
+        return jarResources;
+    }
+
+    private static Set<String> findResourcesInDirectory(final Path path, final Logger logger) {
+        final Set<String> dirResources = new HashSet<>();
+        try {
+            Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+                    if (file.getFileName().toString().endsWith(".class")) {
+                        dirResources.add(path.relativize(file).toString());
+                    }
+                    return super.visitFile(file, attrs);
+                }
+            });
+        } catch (IOException e) {
+            logger.warn("Error walking dir: " + path, e);
         }
+
+        return dirResources;
     }
 }

affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java

@@ -0,0 +1,13 @@
+package net.openhft.affinity;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class BootClassPathTest {
+    @Test
+    public void shouldDetectClassesOnClassPath() throws Exception {
+        assertTrue(BootClassPath.INSTANCE.has("java.lang.Thread"));
+        assertTrue(BootClassPath.INSTANCE.has("java.lang.Runtime"));
+    }
+}