added jpms url protocol

.gitea/workflows/build.yaml

@@ -5,6 +5,8 @@ on:
       - '*'
 jobs:
   build:
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
     runs-on: hostinger
     steps:
       - name: Checkout sources
@@ -19,7 +21,11 @@ jobs:
       - name: Execute Gradle build
         env:
           PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}
-        run: ./gradlew build publish
+        run: ./gradlew build
+      - name: Publish artifacts
+        env:
+          PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}
+        run: ./gradlew publish
   build-docker:
     name: "Build Docker images"
     runs-on: hostinger

Dockerfile

@@ -31,11 +31,11 @@ USER luser
 WORKDIR /home/luser
 
 FROM base-release AS release
-RUN --mount=type=bind,from=build,source=/home/ubuntu/gbcs/gbcs-cli/build,target=/home/luser/build cp build/libs/gbcs-cli-envelope*.jar gbcs.jar
+RUN --mount=type=bind,from=build,source=/home/ubuntu/gbcs/gbcs-cli/build,target=/home/luser/build cp build/libs/gbcs-cli-envelope-*.jar gbcs.jar
 ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar"]
 
 FROM base-release AS release-memcached
-RUN --mount=type=bind,from=build,source=/home/ubuntu/gbcs/gbcs-cli/build,target=/home/luser/build cp build/libs/gbcs-cli-envelope*.jar gbcs.jar
+RUN --mount=type=bind,from=build,source=/home/ubuntu/gbcs/gbcs-cli/build,target=/home/luser/build cp build/libs/gbcs-cli-envelope-*.jar gbcs.jar
 RUN mkdir plugins
 WORKDIR /home/luser/plugins
 RUN --mount=type=bind,from=build,source=/home/ubuntu/gbcs/gbcs-memcached/build/distributions,target=/build/distributions tar -xf /build/distributions/gbcs-memcached*.tar

build.gradle

@@ -10,16 +10,16 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 
-allprojects {
+allprojects { subproject ->
     group = 'net.woggioni'
 
-    if(project.currentTag.isPresent()) {
+        if(project.currentTag.isPresent()) {
-        version = project.currentTag
+            version = project.currentTag.map { it[0] }.get()
-    } else {
+        } else {
-        version = project.gitRevision.map { gitRevision ->
+            version = project.gitRevision.map { gitRevision ->
-            "${getProperty('gbcs.version')}.${gitRevision[0..10]}"
+                "${getProperty('gbcs.version')}.${gitRevision[0..10]}"
+            }.get()
         }
-    }
 
     repositories {
         maven {
@@ -36,7 +36,7 @@ allprojects {
     pluginManager.withPlugin('java-library') {
 
         ext {
-            jpmsModuleName = project.group + '.' + project.name.replace('-', '.')
+            jpmsModuleName = subproject.group + '.' + subproject.name.replace('-', '.')
         }
 
         java {
@@ -61,14 +61,13 @@ allprojects {
             options.compilerArgumentProviders << new CommandLineArgumentProvider() {
                 @Override
                 Iterable<String> asArguments() {
-                    return ['--patch-module', project.jpmsModuleName + '=' + project.sourceSets.main.output.asPath]
+                    return ['--patch-module', subproject.jpmsModuleName + '=' + subproject.sourceSets.main.output.asPath]
                 }
             }
             options.javaModuleVersion = version
         }
     }
 
-
     pluginManager.withPlugin(catalog.plugins.kotlin.jvm.get().pluginId) {
         tasks.withType(KotlinCompile.class) {
             compilerOptions.jvmTarget = JvmTarget.JVM_21
@@ -101,17 +100,12 @@ allprojects {
             }
         }
     }
-
-    tasks.withType(AbstractArchiveTask.class) {
-        archiveVersion = project.version
-    }
 }
 
 dependencies {
     implementation catalog.jwo
     implementation catalog.slf4j.api
     implementation catalog.netty.codec.http
-    implementation catalog.netty.codec.http2
 
     api project('gbcs-base')
     api project('gbcs-api')

conf/gbcs-memcached.xml

@@ -2,7 +2,7 @@
 <gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:gbcs="urn:net.woggioni.gbcs"
              xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
-             xs:schemaLocation="urn:net.woggioni.gbcs-memcached classpath:net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd urn:net.woggioni.gbcs classpath:net/woggioni/gbcs/schema/gbcs.xsd">
+             xs:schemaLocation="urn:net.woggioni.gbcs-memcached jpms://net.woggioni.gbcs.memcached/net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
     <bind host="0.0.0.0" port="13080" />
     <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="16777216" compression-mode="zip">
         <server host="memcached" port="11211"/>

gbcs-api/build.gradle

@@ -7,10 +7,6 @@ plugins {
 dependencies {
 }
 
-tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    options.javaModuleVersion = version
-}
-
 publishing {
     publications {
         maven(MavenPublication) {

gbcs-api/src/main/java/net/woggioni/gbcs/api/Configuration.java

@@ -1,6 +1,7 @@
 package net.woggioni.gbcs.api;
 
 
+import lombok.EqualsAndHashCode;
 import lombok.Value;
 
 import java.nio.file.Path;
@@ -23,25 +24,18 @@ public class Configuration {
 
     @Value
     public static class Group {
+        @EqualsAndHashCode.Include
         String name;
         Set<Role> roles;
-
-        @Override
-        public int hashCode() {
-            return name.hashCode();
-        }
     }
 
     @Value
     public static class User {
+        @EqualsAndHashCode.Include
         String name;
         String password;
         Set<Group> groups;
 
-        @Override
-        public int hashCode() {
-            return name.hashCode();
-        }
 
         public Set<Role> getRoles() {
             return groups.stream()

gbcs-base/build.gradle

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     id 'java-library'
@@ -10,16 +8,6 @@ plugins {
 dependencies {
     compileOnly project(':gbcs-api')
     compileOnly catalog.slf4j.api
-    api catalog.jwo
-}
-
-tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    options.compilerArgs << '--patch-module' << 'net.woggioni.gbcs.base=' + project.sourceSets.main.output.asPath
-    options.javaModuleVersion = version
-}
-
-tasks.named("compileKotlin", KotlinCompile.class) {
-    compilerOptions.jvmTarget = JvmTarget.JVM_21
 }
 
 publishing {

gbcs-base/src/main/java/module-info.java

@@ -3,7 +3,6 @@ module net.woggioni.gbcs.base {
     requires java.logging;
     requires org.slf4j;
     requires kotlin.stdlib;
-    requires net.woggioni.jwo;
 
     exports net.woggioni.gbcs.base;
 }

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/GbcsUrlStreamHandlerFactory.kt

@@ -1,16 +1,20 @@
 package net.woggioni.gbcs.base
 
+import java.io.IOException
 import java.io.InputStream
 import java.net.URL
 import java.net.URLConnection
 import java.net.URLStreamHandler
 import java.net.URLStreamHandlerFactory
+import java.util.Optional
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.stream.Collectors
 
 
-class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
+class GbcsUrlStreamHandlerFactory : URLStreamHandlerFactory {
-    private class Handler(private val classLoader: ClassLoader = ClasspathUrlStreamHandlerFactoryProvider::class.java.classLoader) : URLStreamHandler() {
+
+    private class ClasspathHandler(private val classLoader: ClassLoader = GbcsUrlStreamHandlerFactory::class.java.classLoader) :
+        URLStreamHandler() {
 
         override fun openConnection(u: URL): URLConnection? {
             return javaClass.module
@@ -20,23 +24,48 @@ class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
                     val i = path.lastIndexOf('/')
                     val packageName = path.substring(0, i).replace('/', '.')
                     val modules = packageMap[packageName]!!
-                    ModuleResourceURLConnection(
+                    ClasspathResourceURLConnection(
                         u,
                         modules
                     )
                 }
                 ?: classLoader.getResource(u.path)?.let(URL::openConnection)
-            }
         }
+    }
+
+    private class JpmsHandler : URLStreamHandler() {
+
+        override fun openConnection(u: URL): URLConnection {
+            val thisModule = javaClass.module
+            val sourceModule = Optional.ofNullable(thisModule)
+                .map { obj: Module -> obj.layer }
+                .flatMap { layer: ModuleLayer ->
+                    val moduleName = u.host
+                    layer.findModule(moduleName)
+                }.orElse(thisModule)
+            return JpmsResourceURLConnection(u, sourceModule)
+        }
+    }
+
+    private class JpmsResourceURLConnection(url: URL, private val module: Module) : URLConnection(url) {
+        override fun connect() {
+        }
+
+        @Throws(IOException::class)
+        override fun getInputStream(): InputStream {
+            return module.getResourceAsStream(getURL().path)
+        }
+    }
 
     override fun createURLStreamHandler(protocol: String): URLStreamHandler? {
         return when (protocol) {
-            "classpath" -> Handler()
+            "classpath" -> ClasspathHandler()
+            "jpms" -> JpmsHandler()
             else -> null
         }
     }
 
-    private class ModuleResourceURLConnection(url: URL?, private val modules: List<Module>) :
+    private class ClasspathResourceURLConnection(url: URL?, private val modules: List<Module>) :
         URLConnection(url) {
         override fun connect() {}
 
@@ -53,12 +82,12 @@ class ClasspathUrlStreamHandlerFactoryProvider : URLStreamHandlerFactory {
         private val installed = AtomicBoolean(false)
         fun install() {
             if (!installed.getAndSet(true)) {
-                URL.setURLStreamHandlerFactory(ClasspathUrlStreamHandlerFactoryProvider())
+                URL.setURLStreamHandlerFactory(GbcsUrlStreamHandlerFactory())
             }
         }
 
         private val packageMap: Map<String, List<Module>> by lazy {
-            ClasspathUrlStreamHandlerFactoryProvider::class.java.module.layer
+            GbcsUrlStreamHandlerFactory::class.java.module.layer
                 .modules()
                 .stream()
                 .flatMap { m: Module ->

gbcs-cli/build.gradle

@@ -18,8 +18,6 @@ Property<String> mainClassName = objects.property(String.class)
 mainClassName.set('net.woggioni.gbcs.cli.GradleBuildCacheServerCli')
 
 tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    options.compilerArgs << '--patch-module' << 'net.woggioni.gbcs.cli=' + project.sourceSets.main.output.asPath
-    options.javaModuleVersion = version
     options.javaModuleMainClass = mainClassName
 }
 
@@ -36,8 +34,6 @@ dependencies {
     implementation catalog.netty.codec.http
     implementation catalog.picocli
 
-//    implementation project(':gbcs-base')
-//    implementation project(':gbcs-api')
     implementation rootProject
 
 //    runtimeOnly catalog.slf4j.jdk14
@@ -50,11 +46,6 @@ Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named('envelopeJar', E
     systemProperties['logback.configurationFile'] = 'classpath:net/woggioni/gbcs/cli/logback.xml'
 }
 
-def envelopeJarArtifact = artifacts.add('archives', envelopeJarTaskProvider.get().archiveFile.get().asFile) {
-    type = 'jar'
-    builtBy envelopeJarTaskProvider
-}
-
 tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask) {
     mainClass = 'net.woggioni.gbcs.GraalNativeImageConfiguration'
 }
@@ -68,7 +59,7 @@ tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
 publishing {
     publications {
         maven(MavenPublication) {
-            artifact envelopeJarArtifact
+            artifact envelopeJar
         }
     }
 }

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/GradleBuildCacheServerCli.kt

@@ -2,7 +2,7 @@ package net.woggioni.gbcs.cli
 
 import net.woggioni.gbcs.GradleBuildCacheServer
 import net.woggioni.gbcs.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
-import net.woggioni.gbcs.base.ClasspathUrlStreamHandlerFactoryProvider
+import net.woggioni.gbcs.base.GbcsUrlStreamHandlerFactory
 import net.woggioni.gbcs.base.contextLogger
 import net.woggioni.gbcs.base.debug
 import net.woggioni.gbcs.base.info
@@ -29,7 +29,7 @@ class GradleBuildCacheServerCli(application : Application, private val log : Log
         @JvmStatic
         fun main(vararg args: String) {
             Thread.currentThread().contextClassLoader = GradleBuildCacheServerCli::class.java.classLoader
-            ClasspathUrlStreamHandlerFactoryProvider.install()
+            GbcsUrlStreamHandlerFactory.install()
             val log = contextLogger()
             val app = Application.builder("gbcs")
                 .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")

gbcs-memcached/build.gradle

@@ -30,15 +30,6 @@ dependencies {
     implementation catalog.xmemcached
 }
 
-tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    options.compilerArgs << '--patch-module' << 'net.woggioni.gbcs.memcached=' + project.sourceSets.main.output.asPath
-    options.javaModuleVersion = version
-}
-
-tasks.named("compileKotlin", KotlinCompile.class) {
-    compilerOptions.jvmTarget = JvmTarget.JVM_21
-}
-
 Provider<Tar> bundleTask = tasks.register("bundle", Tar) {
     from(tasks.named(JavaPlugin.JAR_TASK_NAME))
     from(configurations.bundle)
@@ -49,16 +40,10 @@ tasks.named(BasePlugin.ASSEMBLE_TASK_NAME) {
     dependsOn(bundleTask)
 }
 
-def bundleArtifact = artifacts.add('archives', bundleTask.get().archiveFile.get().asFile) {
-    type = 'tar'
-    builtBy bundleTask
-}
-
-
 publishing {
     publications {
         maven(MavenPublication) {
-            artifact bundleArtifact
+            artifact bundleTask
         }
     }
 }

gradle.properties

@@ -1,6 +1,6 @@
 org.gradle.configuration-cache=false
 org.gradle.parallel=true
-org.gradle.caching=false
+org.gradle.caching=true
 
 gbcs.version = 0.0.1
 

src/main/java/module-info.java

@@ -1,5 +1,4 @@
 import net.woggioni.gbcs.api.CacheProvider;
-import net.woggioni.gbcs.url.ClasspathUrlStreamHandlerFactoryProvider;
 import net.woggioni.gbcs.cache.FileSystemCacheProvider;
 
 module net.woggioni.gbcs {
@@ -11,7 +10,6 @@ module net.woggioni.gbcs {
     requires io.netty.buffer;
     requires io.netty.transport;
     requires io.netty.codec.http;
-    requires io.netty.codec.http2;
     requires io.netty.common;
     requires io.netty.handler;
     requires io.netty.codec;
@@ -21,11 +19,10 @@ module net.woggioni.gbcs {
     requires net.woggioni.gbcs.api;
 
     exports net.woggioni.gbcs;
+
     opens net.woggioni.gbcs;
     opens net.woggioni.gbcs.schema;
 
-    uses java.net.URLStreamHandlerFactory;
-    provides java.net.URLStreamHandlerFactory with ClasspathUrlStreamHandlerFactoryProvider;
     uses CacheProvider;
     provides CacheProvider with FileSystemCacheProvider;
 }

src/main/java/net/woggioni/gbcs/url/ClasspathUrlStreamHandlerFactoryProvider.java

@@ -1,104 +0,0 @@
-package net.woggioni.gbcs.url;
-
-import net.woggioni.jwo.Fun;
-import net.woggioni.jwo.LazyValue;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.net.URLConnection;
-import java.net.URLStreamHandler;
-import java.net.URLStreamHandlerFactory;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-
-public class ClasspathUrlStreamHandlerFactoryProvider implements URLStreamHandlerFactory {
-
-    private static final AtomicBoolean installed = new AtomicBoolean(false);
-    public static void install() {
-        if(!installed.getAndSet(true)) {
-            URL.setURLStreamHandlerFactory(new ClasspathUrlStreamHandlerFactoryProvider());
-        }
-    }
-
-    private static final LazyValue<Map<String, List<Module>>> packageMap = LazyValue.of(() ->
-            ClasspathUrlStreamHandlerFactoryProvider.class.getModule().getLayer()
-                .modules()
-                .stream()
-                .flatMap(m -> m.getPackages().stream().map(p -> Map.entry(p, m)))
-                .collect(
-                    Collectors.groupingBy(
-                        Map.Entry::getKey,
-                        Collectors.mapping(
-                            Map.Entry::getValue,
-                            Collectors.toUnmodifiableList()
-                        )
-                    )
-                ),
-            LazyValue.ThreadSafetyMode.NONE
-    );
-
-
-    private static class Handler extends URLStreamHandler {
-        private final ClassLoader classLoader;
-
-        public Handler() {
-            this.classLoader = getClass().getClassLoader();
-        }
-
-        public Handler(ClassLoader classLoader) {
-            this.classLoader = classLoader;
-        }
-
-        @Override
-        protected URLConnection openConnection(URL u) throws IOException {
-            return Optional.ofNullable(getClass().getModule())
-                    .filter(m -> m.getLayer() != null)
-                    .map(m -> {
-                        final var path = u.getPath();
-                        final var i = path.lastIndexOf('/');
-                        final var packageName = path.substring(0, i).replace('/', '.');
-                        final var modules = packageMap.get().get(packageName);
-                        return (URLConnection) new ModuleResourceURLConnection(u, modules);
-                    })
-                    .or(() -> Optional.of(classLoader).map(cl -> cl.getResource(u.getPath())).map((Fun<URL, URLConnection>) URL::openConnection))
-                    .orElse(null);
-        }
-    }
-
-    @Override
-    public URLStreamHandler createURLStreamHandler(String protocol) {
-        URLStreamHandler result;
-        switch (protocol) {
-            case "classpath":
-                result = new Handler();
-                break;
-            default:
-                result = null;
-        }
-        return result;
-    }
-
-    private static final class ModuleResourceURLConnection extends URLConnection {
-        private final List<Module> modules;
-
-        ModuleResourceURLConnection(URL url, List<Module> modules) {
-            super(url);
-            this.modules = modules;
-        }
-
-        public void connect() {
-        }
-
-        public InputStream getInputStream() throws IOException {
-            for(final var module : modules) {
-                final var result = module.getResourceAsStream(getURL().getPath());
-                if(result != null) return result;
-            }
-            return null;
-        }
-    }
-}

src/main/kotlin/net/woggioni/gbcs/GradleBuildCacheServer.kt

@@ -34,7 +34,6 @@ import io.netty.handler.codec.http.HttpServerCodec
 import io.netty.handler.codec.http.HttpUtil
 import io.netty.handler.codec.http.HttpVersion
 import io.netty.handler.codec.http.LastHttpContent
-import io.netty.handler.codec.http2.Http2FrameCodecBuilder
 import io.netty.handler.ssl.ApplicationProtocolNames
 import io.netty.handler.ssl.ApplicationProtocolNegotiationHandler
 import io.netty.handler.ssl.ClientAuth
@@ -58,19 +57,12 @@ import net.woggioni.gbcs.base.PasswordSecurity.decodePasswordHash
 import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
 import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.base.contextLogger
-import net.woggioni.gbcs.base.debug
-import net.woggioni.gbcs.base.info
 import net.woggioni.gbcs.configuration.Parser
 import net.woggioni.gbcs.configuration.Serializer
-import net.woggioni.gbcs.url.ClasspathUrlStreamHandlerFactoryProvider
-import net.woggioni.jwo.Application
 import net.woggioni.jwo.JWO
 import net.woggioni.jwo.Tuple2
-import java.io.ByteArrayOutputStream
 import java.io.OutputStream
 import java.net.InetSocketAddress
-import java.net.URL
-import java.net.URLStreamHandlerFactory
 import java.nio.channels.FileChannel
 import java.nio.file.Files
 import java.nio.file.Path
@@ -223,22 +215,6 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
         companion object {
 
-            private fun getServerAPNHandler(): ApplicationProtocolNegotiationHandler {
-                val serverAPNHandler: ApplicationProtocolNegotiationHandler =
-                    object : ApplicationProtocolNegotiationHandler(ApplicationProtocolNames.HTTP_2) {
-                        override fun configurePipeline(ctx: ChannelHandlerContext, protocol: String) {
-                            if (ApplicationProtocolNames.HTTP_2 == protocol) {
-                                ctx.pipeline().addLast(
-                                    Http2FrameCodecBuilder.forServer().build()
-                                )
-                                return
-                            }
-                            throw IllegalStateException("Protocol: $protocol not supported")
-                        }
-                    }
-                return serverAPNHandler
-            }
-
             fun loadKeystore(file: Path, password: String?): KeyStore {
                 val ext = JWO.splitExtension(file)
                     .map(Tuple2<String, String>::get_2)
@@ -299,6 +275,7 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
             if (sslContext != null) {
                 val sslHandler = sslContext.newHandler(ch.alloc())
+                pipeline.addLast(sslHandler)
 
                 if (auth is Configuration.ClientCertificateAuthentication) {
                     val roleAuthorizer = RoleAuthorizer()
@@ -310,7 +287,6 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                     )
                 }
             }
-//            pipeline.addLast(getServerAPNHandler())
             pipeline.addLast(HttpServerCodec())
             pipeline.addLast(HttpChunkContentCompressor(1024))
             pipeline.addLast(ChunkedWriteHandler())
@@ -370,20 +346,12 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
         companion object {
             private val log = contextLogger()
-
-            private fun splitPath(req: HttpRequest): Pair<String?, String> {
-                val uri = req.uri()
-                val i = uri.lastIndexOf('/')
-                if (i < 0) throw RuntimeException(String.format("Malformed request URI: '%s'", uri))
-                return uri.substring(0, i) to uri.substring(i + 1)
-            }
         }
 
         override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
             val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
             val method = msg.method()
             if (method === HttpMethod.GET) {
-//                val (prefix, key) = splitPath(msg)
                 val path = Path.of(msg.uri())
                 val prefix = path.parent
                 val key = path.fileName.toString()
@@ -494,12 +462,10 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             try {
                 closeFuture.sync()
             } finally {
-                val fut1 = workerGroup.shutdownGracefully()
+                workerGroup.shutdownGracefully()
-                val fut2 = if (bossGroup !== workerGroup) {
+                if (bossGroup !== workerGroup) {
                     bossGroup.shutdownGracefully()
-                } else null
+                }
-                fut1.sync()
-                fut2?.sync()
             }
         }
     }
@@ -532,37 +498,8 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
     companion object {
 
-        private val log by lazy {
-            contextLogger()
-        }
-
-        private const val PROTOCOL_HANDLER = "java.protocol.handler.pkgs"
-        private const val HANDLERS_PACKAGE = "net.woggioni.gbcs.url"
-
         val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
 
-        /**
-         * Reset any cached handlers just in case a jar protocol has already been used. We
-         * reset the handler by trying to set a null [URLStreamHandlerFactory] which
-         * should have no effect other than clearing the handlers cache.
-         */
-        private fun resetCachedUrlHandlers() {
-            try {
-                URL.setURLStreamHandlerFactory(null)
-            } catch (ex: Error) {
-                // Ignore
-            }
-        }
-
-        fun registerUrlProtocolHandler() {
-            val handlers = System.getProperty(PROTOCOL_HANDLER, "")
-            System.setProperty(
-                PROTOCOL_HANDLER,
-                if (handlers == null || handlers.isEmpty()) HANDLERS_PACKAGE else "$handlers|$HANDLERS_PACKAGE"
-            )
-            resetCachedUrlHandlers()
-        }
-
         fun loadConfiguration(configurationFile: Path): Configuration {
             val dbf = Xml.newDocumentBuilderFactory(null)
             val db = dbf.newDocumentBuilder()
@@ -573,61 +510,5 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         fun dumpConfiguration(conf : Configuration, outputStream: OutputStream) {
             Xml.write(Serializer.serialize(conf), outputStream)
         }
-
-        fun loadConfiguration(args: Array<String>): Configuration {
-//            Thread.currentThread().contextClassLoader = GradleBuildCacheServer::class.java.classLoader
-            val app = Application.builder("gbcs")
-                .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")
-                .configurationDirectoryPropertyKey("net.woggioni.gbcs.conf.dir")
-                .build()
-            val confDir = app.computeConfigurationDirectory()
-            val configurationFile = confDir.resolve("gbcs.xml")
-            if (!Files.exists(configurationFile)) {
-                log.info {
-                    "Creating default configuration file at '$configurationFile'"
-                }
-                Files.createDirectories(confDir)
-                val defaultConfigurationFileResource = DEFAULT_CONFIGURATION_URL
-                Files.newOutputStream(configurationFile).use { outputStream ->
-                    defaultConfigurationFileResource.openStream().use { inputStream ->
-                        JWO.copy(inputStream, outputStream)
-                    }
-                }
-            }
-//            val schemaUrl = javaClass.getResource("/net/woggioni/gbcs/gbcs.xsd")
-//            val schemaUrl = GBCS.CONFIGURATION_SCHEMA_URL
-            val dbf = Xml.newDocumentBuilderFactory(null)
-//            dbf.schema = Xml.getSchema(this::class.java.module.getResourceAsStream("/net/woggioni/gbcs/gbcs.xsd"))
-//            dbf.schema = Xml.getSchema(schemaUrl)
-            val db = dbf.newDocumentBuilder()
-            val doc = Files.newInputStream(configurationFile).use(db::parse)
-            return Parser.parse(doc)
-        }
-
-        @JvmStatic
-        fun main(args: Array<String>) {
-            ClasspathUrlStreamHandlerFactoryProvider.install()
-            val configuration = loadConfiguration(args)
-            log.debug {
-                ByteArrayOutputStream().also {
-                    Xml.write(Serializer.serialize(configuration), it)
-                }.let {
-                    "Server configuration:\n${String(it.toByteArray())}"
-                }
-            }
-            GradleBuildCacheServer(configuration).run().use {
-            }
-        }
     }
 }
-
-object GraalNativeImageConfiguration {
-    @JvmStatic
-    fun main(args: Array<String>) {
-        val conf = GradleBuildCacheServer.loadConfiguration(args)
-        GradleBuildCacheServer(conf).run().use {
-            Thread.sleep(3000)
-            it.shutdown()
-        }
-    }
-}

src/main/resources/net/woggioni/gbcs/gbcs-default.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:gbcs="urn:net.woggioni.gbcs"
-             xs:schemaLocation="urn:net.woggioni.gbcs classpath:net/woggioni/gbcs/schema/gbcs.xsd">
+             xs:schemaLocation="urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
     <bind host="127.0.0.1" port="8080"/>
     <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
     <authentication>

src/test/java/net/woggioni/gbcs/utils/NetworkUtils.java

@@ -0,0 +1,30 @@
+package net.woggioni.gbcs.utils;
+
+import net.woggioni.jwo.JWO;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+
+public class NetworkUtils {
+
+    private static final int MAX_ATTEMPTS = 50;
+
+    public static int getFreePort() {
+        int count = 0;
+        while(count < MAX_ATTEMPTS) {
+            try (ServerSocket serverSocket = new ServerSocket(0, 50, InetAddress.getLocalHost())) {
+                final var candidate = serverSocket.getLocalPort();
+                if (candidate > 0) {
+                    return candidate;
+                } else {
+                    JWO.newThrowable(RuntimeException.class, "Got invalid port number: %d", candidate);
+                    throw new RuntimeException("Error trying to find an open port");
+                }
+            } catch (IOException ignored) {
+                ++count;
+            }
+        }
+        throw new RuntimeException("Error trying to find an open port");
+    }
+}

src/test/kotlin/net/woggioni/gbcs/test/BasicAuthServerTest.kt

@@ -1,15 +1,17 @@
 package net.woggioni.gbcs.test
 
 import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.auth.AbstractNettyHttpAuthenticator.Companion.hashPassword
-import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.api.Role
+import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
 import net.woggioni.gbcs.configuration.Serializer
+import net.woggioni.gbcs.utils.NetworkUtils
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
+import java.io.IOException
 import java.net.ServerSocket
 import java.net.URI
 import java.net.http.HttpClient
@@ -41,7 +43,7 @@ class BasicAuthServerTest : AbstractServerTest() {
         val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
         cfg = Configuration(
             "127.0.0.1",
-            ServerSocket(0).localPort + 1,
+            NetworkUtils.getFreePort(),
             serverPath,
             listOf(
                 Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup)),

src/test/kotlin/net/woggioni/gbcs/test/ConfigurationTest.kt

@@ -1,10 +1,10 @@
 package net.woggioni.gbcs.test
 
+import net.woggioni.gbcs.base.GbcsUrlStreamHandlerFactory
 import net.woggioni.gbcs.base.GBCS.toUrl
 import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.configuration.Parser
 import net.woggioni.gbcs.configuration.Serializer
-import net.woggioni.gbcs.url.ClasspathUrlStreamHandlerFactoryProvider
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.io.TempDir
 import org.junit.jupiter.params.ParameterizedTest
@@ -22,7 +22,7 @@ class ConfigurationTest {
     )
     @ParameterizedTest
     fun test(configurationUrl: String, @TempDir testDir: Path) {
-        ClasspathUrlStreamHandlerFactoryProvider.install()
+        GbcsUrlStreamHandlerFactory.install()
         val doc = Xml.parseXml(configurationUrl.toUrl())
         val cfg = Parser.parse(doc)
         val configFile = testDir.resolve("gbcs.xml")

src/test/kotlin/net/woggioni/gbcs/test/NoAuthServerTest.kt

@@ -5,6 +5,7 @@ import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
 import net.woggioni.gbcs.configuration.Serializer
+import net.woggioni.gbcs.utils.NetworkUtils
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
@@ -32,7 +33,7 @@ class NoAuthServerTest : AbstractServerTest() {
         this.cacheDir = testDir.resolve("cache")
         cfg = Configuration(
             "127.0.0.1",
-            ServerSocket(0).localPort + 1,
+            NetworkUtils.getFreePort(),
             serverPath,
             emptyMap(),
             emptyMap(),

src/test/kotlin/net/woggioni/gbcs/test/TlsServerTest.kt

@@ -8,6 +8,7 @@ import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
 import net.woggioni.gbcs.configuration.Serializer
 import net.woggioni.gbcs.utils.CertificateUtils
 import net.woggioni.gbcs.utils.CertificateUtils.X509Credentials
+import net.woggioni.gbcs.utils.NetworkUtils
 import org.bouncycastle.asn1.x500.X500Name
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
@@ -146,7 +147,7 @@ class TlsServerTest : AbstractServerTest() {
         createKeyStoreAndTrustStore()
         cfg = Configuration(
             "127.0.0.1",
-            ServerSocket(0).localPort + 1,
+            NetworkUtils.getFreePort(),
             serverPath,
             users.asSequence().map { it.name to it }.toMap(),
             sequenceOf(writersGroup, readersGroup).map { it.name to it }.toMap(),

src/test/resources/net/woggioni/gbcs/test/gbcs-default.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:gbcs="urn:net.woggioni.gbcs"
-             xs:schemaLocation="urn:net.woggioni.gbcs classpath:net/woggioni/gbcs/schema/gbcs.xsd">
+             xs:schemaLocation="urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
     <bind host="127.0.0.1" port="11443"/>
     <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
     <authentication>

src/test/resources/net/woggioni/gbcs/test/gbcs-memcached.xml

@@ -2,7 +2,7 @@
 <gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:gbcs="urn:net.woggioni.gbcs"
              xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
-             xs:schemaLocation="urn:net.woggioni.gbcs classpath:net/woggioni/gbcs/schema/gbcs.xsd urn:net.woggioni.gbcs-memcached classpath:net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd">
+             xs:schemaLocation="urn:net.woggioni.gbcs-memcached jpms://net.woggioni.gbcs.memcached/net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
     <bind host="127.0.0.1" port="11443" />
     <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="101325" compression-mode="gzip" digest="SHA-256">
         <server host="127.0.0.1" port="11211"/>