Use SPI to inject MemoryFileSystem URL protocol support

Author: ascopes

java-compiler-testing/src/main/java/io/github/ascopes/jct/workspaces/impl/MemoryFileSystemProvider.java

@@ -16,9 +16,12 @@
 package io.github.ascopes.jct.workspaces.impl;
 
 import com.github.marschall.memoryfilesystem.MemoryFileSystemBuilder;
+import com.github.marschall.memoryfilesystem.memory.MemoryURLStreamHandlerFactory;
 import io.github.ascopes.jct.workspaces.RamFileSystemProvider;
 import java.io.IOException;
 import java.io.UncheckedIOException;
+import java.net.URLStreamHandler;
+import java.net.spi.URLStreamHandlerProvider;
 import java.nio.file.FileSystem;
 import org.apiguardian.api.API;
 import org.apiguardian.api.API.Status;
@@ -63,4 +66,36 @@ public FileSystem createFileSystem(String name) {
       throw new UncheckedIOException("could not create file system with name: " + name, e);
     }
   }
+
+  /**
+   * Java 9 SPI-based provider handler to register the URL protocol handler for the MemoryFileSystem
+   * API implicitly at runtime. This enables URL resolution to work correctly, which is needed to
+   * support {@link java.net.URLClassLoader} elsewhere.
+   *
+   * <p>Internally, this just adapts a {@link MemoryURLStreamHandlerFactory} into a
+   * {@link URLStreamHandlerProvider} so that the JPMS SPI mechanism can load this provider eagerly
+   * as soon as possible without needing to use JVM flags or call explicit methods during
+   * classloading.
+   *
+   * @author Ashley Scopes
+   * @since 0.7.0
+   */
+  @API(since = "0.7.0", status = Status.INTERNAL)
+  public static final class MemoryFileSystemUrlHandlerProvider extends URLStreamHandlerProvider {
+
+    private final MemoryURLStreamHandlerFactory factory;
+
+    public MemoryFileSystemUrlHandlerProvider() {
+      factory = new MemoryURLStreamHandlerFactory();
+    }
+
+    @Override
+    public URLStreamHandler createURLStreamHandler(String protocol) {
+      // This check can be removed once https://github.com/marschall/memoryfilesystem/pull/144 is
+      // addressed.
+      return com.github.marschall.memoryfilesystem.MemoryFileSystemProvider.SCHEME.equals(protocol)
+          ? factory.createURLStreamHandler(protocol)
+          : null;
+    }
+  }
 }

java-compiler-testing/src/main/java/module-info.java

@@ -15,7 +15,9 @@
  */
 import io.github.ascopes.jct.junit.JctExtension;
 import io.github.ascopes.jct.workspaces.RamFileSystemProvider;
+import io.github.ascopes.jct.workspaces.impl.MemoryFileSystemProvider.MemoryFileSystemUrlHandlerProvider;
 import org.junit.jupiter.api.extension.Extension;
+import java.net.spi.URLStreamHandlerProvider;
 
 /**
  * A framework for performing exhaustive integration testing against Java compilers in modern Java
@@ -133,7 +135,7 @@
   /// SERVICE PROVIDER INTERFACES ///
   ///////////////////////////////////
 
-  provides Extension with JctExtension;
+  provides URLStreamHandlerProvider with MemoryFileSystemUrlHandlerProvider;
   uses RamFileSystemProvider;
 
   //////////////////////////////////////////////////////

java-compiler-testing/src/test/java/io/github/ascopes/jct/tests/unit/workspaces/impl/MemoryFileSystemProviderImplTest.java

@@ -18,19 +18,28 @@
 import static io.github.ascopes.jct.tests.helpers.Fixtures.someText;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import com.github.marschall.memoryfilesystem.memory.Handler;
 import io.github.ascopes.jct.workspaces.impl.MemoryFileSystemProvider;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.spi.URLStreamHandlerProvider;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
+import java.util.ServiceLoader;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import io.github.ascopes.jct.workspaces.impl.MemoryFileSystemProvider.MemoryFileSystemUrlHandlerProvider;
 import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 
 /**
@@ -194,4 +203,63 @@ void theCreatedFileSystemSupportsUrls() throws IOException {
       }
     }
   }
+
+  @DisplayName("MemoryFileSystemUrlHandlerProvider tests")
+  @Nested
+  class MemoryFileSystemUrlHandlerProviderTest {
+
+    @DisplayName("The provider is registered as SPI in the module descriptor")
+    @Test
+    void providerIsRegisteredAsSpiInModuleDescriptor() {
+      // Given
+      var module = MemoryFileSystemUrlHandlerProvider.class.getModule();
+      var providers = module.getDescriptor()
+          .provides()
+          .stream()
+          .filter(provide -> provide.service().equals(URLStreamHandlerProvider.class.getName()))
+          .flatMap(provide -> provide.providers().stream());
+
+      // Then
+      assertThat(providers)
+          .contains(MemoryFileSystemUrlHandlerProvider.class.getName());
+    }
+
+    @DisplayName("The provider returns a handler for the 'memory' protocol")
+    @ValueSource(strings = {
+        "memory://foo/bar/baz",
+        "memory:da32e382-ece7-11ed-a05b-0242ac120003://foo/bar/baz",
+        "memory:cc26d303-e997-4ea2-be2b-6b4b6c042b11://foo/bar/baz",
+    })
+    @ParameterizedTest(name = "for URL {0}")
+    void providerReturnsHandlerForMemoryProtocol(String urlString) throws MalformedURLException {
+      // Given
+      var url = new URL(urlString);
+      var provider = new MemoryFileSystemUrlHandlerProvider();
+
+      // When
+      var handler = provider.createURLStreamHandler(url.getProtocol());
+
+      // Then
+      assertThat(handler).isInstanceOf(Handler.class);
+    }
+
+    @DisplayName("The provider returns a null handler for non 'memory' protocols")
+    @ValueSource(strings = {
+        "file://foo/bar/baz",
+        "jar:file://foo/bar/baz.jar!/Bork.class",
+        "jrt:",
+    })
+    @ParameterizedTest(name = "for URL {0}")
+    void providerReturnsNullHandlerForOtherProtocol(String urlString) throws MalformedURLException {
+      // Given
+      var url = new URL(urlString);
+      var provider = new MemoryFileSystemUrlHandlerProvider();
+
+      // When
+      var handler = provider.createURLStreamHandler(url.getProtocol());
+
+      // Then
+      assertThat(handler).isNull();
+    }
+  }
 }

java-compiler-testing/src/test/java/module-info.java

@@ -34,4 +34,7 @@
   requires org.mockito;
   requires org.mockito.junit.jupiter;
   requires org.slf4j;
+
+  // Used for MemoryFileSystemProviderImplTest$MemoryFileSystemUrlHandlerProviderTest
+  uses java.net.spi.URLStreamHandlerProvider;
 }

pom.xml

@@ -151,7 +151,6 @@
       -Dnet.bytebuddy.experimental=true
       -Dorg.slf4j.simpleLogger.log=INFO
       -Dorg.slf4j.simpleLogger.log.io.github.ascopes.jct=TRACE
-      -Djava.protocol.handler.pkgs=com.github.marschall.memoryfilesystem
       -Xshare:off
       -XX:+TieredCompilation
       -XX:TieredStopAtLevel=1