org.reflections.vfs.Vfs Java Examples

@Override
public Vfs.Dir createDir(final URL url) throws Exception {
    URLConnection urlConnection = url.openConnection();
    Class<?> theClass = warURLConnectionClass.get();
    if (urlConnection.getClass().equals(theClass)) {
        Object wrappedJarUrlConnection = getValue(
                makeAccessible(
                        theClass.getDeclaredField("wrappedJarUrlConnection")
                ),
                urlConnection
        );
        if (wrappedJarUrlConnection instanceof JarURLConnection) {
            return new ZipDir(((JarURLConnection) wrappedJarUrlConnection).getJarFile());
        }
    }
    return null;
}
 

@Test
public void directory_traversal_is_working() throws Exception {
    JndiInputDir jndiInputDir = new JndiInputDir(goodURL);

    List<String> names = Lists.newArrayList();
    List<String> paths = Lists.newArrayList();

    for (Vfs.File file : jndiInputDir.getFiles()) {
        names.add(file.getName());
        paths.add(file.getRelativePath());

        if (file.getName().equals("AAA")) {
            assertThat(file.openInputStream()).isEqualTo(aaaInputStream);
        } else if (file.getName().equals("AB")) {
            assertThat(file.openInputStream()).isEqualTo(abInputStream);
        } else {
            fail("unexpected file " + file.getName());
        }
    }

    assertThat(names).isEqualTo(Lists.newArrayList("AAA", "AB"));
    assertThat(paths).isEqualTo(Lists.newArrayList("A/AA/AAA", "A/AB"));

    jndiInputDir.close();
}
 

private KernelManager() {
    // Load Nuun and Reflections classes to force initialization of Vfs url types
    try {
        Class.forName(Vfs.class.getCanonicalName());
        Class.forName(AbstractClasspathScanner.class.getCanonicalName());
    } catch (ClassNotFoundException e) {
        throw new RuntimeException("Cannot initialize the classpath scanning infrastructure", e);
    }

    // Save existing url types
    savedUrlTypes = Vfs.getDefaultUrlTypes();

    // Find all classpath scan handlers and add their Vfs url types
    List<Vfs.UrlType> urlTypes = new ArrayList<>();
    for (ClasspathScanHandler classpathScanHandler : ServiceLoader.load(ClasspathScanHandler.class)) {
        LOGGER.debug("Classpath handler {} detected", classpathScanHandler.getClass().getCanonicalName());
        urlTypes.addAll(classpathScanHandler.urlTypes());
    }
    LOGGER.debug("Supported URL types for scanning: {}", urlTypes);
    detectedUrlTypes = urlTypes;
}
 

@Override
public Vfs.Dir createDir(final URL url) {
    return new Vfs.Dir() {

        @Override
        public String getPath() {
            return url.getPath();
        }

        @Override
        public Iterable<Vfs.File> getFiles() {
            failedUrls.add(url.toExternalForm());
            return new ArrayList<>();
        }

        @Override
        public void close() {
            // nothing to do
        }
    };
}
 

@Override
public List<Vfs.UrlType> urlTypes() {
    return Lists.newArrayList(
            new TomcatWarFileUrlType(),
            new TomcatJndiJarUrlType(),
            new TomcatJndiFileUrlType()
    );
}
 

@Test
public void testUrlTypes(@SuppressWarnings("unused") @Mocked final WsInputDir wsInputDir) throws Exception {
    WebsphereClasspathScanHandler handler = new WebsphereClasspathScanHandler();
    List<Vfs.UrlType> list = handler.urlTypes();
    Assertions.assertThat(list.size()).isEqualTo(1);
    Vfs.UrlType urlType = list.get(0);

    URLStreamHandler goodStubUrlHandler = new URLStreamHandler() {
        @Override
        protected URLConnection openConnection(URL u) {
            return null;
        }
    };

    final URL warURL = new URL("wsjar", "", -1, "file:C/test.war", goodStubUrlHandler);
    final URL warJarURL = new URL("wsjar", "", -1, "file:C/test.war!test.jar", goodStubUrlHandler);
    final URL badURL = new URL("jar", "", -1, "file:C/test.war");
    Assertions.assertThat(urlType.matches(warURL)).isTrue();
    Assertions.assertThat(urlType.matches(badURL)).isFalse();
    Assertions.assertThat(urlType.matches(warJarURL)).isFalse();

    urlType.createDir(warURL);
    new Verifications() {
        {
            new WsInputDir(warURL);
            times = 1;
        }
    };
}
 

private synchronized Kernel createKernel(KernelConfiguration kernelConfiguration,
        DiagnosticManager diagnosticManager) {
    // Kernel instantiation
    Kernel kernel = NuunCore.createKernel(kernelConfiguration);
    FallbackUrlType fallbackUrlType = new FallbackUrlType();
    List<Vfs.UrlType> urlTypes = new ArrayList<>(detectedUrlTypes);
    urlTypes.add(fallbackUrlType);

    // Kernel initialization (it is assumed that only this class alter Vfs default url types)
    Vfs.setDefaultURLTypes(urlTypes);
    kernel.init();
    Vfs.setDefaultURLTypes(savedUrlTypes);

    // Log if any URL were not scanned
    int failedUrlCount = fallbackUrlType.getFailedUrls().size();
    if (failedUrlCount > 0) {
        for (String failedUrl : fallbackUrlType.getFailedUrls()) {
            LOGGER.warn("Could not scan URL: {}", failedUrl);
        }
    }

    diagnosticManager.registerDiagnosticInfoCollector("kernel", () -> {
        Map<String, Object> result = new HashMap<>();
        result.put("scannedUrls", kernel.scannedURLs());
        result.put("failedUrls", fallbackUrlType.getFailedUrls());
        return result;
    });

    return kernel;
}
 

@Override
public List<Vfs.UrlType> urlTypes() {
    return Lists.newArrayList(
            Vfs.DefaultUrlTypes.jarFile,
            Vfs.DefaultUrlTypes.jarUrl,
            Vfs.DefaultUrlTypes.directory,
            Vfs.DefaultUrlTypes.jarInputStream
    );
}
 

@Override
public Vfs.Dir createDir(final URL url) {
    return new JndiJarInputDir(url);
}
 

@Override
public Vfs.Dir createDir(final URL url) {
    return new JndiInputDir(url);
}
 

@Override
public List<Vfs.UrlType> urlTypes() {
    return Lists.newArrayList(new WebSphereJarUrlType());
}
 

@Override
public Vfs.Dir createDir(final URL url) {
    return new WsInputDir(url);
}
 

/**
 * @return the list of supported {@link Vfs.UrlType}.
 */
List<Vfs.UrlType> urlTypes();