added jpms url protocol

.gitea/workflows/build.yaml

@@ -9,56 +9,53 @@ jobs:
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: graalvm
+          java-version: 21
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v3
       - name: Execute Gradle build
-        run: ./gradlew build
+        env:
-      - name: Prepare Docker image build
+          PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}
-        run: ./gradlew prepareDockerBuild
+        run: ./gradlew build publish
-      - name: Get project version
+  build-docker:
-        id: retrieve-version
+    name: "Build Docker images"
-        run: ./gradlew -q version >> "$GITHUB_OUTPUT"
+    runs-on: hostinger
-      - name: Set up QEMU
+    steps:
-        uses: docker/setup-qemu-action@v3
+      -
-      - name: Set up Docker Buildx
+        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v3.4.0
         with:
           driver: docker-container
-      - name: Login to Gitea container registry
+      -
+        name: Login to Gitea container registry
         uses: docker/login-action@v3
         with:
           registry: gitea.woggioni.net
           username: woggioni
           password: ${{ secrets.PUBLISHER_TOKEN }}
       -
-        name: Build gbcs Docker image
+        name: Build and push gbcs images
-        uses: docker/build-push-action@v5.3.0
+        uses: docker/build-push-action@v6
         with:
-          context: "docker/build/docker"
-          platforms: linux/amd64,linux/arm64
           push: true
           pull: true
           tags: |
-            gitea.woggioni.net/woggioni/gbcs:latest
+            "gitea.woggioni.net/woggioni/gbcs:slim"
-            gitea.woggioni.net/woggioni/gbcs:${{ steps.retrieve-version.outputs.VERSION }}
-          target: release
-          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
-      -
-        name: Build gbcs memcache Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64,linux/arm64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/gbcs:memcache
-            gitea.woggioni.net/woggioni/gbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-memcache
           cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
           cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/gbcs:buildx
-      - name: Publish artifacts
+          target: release
-        env:
+      -
-          PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}
+        name: Build and push gbcs memcached image
-        run: ./gradlew publish
+        uses: docker/build-push-action@v6
-
+        with:
+          push: true
+          pull: true
+          tags: |
+            "gitea.woggioni.net/woggioni/gbcs:latest"
+            "gitea.woggioni.net/woggioni/gbcs:memcached"
+          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
+          cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/gbcs:buildx
+          target: release-memcached

Dockerfile

@@ -0,0 +1,46 @@
+FROM container-registry.oracle.com/graalvm/native-image:21 AS oracle
+
+FROM ubuntu:24.04 AS build
+COPY --from=oracle /usr/lib64/graalvm/ /usr/lib64/graalvm/
+ENV JAVA_HOME=/usr/lib64/graalvm/graalvm-java21
+USER ubuntu
+WORKDIR /home/ubuntu
+
+RUN mkdir gbcs
+WORKDIR /home/ubuntu/gbcs
+
+COPY --chown=ubuntu:users .git .git
+COPY --chown=ubuntu:users gbcs-base gbcs-base
+COPY --chown=ubuntu:users gbcs-api gbcs-api
+COPY --chown=ubuntu:users gbcs-memcached gbcs-memcached
+COPY --chown=ubuntu:users gbcs-cli gbcs-cli
+COPY --chown=ubuntu:users src src
+COPY --chown=ubuntu:users settings.gradle settings.gradle
+COPY --chown=ubuntu:users build.gradle build.gradle
+COPY --chown=ubuntu:users gradle.properties gradle.properties
+COPY --chown=ubuntu:users gradle gradle
+COPY --chown=ubuntu:users gradlew gradlew
+
+RUN --mount=type=cache,target=/home/ubuntu/.gradle,uid=1000,gid=1000 ./gradlew --no-daemon assemble
+
+FROM alpine:latest AS base-release
+RUN --mount=type=cache,target=/var/cache/apk apk update
+RUN --mount=type=cache,target=/var/cache/apk apk add openjdk21-jre
+RUN adduser -D luser
+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
+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 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
+WORKDIR /home/luser
+ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar"]
+
+FROM release-memcached as compose
+COPY --chown=luser:luser conf/gbcs-memcached.xml /home/luser/.config/gbcs/gbcs.xml

build.gradle

@@ -1,23 +1,25 @@
 plugins {
-    alias catalog.plugins.kotlin.jvm apply false
+    id 'java-library'
+    alias catalog.plugins.kotlin.jvm
     alias catalog.plugins.sambal
-    alias catalog.plugins.lombok apply false
+    alias catalog.plugins.lombok
+    id 'maven-publish'
 }
 
-
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
-allprojects { subproject ->
+
+allprojects {
     group = 'net.woggioni'
 
-        if(project.currentTag.isPresent()) {
+    if(project.currentTag.isPresent()) {
-            version = project.currentTag.map { it[0] }.get()
+        version = project.currentTag
-        } 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 {
@@ -34,7 +36,7 @@ allprojects { subproject ->
     pluginManager.withPlugin('java-library') {
 
         ext {
-            jpmsModuleName = subproject.group + '.' + subproject.name.replace('-', '.')
+            jpmsModuleName = project.group + '.' + project.name.replace('-', '.')
         }
 
         java {
@@ -46,12 +48,6 @@ allprojects { subproject ->
             }
         }
 
-        dependencies {
-            testImplementation catalog.junit.jupiter.api
-            testImplementation catalog.junit.jupiter.params
-            testRuntimeOnly catalog.junit.jupiter.engine
-        }
-
         test {
             useJUnitPlatform()
         }
@@ -65,21 +61,13 @@ allprojects { subproject ->
             options.compilerArgumentProviders << new CommandLineArgumentProvider() {
                 @Override
                 Iterable<String> asArguments() {
-                    return ['--patch-module', subproject.jpmsModuleName + '=' + subproject.sourceSets.main.output.asPath]
+                    return ['--patch-module', project.jpmsModuleName + '=' + project.sourceSets.main.output.asPath]
                 }
             }
             options.javaModuleVersion = version
         }
     }
 
-    pluginManager.withPlugin('jacoco') {
-        test {
-            finalizedBy jacocoTestReport
-        }
-        jacocoTestReport {
-            dependsOn test
-        }
-    }
 
     pluginManager.withPlugin(catalog.plugins.kotlin.jvm.get().pluginId) {
         tasks.withType(KotlinCompile.class) {
@@ -113,11 +101,37 @@ allprojects { subproject ->
             }
         }
     }
-}
 
-tasks.register('version') {
+    tasks.withType(AbstractArchiveTask.class) {
-    doLast {
+        archiveVersion = project.version
-        println("VERSION=$version")
+    }
+}
+
+dependencies {
+    implementation catalog.jwo
+    implementation catalog.slf4j.api
+    implementation catalog.netty.codec.http
+
+    api project('gbcs-base')
+    api project('gbcs-api')
+
+//    runtimeOnly catalog.slf4j.jdk14
+    testRuntimeOnly catalog.logback.classic
+
+    testImplementation catalog.bcprov.jdk18on
+    testImplementation catalog.bcpkix.jdk18on
+    testImplementation catalog.junit.jupiter.api
+    testImplementation catalog.junit.jupiter.params
+    testRuntimeOnly catalog.junit.jupiter.engine
+
+    testRuntimeOnly project("gbcs-memcached")
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from(components["java"])
+        }
     }
 }
 

conf/gbcs-memcached.xml

@@ -0,0 +1,13 @@
+<?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"
+             xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
+             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"/>
+    </cache>
+    <authentication>
+        <none/>
+    </authentication>
+</gbcs:server>

docker-compose.yml

@@ -0,0 +1,37 @@
+networks:
+  default:
+    external: false
+    ipam:
+      driver: default
+      config:
+        - subnet: 172.118.0.0/16
+          ip_range: 172.118.0.0/16
+          gateway: 172.118.0.254
+services:
+  gbcs:
+    build:
+      context: .
+      target: compose
+    container_name: gbcs
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:8080:13080"
+      - "[::1]:8080:13080"
+    depends_on:
+      memcached:
+        condition: service_started
+    deploy:
+      resources:
+        limits:
+          cpus: "2.00"
+          memory: 256M
+  memcached:
+    image: memcached
+    container_name: memcached
+    restart: unless-stopped
+    command: -I 64m -m 900m
+    deploy:
+      resources:
+        limits:
+          cpus: "1.00"
+          memory: 1G

docker/Dockerfile

@@ -1,16 +0,0 @@
-FROM eclipse-temurin:21-jre-alpine AS base-release
-RUN adduser -D luser
-USER luser
-WORKDIR /home/luser
-
-FROM base-release AS release
-ADD gbcs-cli-envelope-*.jar gbcs.jar
-ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]
-
-FROM base-release AS release-memcache
-ADD --chown=luser:luser gbcs-cli-envelope-*.jar gbcs.jar
-RUN mkdir plugins
-WORKDIR /home/luser/plugins
-RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcache*.tar
-WORKDIR /home/luser
-ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]

docker/build.gradle

@@ -1,67 +0,0 @@
-plugins {
-    id 'base'
-    alias(catalog.plugins.gradle.docker)
-}
-
-import com.bmuschko.gradle.docker.tasks.image.DockerBuildImage
-import com.bmuschko.gradle.docker.tasks.image.DockerPushImage
-import com.bmuschko.gradle.docker.tasks.image.DockerTagImage
-
-
-configurations {
-    docker {
-        canBeResolved = true
-        transitive = false
-        visible = false
-        canBeConsumed = false
-    }
-}
-
-dependencies {
-    docker project(path: ':gbcs-cli', configuration: 'release')
-    docker project(path: ':gbcs-server-memcache', configuration: 'release')
-}
-
-Provider<Task> cleanTaskProvider = tasks.named(BasePlugin.CLEAN_TASK_NAME) {}
-
-Provider<Copy> prepareDockerBuild = tasks.register('prepareDockerBuild', Copy) {
-    dependsOn cleanTaskProvider
-    group = 'docker'
-    into project.layout.buildDirectory.file('docker')
-    from(configurations.docker)
-    from(file('Dockerfile'))
-}
-
-Provider<DockerBuildImage> dockerBuild = tasks.register('dockerBuildImage', DockerBuildImage) {
-    group = 'docker'
-    dependsOn prepareDockerBuild
-    images.add('gitea.woggioni.net/woggioni/gbcs:latest')
-    images.add("gitea.woggioni.net/woggioni/gbcs:${version}")
-}
-
-Provider<DockerTagImage> dockerTag = tasks.register('dockerTagImage', DockerTagImage) {
-    group = 'docker'
-    repository = 'gitea.woggioni.net/woggioni/gbcs'
-    imageId = 'gitea.woggioni.net/woggioni/gbcs:latest'
-    tag = version
-}
-
-Provider<DockerTagImage> dockerTagMemcache = tasks.register('dockerTagMemcacheImage', DockerTagImage) {
-    group = 'docker'
-    repository = 'gitea.woggioni.net/woggioni/gbcs'
-    imageId = 'gitea.woggioni.net/woggioni/gbcs:memcache'
-    tag = "${version}-memcache"
-}
-
-Provider<DockerPushImage> dockerPush = tasks.register('dockerPushImage', DockerPushImage) {
-    group = 'docker'
-    dependsOn dockerTag, dockerTagMemcache
-    registryCredentials {
-        url = getProperty('docker.registry.url')
-        username = 'woggioni'
-        password = System.getenv().get("PUBLISHER_TOKEN")
-    }
-    images = [dockerTag.flatMap{ it.tag }, dockerTagMemcache.flatMap{ it.tag }]
-}
-
-

gbcs-api/build.gradle

@@ -5,7 +5,10 @@ plugins {
 }
 
 dependencies {
-    api catalog.netty.buffer
+}
+
+tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
+    options.javaModuleVersion = version
 }
 
 publishing {

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

@@ -1,7 +1,6 @@
 module net.woggioni.gbcs.api {
     requires static lombok;
     requires java.xml;
-    requires io.netty.buffer;
     exports net.woggioni.gbcs.api;
     exports net.woggioni.gbcs.api.exception;
 }

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

@@ -1,14 +1,11 @@
 package net.woggioni.gbcs.api;
 
-import io.netty.buffer.ByteBuf;
 import net.woggioni.gbcs.api.exception.ContentTooLargeException;
 
 import java.nio.channels.ReadableByteChannel;
-import java.util.concurrent.CompletableFuture;
-
 
 public interface Cache extends AutoCloseable {
-    CompletableFuture<ReadableByteChannel> get(String key);
+    ReadableByteChannel get(String key);
 
-    CompletableFuture<Void> put(String key, ByteBuf content) throws ContentTooLargeException;
+    void put(String key, byte[] content) throws ContentTooLargeException;
 }

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

@@ -1,13 +1,10 @@
 package net.woggioni.gbcs.api;
 
 
-import lombok.EqualsAndHashCode;
-import lombok.NonNull;
 import lombok.Value;
 
 import java.nio.file.Path;
 import java.security.cert.X509Certificate;
-import java.time.Duration;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -16,57 +13,35 @@ import java.util.stream.Collectors;
 public class Configuration {
     String host;
     int port;
-    int incomingConnectionsBacklogSize;
     String serverPath;
-    @NonNull
-    EventExecutor eventExecutor;
-    @NonNull
-    Connection connection;
     Map<String, User> users;
     Map<String, Group> groups;
     Cache cache;
     Authentication authentication;
     Tls tls;
-
+    boolean useVirtualThread;
-    @Value
-    public static class EventExecutor {
-        boolean useVirtualThreads;
-    }
-
-    @Value
-    public static class Connection {
-        Duration readTimeout;
-        Duration writeTimeout;
-        Duration idleTimeout;
-        Duration readIdleTimeout;
-        Duration writeIdleTimeout;
-        int maxRequestSize;
-    }
-
-    @Value
-    public static class Quota {
-        long calls;
-        Duration period;
-        long initialAvailableCalls;
-        long maxAvailableCalls;
-    }
 
     @Value
     public static class Group {
-        @EqualsAndHashCode.Include
         String name;
         Set<Role> roles;
-        Quota groupQuota;
+
-        Quota userQuota;
+        @Override
+        public int hashCode() {
+            return name.hashCode();
+        }
     }
 
     @Value
     public static class User {
-        @EqualsAndHashCode.Include
         String name;
         String password;
         Set<Group> groups;
-        Quota quota;
+
+        @Override
+        public int hashCode() {
+            return name.hashCode();
+        }
 
         public Set<Role> getRoles() {
             return groups.stream()
@@ -85,21 +60,11 @@ public class Configuration {
         Group extract(X509Certificate cert);
     }
 
-    @Value
-    public static class Throttling {
-        KeyStore keyStore;
-        TrustStore trustStore;
-        boolean verifyClients;
-    }
-
-    public enum ClientCertificate {
-        REQUIRED, OPTIONAL
-    }
-
     @Value
     public static class Tls {
         KeyStore keyStore;
         TrustStore trustStore;
+        boolean verifyClients;
     }
 
     @Value
@@ -115,7 +80,6 @@ public class Configuration {
         Path file;
         String password;
         boolean checkCertificateStatus;
-        boolean requireClientCertificate;
     }
 
     @Value
@@ -143,28 +107,24 @@ public class Configuration {
     public static Configuration of(
             String host,
             int port,
-            int incomingConnectionsBacklogSize,
             String serverPath,
-            EventExecutor eventExecutor,
-            Connection connection,
             Map<String, User> users,
             Map<String, Group> groups,
             Cache cache,
             Authentication authentication,
-            Tls tls
+            Tls tls,
+            boolean useVirtualThread
     ) {
         return new Configuration(
                 host,
                 port,
-                incomingConnectionsBacklogSize,
                 serverPath != null && !serverPath.isEmpty() && !serverPath.equals("/") ? serverPath : null,
-                eventExecutor,
-                connection,
                 users,
                 groups,
                 cache,
                 authentication,
-                tls
+                tls,
+                useVirtualThread
         );
     }
 }

gbcs-api/src/main/java/net/woggioni/gbcs/api/exception/CacheException.java

@@ -1,11 +0,0 @@
-package net.woggioni.gbcs.api.exception;
-
-public class CacheException extends GbcsException {
-    public CacheException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public CacheException(String message) {
-        this(message, null);
-    }
-}

gbcs-api/src/main/java/net/woggioni/gbcs/api/exception/ConfigurationException.java

@@ -1,11 +0,0 @@
-package net.woggioni.gbcs.api.exception;
-
-public class ConfigurationException extends GbcsException {
-    public ConfigurationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public ConfigurationException(String message) {
-        this(message, null);
-    }
-}

gbcs-base/build.gradle

@@ -0,0 +1,30 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    alias catalog.plugins.kotlin.jvm
+}
+
+dependencies {
+    compileOnly project(':gbcs-api')
+    compileOnly catalog.slf4j.api
+}
+
+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 {
+    publications {
+        maven(MavenPublication) {
+            from(components["java"])
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+module net.woggioni.gbcs.base {
+    requires java.xml;
+    requires java.logging;
+    requires org.slf4j;
+    requires kotlin.stdlib;
+
+    exports net.woggioni.gbcs.base;
+}

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

@@ -0,0 +1,12 @@
+package net.woggioni.gbcs.base
+
+import java.net.URI
+import java.net.URL
+
+object GBCS {
+    fun String.toUrl() : URL = URL.of(URI(this), null)
+
+    const val GBCS_NAMESPACE_URI: String = "urn:net.woggioni.gbcs"
+    const val GBCS_PREFIX: String = "gbcs"
+    const val XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"
+}

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

@@ -1,17 +1,17 @@
-package net.woggioni.gbcs.common
+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.spi.URLStreamHandlerProvider
+import java.net.URLStreamHandlerFactory
 import java.util.Optional
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.stream.Collectors
 
 
-class GbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
+class GbcsUrlStreamHandlerFactory : URLStreamHandlerFactory {
 
     private class ClasspathHandler(private val classLoader: ClassLoader = GbcsUrlStreamHandlerFactory::class.java.classLoader) :
         URLStreamHandler() {
@@ -36,17 +36,13 @@ class GbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
     private class JpmsHandler : URLStreamHandler() {
 
         override fun openConnection(u: URL): URLConnection {
-            val moduleName = u.host
             val thisModule = javaClass.module
-            val sourceModule =
+            val sourceModule = Optional.ofNullable(thisModule)
-                thisModule
+                .map { obj: Module -> obj.layer }
-                ?.let(Module::getLayer)
+                .flatMap { layer: ModuleLayer ->
-                ?.let { layer: ModuleLayer ->
+                    val moduleName = u.host
-                    layer.findModule(moduleName).orElse(null)
+                    layer.findModule(moduleName)
-                } ?: if(thisModule.layer == null) {
+                }.orElse(thisModule)
-                    thisModule
-                } else throw ModuleNotFoundException("Module '$moduleName' not found")
-
             return JpmsResourceURLConnection(u, sourceModule)
         }
     }
@@ -57,9 +53,7 @@ class GbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
 
         @Throws(IOException::class)
         override fun getInputStream(): InputStream {
-            val resource = getURL().path
+            return module.getResourceAsStream(getURL().path)
-            return module.getResourceAsStream(resource)
-                ?: throw ResourceNotFoundException("Resource '$resource' not found in module '${module.name}'")
         }
     }
 

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 
 data class HostAndPort(val host: String, val port: Int = 0) {

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

@@ -1,8 +1,7 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import org.slf4j.event.Level
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.logging.LogManager
@@ -53,12 +52,6 @@ inline fun log(log : Logger,
     }
 }
 
-inline fun Logger.log(level : Level, messageBuilder : () -> String) {
-    if(isEnabledForLevel(level)) {
-        makeLoggingEventBuilder(level).log(messageBuilder())
-    }
-}
-
 inline fun Logger.trace(messageBuilder : () -> String) {
     if(isTraceEnabled) {
         trace(messageBuilder())

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import java.security.SecureRandom
 import java.security.spec.KeySpec

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

@@ -1,8 +1,6 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
-import net.woggioni.jwo.JWO
 import org.slf4j.LoggerFactory
-import org.slf4j.event.Level
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 import org.w3c.dom.Node
@@ -82,36 +80,31 @@ class Xml(val doc: Document, val element: Element) {
             private val log = LoggerFactory.getLogger(ErrorHandler::class.java)
         }
 
-         override fun warning(ex: SAXParseException)= err(ex, Level.WARN)
+        override fun warning(ex: SAXParseException) {
+            log.warn(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+        }
 
-        private fun err(ex: SAXParseException, level: Level) {
+        override fun error(ex: SAXParseException) {
-            log.log(level) {
+            log.error(
-                "Problem at ${fileURL}:${ex.lineNumber}:${ex.columnNumber} parsing deployment configuration: ${ex.message}"
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
-            }
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
             throw ex
         }
 
-        override fun error(ex: SAXParseException) = err(ex, Level.ERROR)
+        override fun fatalError(ex: SAXParseException) {
-        override fun fatalError(ex: SAXParseException) = err(ex, Level.ERROR)
+            log.error(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+            throw ex
+        }
     }
 
     companion object {
-        private val dictMap: Map<String, Map<String, Any>> = sequenceOf(
-            "env" to System.getenv().asSequence().map { (k, v) -> k to (v as Any) }.toMap(),
-            "sys" to System.getProperties().asSequence().map { (k, v) -> k as String to (v as Any) }.toMap()
-        ).toMap()
-
-        private fun renderConfigurationTemplate(template: String): String {
-            return JWO.renderTemplate(template, emptyMap(), dictMap).replace("$$", "$")
-        }
-
-        fun Element.renderAttribute(name : String, namespaceURI: String? = null) = if(namespaceURI == null) {
-            getAttribute(name)
-        } else {
-            getAttributeNS(name, namespaceURI)
-        }.takeIf(String::isNotEmpty)?.let(Companion::renderConfigurationTemplate)
-
-
         fun Element.asIterable() = Iterable { ElementIterator(this, null) }
         fun NodeList.asIterable() = Iterable { NodeListIterator(this) }
 
@@ -153,29 +146,29 @@ class Xml(val doc: Document, val element: Element) {
             dbf.isExpandEntityReferences = true
             dbf.isIgnoringComments = true
             dbf.isNamespaceAware = true
-            dbf.isValidating = schemaResourceURL == null
+            dbf.isValidating = false
-            dbf.setFeature("http://apache.org/xml/features/validation/schema", true)
+            dbf.setFeature("http://apache.org/xml/features/validation/schema", true);
             schemaResourceURL?.let {
                 dbf.schema = getSchema(it)
             }
             return dbf
         }
 
-        fun newDocumentBuilder(resource: URL, schemaResourceURL: URL?): DocumentBuilder {
+    fun newDocumentBuilder(resource: URL, schemaResourceURL: URL?): DocumentBuilder {
-            val db = newDocumentBuilderFactory(schemaResourceURL).newDocumentBuilder()
+        val db = newDocumentBuilderFactory(schemaResourceURL).newDocumentBuilder()
-            db.setErrorHandler(ErrorHandler(resource))
+        db.setErrorHandler(ErrorHandler(resource))
-            return db
+        return db
-        }
+    }
 
-        fun parseXmlResource(resource: URL, schemaResourceURL: URL?): Document {
+    fun parseXmlResource(resource: URL, schemaResourceURL: URL?): Document {
-            val db = newDocumentBuilder(resource, schemaResourceURL)
+        val db = newDocumentBuilder(resource, schemaResourceURL)
-            return resource.openStream().use(db::parse)
+        return resource.openStream().use(db::parse)
-        }
+    }
 
-        fun parseXml(sourceURL: URL, sourceStream: InputStream? = null, schemaResourceURL: URL? = null): Document {
+    fun parseXml(sourceURL : URL, sourceStream: InputStream? = null, schemaResourceURL: URL? = null): Document {
-            val db = newDocumentBuilder(sourceURL, schemaResourceURL)
+        val db = newDocumentBuilder(sourceURL, schemaResourceURL)
-            return sourceStream?.let(db::parse) ?: sourceURL.openStream().use(db::parse)
+        return sourceStream?.let(db::parse) ?: sourceURL.openStream().use(db::parse)
-        }
+    }
 
         fun write(doc: Document, output: OutputStream) {
             val transformerFactory = TransformerFactory.newInstance()
@@ -190,12 +183,7 @@ class Xml(val doc: Document, val element: Element) {
             transformer.transform(source, result)
         }
 
-        fun of(
+        fun of(namespaceURI: String, qualifiedName: String, schemaResourceURL: URL? = null, cb: Xml.(el: Element) -> Unit): Document {
-            namespaceURI: String,
-            qualifiedName: String,
-            schemaResourceURL: URL? = null,
-            cb: Xml.(el: Element) -> Unit
-        ): Document {
             val dbf = newDocumentBuilderFactory(schemaResourceURL)
             val db = dbf.newDocumentBuilder()
             val doc = db.newDocument()
@@ -219,7 +207,7 @@ class Xml(val doc: Document, val element: Element) {
 
     fun node(
         name: String,
-        namespaceURI: String? = null,
+        namespaceURI : String? = null,
         attrs: Map<String, String> = emptyMap(),
         cb: Xml.(el: Element) -> Unit = {}
     ): Element {
@@ -234,7 +222,7 @@ class Xml(val doc: Document, val element: Element) {
             }
     }
 
-    fun attr(key: String, value: String, namespaceURI: String? = null) {
+    fun attr(key: String, value: String, namespaceURI : String? = null) {
         element.setAttributeNS(namespaceURI, key, value)
     }
 

gbcs-cli/build.gradle

@@ -4,38 +4,27 @@ plugins {
     alias catalog.plugins.envelope
     alias catalog.plugins.sambal
     alias catalog.plugins.graalvm.native.image
-    alias catalog.plugins.graalvm.jlink
-    alias catalog.plugins.jpms.check
     id 'maven-publish'
 }
 
 import net.woggioni.gradle.envelope.EnvelopeJarTask
-import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
 import net.woggioni.gradle.graalvm.NativeImagePlugin
 import net.woggioni.gradle.graalvm.NativeImageTask
-import net.woggioni.gradle.graalvm.JlinkPlugin
+import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
-import net.woggioni.gradle.graalvm.JlinkTask
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
-Property<String> mainModuleName = objects.property(String.class)
-mainModuleName.set('net.woggioni.gbcs.cli')
 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
 }
 
-configurations {
-    release {
-        transitive = false
-        canBeConsumed = true
-        canBeResolved = true
-        visible = true
-    }
-}
-
 envelopeJar {
-    mainModule = mainModuleName
+    mainModule = 'net.woggioni.gbcs.cli'
     mainClass = mainClassName
 
     extraClasspath = ["plugins"]
@@ -47,55 +36,40 @@ dependencies {
     implementation catalog.netty.codec.http
     implementation catalog.picocli
 
-    implementation project(':gbcs-client')
+//    implementation project(':gbcs-base')
-    implementation project(':gbcs-server')
+//    implementation project(':gbcs-api')
+    implementation rootProject
 
 //    runtimeOnly catalog.slf4j.jdk14
     runtimeOnly catalog.logback.classic
-//    runtimeOnly catalog.slf4j.simple
 }
 
 Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named('envelopeJar', EnvelopeJarTask.class) {
 //    systemProperties['java.util.logging.config.class'] = 'net.woggioni.gbcs.LoggingConfig'
-//    systemProperties['log.config.source'] = 'net/woggioni/gbcs/cli/logging.properties'
+//    systemProperties['log.config.source'] = 'logging.properties'
-//    systemProperties['java.util.logging.config.file'] = 'classpath:net/woggioni/gbcs/cli/logging.properties'
     systemProperties['logback.configurationFile'] = 'classpath:net/woggioni/gbcs/cli/logback.xml'
-    systemProperties['io.netty.leakDetectionLevel'] = 'DISABLED'
+}
 
-//    systemProperties['org.slf4j.simpleLogger.showDateTime'] = 'true'
+def envelopeJarArtifact = artifacts.add('archives', envelopeJarTaskProvider.get().archiveFile.get().asFile) {
-//    systemProperties['org.slf4j.simpleLogger.defaultLogLevel'] = 'debug'
+    type = 'jar'
-//    systemProperties['org.slf4j.simpleLogger.log.com.google.code.yanf4j'] = 'warn'
+    builtBy envelopeJarTaskProvider
-//    systemProperties['org.slf4j.simpleLogger.log.net.rubyeye.xmemcached'] = 'warn'
-//    systemProperties['org.slf4j.simpleLogger.dateTimeFormat'] = 'yyyy-MM-dd\'T\'HH:mm:ss.SSSZ'
 }
 
 tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask) {
-    mainClass = mainClassName
+    mainClass = 'net.woggioni.gbcs.GraalNativeImageConfiguration'
-    mainModule = mainModuleName
 }
 
 tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
-    mainClass = mainClassName
+    mainClass = 'net.woggioni.gbcs.GradleBuildCacheServer'
-    mainModule = mainModuleName
     useMusl = true
     buildStaticImage = true
 }
 
-tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
-    mainClass = mainClassName
-    mainModule = 'net.woggioni.gbcs.cli'
-}
-
-artifacts {
-    release(envelopeJarTaskProvider)
-}
-
 publishing {
     publications {
         maven(MavenPublication) {
-            artifact envelopeJar
+            artifact envelopeJarArtifact
         }
     }
 }
 
-

gbcs-cli/native-image/native-image.properties

@@ -1,2 +1,2 @@
-Args=-H:Optimize=3 --gc=serial --initialize-at-run-time=io.netty
+Args=-H:Optimize=3 --gc=serial
 #-H:TraceClassInitialization=io.netty.handler.ssl.BouncyCastleAlpnSslUtils

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

@@ -1,17 +1,15 @@
 module net.woggioni.gbcs.cli {
     requires org.slf4j;
-    requires net.woggioni.gbcs.server;
+    requires net.woggioni.gbcs;
     requires info.picocli;
-    requires net.woggioni.gbcs.common;
+    requires net.woggioni.gbcs.base;
-    requires net.woggioni.gbcs.client;
     requires kotlin.stdlib;
     requires net.woggioni.jwo;
-    requires net.woggioni.gbcs.api;
 
     exports net.woggioni.gbcs.cli.impl.converters to info.picocli;
     opens net.woggioni.gbcs.cli.impl.commands to info.picocli;
     opens net.woggioni.gbcs.cli.impl to info.picocli;
-    opens net.woggioni.gbcs.cli to info.picocli, net.woggioni.gbcs.common;
+    opens net.woggioni.gbcs.cli to info.picocli, net.woggioni.gbcs.base;
 
     exports net.woggioni.gbcs.cli;
 }

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

@@ -1,60 +1,58 @@
 package net.woggioni.gbcs.cli
 
+import net.woggioni.gbcs.GradleBuildCacheServer
+import net.woggioni.gbcs.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
+import net.woggioni.gbcs.base.GbcsUrlStreamHandlerFactory
+import net.woggioni.gbcs.base.contextLogger
+import net.woggioni.gbcs.base.debug
+import net.woggioni.gbcs.base.info
 import net.woggioni.gbcs.cli.impl.AbstractVersionProvider
 import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.cli.impl.commands.BenchmarkCommand
-import net.woggioni.gbcs.cli.impl.commands.ClientCommand
-import net.woggioni.gbcs.cli.impl.commands.GetCommand
-import net.woggioni.gbcs.cli.impl.commands.HealthCheckCommand
 import net.woggioni.gbcs.cli.impl.commands.PasswordHashCommand
-import net.woggioni.gbcs.cli.impl.commands.PutCommand
-import net.woggioni.gbcs.cli.impl.commands.ServerCommand
-import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
-import net.woggioni.gbcs.common.contextLogger
 import net.woggioni.jwo.Application
+import net.woggioni.jwo.JWO
+import org.slf4j.Logger
 import picocli.CommandLine
 import picocli.CommandLine.Model.CommandSpec
+import java.io.ByteArrayOutputStream
+import java.nio.file.Files
+import java.nio.file.Path
 
 
 @CommandLine.Command(
     name = "gbcs", versionProvider = GradleBuildCacheServerCli.VersionProvider::class
 )
-class GradleBuildCacheServerCli : GbcsCommand() {
+class GradleBuildCacheServerCli(application : Application, private val log : Logger) : GbcsCommand() {
 
     class VersionProvider : AbstractVersionProvider()
     companion object {
         @JvmStatic
         fun main(vararg args: String) {
-            val currentClassLoader = GradleBuildCacheServerCli::class.java.classLoader
+            Thread.currentThread().contextClassLoader = GradleBuildCacheServerCli::class.java.classLoader
-            Thread.currentThread().contextClassLoader = currentClassLoader
+            GbcsUrlStreamHandlerFactory.install()
-            if(currentClassLoader.javaClass.name == "net.woggioni.envelope.loader.ModuleClassLoader") {
-                //We're running in an envelope jar and custom URL protocols won't work
-                GbcsUrlStreamHandlerFactory.install()
-            }
             val log = contextLogger()
             val app = Application.builder("gbcs")
                 .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")
                 .configurationDirectoryPropertyKey("net.woggioni.gbcs.conf.dir")
                 .build()
-            val gbcsCli = GradleBuildCacheServerCli()
+            val gbcsCli = GradleBuildCacheServerCli(app, log)
             val commandLine = CommandLine(gbcsCli)
             commandLine.setExecutionExceptionHandler { ex, cl, parseResult ->
                 log.error(ex.message, ex)
                 CommandLine.ExitCode.SOFTWARE
             }
-            commandLine.addSubcommand(ServerCommand(app))
             commandLine.addSubcommand(PasswordHashCommand())
-            commandLine.addSubcommand(
-                CommandLine(ClientCommand(app)).apply {
-                    addSubcommand(BenchmarkCommand())
-                    addSubcommand(PutCommand())
-                    addSubcommand(GetCommand())
-                    addSubcommand(HealthCheckCommand())
-                })
             System.exit(commandLine.execute(*args))
         }
     }
 
+    @CommandLine.Option(
+        names = ["-c", "--config-file"],
+        description = ["Read the application configuration from this file"],
+        paramLabel = "CONFIG_FILE"
+    )
+    private var configurationFile: Path = findConfigurationFile(application)
+
     @CommandLine.Option(names = ["-V", "--version"], versionHelp = true)
     var versionHelp = false
         private set
@@ -62,8 +60,39 @@ class GradleBuildCacheServerCli : GbcsCommand() {
     @CommandLine.Spec
     private lateinit var spec: CommandSpec
 
+    private fun findConfigurationFile(app : Application): Path {
+        val confDir = app.computeConfigurationDirectory()
+        val configurationFile = confDir.resolve("gbcs.xml")
+        return configurationFile
+    }
+
+    private fun createDefaultConfigurationFile(configurationFile : Path) {
+        log.info {
+            "Creating default configuration file at '$configurationFile'"
+        }
+        val defaultConfigurationFileResource = DEFAULT_CONFIGURATION_URL
+        Files.newOutputStream(configurationFile).use { outputStream ->
+            defaultConfigurationFileResource.openStream().use { inputStream ->
+                JWO.copy(inputStream, outputStream)
+            }
+        }
+    }
 
     override fun run() {
-        spec.commandLine().usage(System.out);
+        if (!Files.exists(configurationFile)) {
+            Files.createDirectories(configurationFile.parent)
+            createDefaultConfigurationFile(configurationFile)
+        }
+
+        val configuration = GradleBuildCacheServer.loadConfiguration(configurationFile)
+        log.debug {
+            ByteArrayOutputStream().also {
+                GradleBuildCacheServer.dumpConfiguration(configuration, it)
+            }.let {
+                "Server configuration:\n${String(it.toByteArray())}"
+            }
+        }
+        GradleBuildCacheServer(configuration).run().use {
+        }
     }
 }

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/AbstractVersionProvider.kt

@@ -1,6 +1,8 @@
 package net.woggioni.gbcs.cli.impl
 
 import picocli.CommandLine
+import java.net.URL
+import java.util.Enumeration
 import java.util.jar.Attributes
 import java.util.jar.JarFile
 import java.util.jar.Manifest

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/GbcsCommand.kt

@@ -1,8 +1,6 @@
 package net.woggioni.gbcs.cli.impl
 
-import net.woggioni.jwo.Application
 import picocli.CommandLine
-import java.nio.file.Path
 
 
 abstract class GbcsCommand : Runnable {
@@ -10,10 +8,4 @@ abstract class GbcsCommand : Runnable {
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true)
     var usageHelp = false
         private set
-
-    protected fun findConfigurationFile(app: Application, fileName : String): Path {
-        val confDir = app.computeConfigurationDirectory()
-        val configurationFile = confDir.resolve(fileName)
-        return configurationFile
-    }
 }

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/BenchmarkCommand.kt

@@ -1,142 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.error
-import net.woggioni.gbcs.common.info
-import net.woggioni.jwo.JWO
-import picocli.CommandLine
-import java.security.SecureRandom
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.Semaphore
-import java.util.concurrent.atomic.AtomicLong
-import kotlin.random.Random
-
-@CommandLine.Command(
-    name = "benchmark",
-    description = ["Run a load test against the server"],
-    showDefaultValues = true
-)
-class BenchmarkCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    @CommandLine.Option(
-        names = ["-e", "--entries"],
-        description = ["Total number of elements to be added to the cache"],
-        paramLabel = "NUMBER_OF_ENTRIES"
-    )
-    private var numberOfEntries = 1000
-
-    @CommandLine.Option(
-        names = ["-s", "--size"],
-        description = ["Size of a cache value in bytes"],
-        paramLabel = "SIZE"
-    )
-    private var size = 0x1000
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        GradleBuildCacheClient(profile).use { client ->
-
-            val entryGenerator = sequence {
-                val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
-                while (true) {
-                    val key = JWO.bytesToHex(random.nextBytes(16))
-                    val content = random.nextInt().toByte()
-                    val value = ByteArray(size, { _ -> content })
-                    yield(key to value)
-                }
-            }
-
-            log.info {
-                "Starting insertion"
-            }
-            val entries = let {
-                val completionCounter = AtomicLong(0)
-                val completionQueue = LinkedBlockingQueue<Pair<String, ByteArray>>(numberOfEntries)
-                val start = Instant.now()
-                val semaphore = Semaphore(profile.maxConnections * 3)
-                val iterator = entryGenerator.take(numberOfEntries).iterator()
-                while (completionCounter.get() < numberOfEntries) {
-                    if (iterator.hasNext()) {
-                        val entry = iterator.next()
-                        semaphore.acquire()
-                        val future = client.put(entry.first, entry.second).thenApply { entry }
-                        future.whenComplete { result, ex ->
-                            if (ex != null) {
-                                log.error(ex.message, ex)
-                            } else {
-                                completionQueue.put(result)
-                            }
-                            semaphore.release()
-                            completionCounter.incrementAndGet()
-                        }
-                    } else {
-                        Thread.sleep(0)
-                    }
-                }
-
-                val inserted = completionQueue.toList()
-                val end = Instant.now()
-                log.info {
-                    val elapsed = Duration.between(start, end).toMillis()
-                    val opsPerSecond = String.format("%.2f", numberOfEntries.toDouble() / elapsed * 1000)
-                    "Insertion rate: $opsPerSecond ops/s"
-                }
-                inserted
-            }
-            log.info {
-                "Inserted ${entries.size} entries"
-            }
-            log.info {
-                "Starting retrieval"
-            }
-            if (entries.isNotEmpty()) {
-                val completionCounter = AtomicLong(0)
-                val semaphore = Semaphore(profile.maxConnections * 3)
-                val start = Instant.now()
-                val it = entries.iterator()
-                while (completionCounter.get() < entries.size) {
-                    if (it.hasNext()) {
-                        val entry = it.next()
-                        val future = client.get(entry.first).thenApply {
-                            if (it == null) {
-                                log.error {
-                                    "Missing entry for key '${entry.first}'"
-                                }
-                            } else if (!entry.second.contentEquals(it)) {
-                                log.error {
-                                    "Retrieved a value different from what was inserted for key '${entry.first}'"
-                                }
-                            }
-                        }
-                        future.whenComplete { _, _ ->
-                            completionCounter.incrementAndGet()
-                            semaphore.release()
-                        }
-                    } else {
-                        Thread.sleep(0)
-                    }
-                }
-                val end = Instant.now()
-                log.info {
-                    val elapsed = Duration.between(start, end).toMillis()
-                    val opsPerSecond = String.format("%.2f", entries.size.toDouble() / elapsed * 1000)
-                    "Retrieval rate: $opsPerSecond ops/s"
-                }
-            } else {
-                log.error("Skipping retrieval benchmark as it was not possible to insert any entry in the cache")
-            }
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/ClientCommand.kt

@@ -1,41 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.jwo.Application
-import picocli.CommandLine
-import java.nio.file.Path
-
-@CommandLine.Command(
-    name = "client",
-    description = ["GBCS client"],
-    showDefaultValues = true
-)
-class ClientCommand(app : Application) : GbcsCommand() {
-
-    @CommandLine.Option(
-        names = ["-c", "--configuration"],
-        description = ["Path to the client configuration file"],
-        paramLabel = "CONFIGURATION_FILE"
-    )
-    private var configurationFile : Path = findConfigurationFile(app, "gbcs-client.xml")
-
-    @CommandLine.Option(
-        names = ["-p", "--profile"],
-        description = ["Name of the client profile to be used"],
-        paramLabel = "PROFILE",
-        required = true
-    )
-    var profileName : String? = null
-
-    val configuration : GradleBuildCacheClient.Configuration by lazy {
-        GradleBuildCacheClient.Configuration.parse(configurationFile)
-    }
-
-    override fun run() {
-        println("Available profiles:")
-        configuration.profiles.forEach { (profileName, _) ->
-            println(profileName)
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/GetCommand.kt

@@ -1,51 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
-import picocli.CommandLine
-import java.nio.file.Files
-import java.nio.file.Path
-
-@CommandLine.Command(
-    name = "get",
-    description = ["Fetch a value from the cache with the specified key"],
-    showDefaultValues = true
-)
-class GetCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    @CommandLine.Option(
-        names = ["-k", "--key"],
-        description = ["The key for the new value"],
-        paramLabel = "KEY"
-    )
-    private var key : String = ""
-
-    @CommandLine.Option(
-        names = ["-v", "--value"],
-        description = ["Path to a file where the retrieved value will be written (defaults to stdout)"],
-        paramLabel = "VALUE_FILE",
-    )
-    private var output : Path? = null
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        GradleBuildCacheClient(profile).use { client ->
-            client.get(key).thenApply { value ->
-                value?.let {
-                    (output?.let(Files::newOutputStream) ?: System.out).use {
-                        it.write(value)
-                    }
-                } ?: throw NoSuchElementException("No value found for key $key")
-            }.get()
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/HealthCheckCommand.kt

@@ -1,45 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
-import picocli.CommandLine
-import java.security.SecureRandom
-import kotlin.random.Random
-
-@CommandLine.Command(
-    name = "health",
-    description = ["Check server health"],
-    showDefaultValues = true
-)
-class HealthCheckCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        GradleBuildCacheClient(profile).use { client ->
-            val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
-            val nonce = ByteArray(0xa0)
-            random.nextBytes(nonce)
-            client.healthCheck(nonce).thenApply { value ->
-                if(value == null) {
-                    throw IllegalStateException("Empty response from server")
-                }
-                for(i in 0 until nonce.size) {
-                    for(j in value.size - nonce.size until nonce.size) {
-                        if(nonce[i] != value[j]) {
-                            throw IllegalStateException("Server nonce does not match")
-                        }
-                    }
-                }
-            }.get()
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/PasswordHashCommand.kt

@@ -1,13 +1,13 @@
 package net.woggioni.gbcs.cli.impl.commands
 
+import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
 import net.woggioni.gbcs.cli.impl.GbcsCommand
 import net.woggioni.gbcs.cli.impl.converters.OutputStreamConverter
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
 import net.woggioni.jwo.UncloseableOutputStream
 import picocli.CommandLine
+import java.io.BufferedWriter
 import java.io.OutputStream
 import java.io.OutputStreamWriter
-import java.io.PrintWriter
 
 
 @CommandLine.Command(
@@ -20,7 +20,7 @@ class PasswordHashCommand : GbcsCommand() {
         names = ["-o", "--output-file"],
         description = ["Write the output to a file instead of stdout"],
         converter = [OutputStreamConverter::class],
-        showDefaultValue = CommandLine.Help.Visibility.NEVER,
+        defaultValue = "stdout",
         paramLabel = "OUTPUT_FILE"
     )
     private var outputStream: OutputStream = UncloseableOutputStream(System.out)
@@ -30,8 +30,9 @@ class PasswordHashCommand : GbcsCommand() {
         val password2 = String(System.console().readPassword("Type your password again for confirmation:"))
         if(password1 != password2) throw IllegalArgumentException("Passwords do not match")
 
-        PrintWriter(OutputStreamWriter(outputStream, Charsets.UTF_8)).use {
+        BufferedWriter(OutputStreamWriter(outputStream, Charsets.UTF_8)).use {
-            it.println(hashPassword(password1))
+            it.write(hashPassword(password1))
+            it.newLine()
         }
     }
 }

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/PutCommand.kt

@@ -1,48 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.cli.impl.converters.InputStreamConverter
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
-import picocli.CommandLine
-import java.io.InputStream
-
-@CommandLine.Command(
-    name = "put",
-    description = ["Add or replace a value to the cache with the specified key"],
-    showDefaultValues = true
-)
-class PutCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    @CommandLine.Option(
-        names = ["-k", "--key"],
-        description = ["The key for the new value"],
-        paramLabel = "KEY"
-    )
-    private var key : String = ""
-
-    @CommandLine.Option(
-        names = ["-v", "--value"],
-        description = ["Path to a file containing the value to be added (defaults to stdin)"],
-        paramLabel = "VALUE_FILE",
-        converter = [InputStreamConverter::class]
-    )
-    private var value : InputStream = System.`in`
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        GradleBuildCacheClient(profile).use { client ->
-            value.use {
-                client.put(key, it.readAllBytes())
-            }.get()
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/commands/ServerCommand.kt

@@ -1,77 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.cli.impl.converters.DurationConverter
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import net.woggioni.gbcs.common.info
-import net.woggioni.gbcs.server.GradleBuildCacheServer
-import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
-import net.woggioni.jwo.Application
-import net.woggioni.jwo.JWO
-import picocli.CommandLine
-import java.io.ByteArrayOutputStream
-import java.nio.file.Files
-import java.nio.file.Path
-import java.time.Duration
-
-@CommandLine.Command(
-    name = "server",
-    description = ["GBCS server"],
-    showDefaultValues = true
-)
-class ServerCommand(app : Application) : GbcsCommand() {
-
-    private val log = contextLogger()
-
-    private fun createDefaultConfigurationFile(configurationFile: Path) {
-        log.info {
-            "Creating default configuration file at '$configurationFile'"
-        }
-        val defaultConfigurationFileResource = DEFAULT_CONFIGURATION_URL
-        Files.newOutputStream(configurationFile).use { outputStream ->
-            defaultConfigurationFileResource.openStream().use { inputStream ->
-                JWO.copy(inputStream, outputStream)
-            }
-        }
-    }
-
-    @CommandLine.Option(
-        names = ["-t", "--timeout"],
-        description = ["Exit after the specified time"],
-        paramLabel = "TIMEOUT",
-        converter = [DurationConverter::class]
-    )
-    private var timeout: Duration? = null
-
-    @CommandLine.Option(
-        names = ["-c", "--config-file"],
-        description = ["Read the application configuration from this file"],
-        paramLabel = "CONFIG_FILE"
-    )
-    private var configurationFile: Path = findConfigurationFile(app, "gbcs-server.xml")
-
-    override fun run() {
-        if (!Files.exists(configurationFile)) {
-            Files.createDirectories(configurationFile.parent)
-            createDefaultConfigurationFile(configurationFile)
-        }
-
-        val configuration = GradleBuildCacheServer.loadConfiguration(configurationFile)
-        log.debug {
-            ByteArrayOutputStream().also {
-                GradleBuildCacheServer.dumpConfiguration(configuration, it)
-            }.let {
-                "Server configuration:\n${String(it.toByteArray())}"
-            }
-        }
-        val server = GradleBuildCacheServer(configuration)
-        server.run().use { server ->
-            timeout?.let {
-                Thread.sleep(it)
-                server.shutdown()
-            }
-        }
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/converters/DurationConverter.kt

@@ -1,11 +0,0 @@
-package net.woggioni.gbcs.cli.impl.converters
-
-import picocli.CommandLine
-import java.time.Duration
-
-
-class DurationConverter : CommandLine.ITypeConverter<Duration> {
-    override fun convert(value: String): Duration {
-        return Duration.parse(value)
-    }
-}

gbcs-cli/src/main/kotlin/net/woggioni/gbcs/cli/impl/converters/InputStreamConverter.kt

@@ -1,13 +0,0 @@
-package net.woggioni.gbcs.cli.impl.converters
-
-import picocli.CommandLine
-import java.io.InputStream
-import java.nio.file.Files
-import java.nio.file.Paths
-
-
-class InputStreamConverter : CommandLine.ITypeConverter<InputStream> {
-    override fun convert(value: String): InputStream {
-        return Files.newInputStream(Paths.get(value))
-    }
-}

gbcs-cli/src/main/resources/net/woggioni/gbcs/cli/logback.xml

@@ -12,7 +12,10 @@
         </encoder>
     </appender>
 
-    <root level="info">
+    <root level="debug">
         <appender-ref ref="console"/>
     </root>
+    <logger name="io.netty" level="debug"/>
+    <logger name="com.google.code.yanf4j" level="warn"/>
+    <logger name="net.rubyeye.xmemcached" level="warn"/>
 </configuration>

gbcs-client/build.gradle

@@ -1,17 +0,0 @@
-plugins {
-    id 'java-library'
-    alias catalog.plugins.kotlin.jvm
-}
-
-dependencies {
-    implementation project(':gbcs-api')
-    implementation project(':gbcs-common')
-    implementation catalog.picocli
-    implementation catalog.slf4j.api
-    implementation catalog.netty.buffer
-    implementation catalog.netty.codec.http
-
-    testRuntimeOnly catalog.logback.classic
-}
-
-

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

@@ -1,17 +0,0 @@
-module net.woggioni.gbcs.client {
-    requires io.netty.handler;
-    requires io.netty.codec.http;
-    requires io.netty.transport;
-    requires kotlin.stdlib;
-    requires io.netty.common;
-    requires io.netty.buffer;
-    requires java.xml;
-    requires net.woggioni.gbcs.common;
-    requires net.woggioni.gbcs.api;
-    requires io.netty.codec;
-    requires org.slf4j;
-
-    exports net.woggioni.gbcs.client;
-
-    opens net.woggioni.gbcs.client.schema;
-}

gbcs-client/src/main/kotlin/net/woggioni/gbcs/client/Client.kt

@@ -1,344 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.bootstrap.Bootstrap
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
-import io.netty.channel.Channel
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelOption
-import io.netty.channel.ChannelPipeline
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.pool.AbstractChannelPoolHandler
-import io.netty.channel.pool.ChannelPool
-import io.netty.channel.pool.FixedChannelPool
-import io.netty.channel.socket.nio.NioSocketChannel
-import io.netty.handler.codec.DecoderException
-import io.netty.handler.codec.http.DefaultFullHttpRequest
-import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.FullHttpResponse
-import io.netty.handler.codec.http.HttpClientCodec
-import io.netty.handler.codec.http.HttpContentDecompressor
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpMethod
-import io.netty.handler.codec.http.HttpObjectAggregator
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpVersion
-import io.netty.handler.ssl.SslContext
-import io.netty.handler.ssl.SslContextBuilder
-import io.netty.handler.stream.ChunkedWriteHandler
-import io.netty.util.concurrent.Future
-import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.gbcs.client.impl.Parser
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import net.woggioni.gbcs.common.trace
-import java.net.InetSocketAddress
-import java.net.URI
-import java.nio.file.Files
-import java.nio.file.Path
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-import java.time.Duration
-import java.util.Base64
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.atomic.AtomicInteger
-import io.netty.util.concurrent.Future as NettyFuture
-
-
-class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
-    private val group: NioEventLoopGroup
-    private var sslContext: SslContext
-    private val log = contextLogger()
-    private val pool: ChannelPool
-
-    data class Configuration(
-        val profiles: Map<String, Profile>
-    ) {
-        sealed class Authentication {
-            data class TlsClientAuthenticationCredentials(
-                val key: PrivateKey,
-                val certificateChain: Array<X509Certificate>
-            ) : Authentication()
-
-            data class BasicAuthenticationCredentials(val username: String, val password: String) : Authentication()
-        }
-
-        class RetryPolicy(
-            val maxAttempts: Int,
-            val initialDelayMillis: Long,
-            val exp: Double
-        )
-
-        data class Profile(
-            val serverURI: URI,
-            val authentication: Authentication?,
-            val connectionTimeout: Duration?,
-            val maxConnections: Int,
-            val retryPolicy: RetryPolicy?,
-        )
-
-        companion object {
-            fun parse(path: Path): Configuration {
-                return Files.newInputStream(path).use {
-                    Xml.parseXml(path.toUri().toURL(), it)
-                }.let(Parser::parse)
-            }
-        }
-    }
-
-    init {
-        group = NioEventLoopGroup()
-        sslContext = SslContextBuilder.forClient().also { builder ->
-            (profile.authentication as? Configuration.Authentication.TlsClientAuthenticationCredentials)?.let { tlsClientAuthenticationCredentials ->
-                builder.keyManager(
-                    tlsClientAuthenticationCredentials.key,
-                    *tlsClientAuthenticationCredentials.certificateChain
-                )
-            }
-        }.build()
-
-        val (scheme, host, port) = profile.serverURI.run {
-            Triple(
-                if (scheme == null) "http" else profile.serverURI.scheme,
-                host,
-                port.takeIf { it > 0 } ?: if ("https" == scheme.lowercase()) 443 else 80
-            )
-        }
-
-        val bootstrap = Bootstrap().apply {
-            group(group)
-            channel(NioSocketChannel::class.java)
-            option(ChannelOption.TCP_NODELAY, true)
-            option(ChannelOption.SO_KEEPALIVE, true)
-            remoteAddress(InetSocketAddress(host, port))
-            profile.connectionTimeout?.let {
-                option(ChannelOption.CONNECT_TIMEOUT_MILLIS, it.toMillis().toInt())
-            }
-        }
-        val channelPoolHandler = object : AbstractChannelPoolHandler() {
-
-            @Volatile
-            private var connectionCount = AtomicInteger()
-
-            @Volatile
-            private var leaseCount = AtomicInteger()
-
-            override fun channelReleased(ch: Channel) {
-                val activeLeases = leaseCount.decrementAndGet()
-                log.trace {
-                    "Released channel ${ch.id().asShortText()}, number of active leases: $activeLeases"
-                }
-            }
-
-            override fun channelAcquired(ch: Channel) {
-                val activeLeases = leaseCount.getAndIncrement()
-                log.trace {
-                    "Acquired channel ${ch.id().asShortText()}, number of active leases: $activeLeases"
-                }
-            }
-
-            override fun channelCreated(ch: Channel) {
-                val connectionId = connectionCount.getAndIncrement()
-                log.debug {
-                    "Created connection $connectionId, total number of active connections: $connectionId"
-                }
-                ch.closeFuture().addListener {
-                    val activeConnections = connectionCount.decrementAndGet()
-                    log.debug {
-                        "Closed connection $connectionId, total number of active connections: $activeConnections"
-                    }
-                }
-                val pipeline: ChannelPipeline = ch.pipeline()
-
-                // Add SSL handler if needed
-                if ("https".equals(scheme, ignoreCase = true)) {
-                    pipeline.addLast("ssl", sslContext.newHandler(ch.alloc(), host, port))
-                }
-
-                // HTTP handlers
-                pipeline.addLast("codec", HttpClientCodec())
-                pipeline.addLast("decompressor", HttpContentDecompressor())
-                pipeline.addLast("aggregator", HttpObjectAggregator(134217728))
-                pipeline.addLast("chunked", ChunkedWriteHandler())
-            }
-        }
-        pool = FixedChannelPool(bootstrap, channelPoolHandler, profile.maxConnections)
-    }
-
-    private fun executeWithRetry(operation: () -> CompletableFuture<FullHttpResponse>): CompletableFuture<FullHttpResponse> {
-        val retryPolicy = profile.retryPolicy
-        return if (retryPolicy != null) {
-            val outcomeHandler = OutcomeHandler<FullHttpResponse> { outcome ->
-                when (outcome) {
-                    is OperationOutcome.Success -> {
-                        val response = outcome.result
-                        val status = response.status()
-                        when (status) {
-                            HttpResponseStatus.TOO_MANY_REQUESTS -> {
-                                val retryAfter = response.headers()[HttpHeaderNames.RETRY_AFTER]?.let { headerValue ->
-                                    try {
-                                        headerValue.toLong() * 1000
-                                    } catch (nfe: NumberFormatException) {
-                                        null
-                                    }
-                                }
-                                OutcomeHandlerResult.Retry(retryAfter)
-                            }
-
-                            HttpResponseStatus.INTERNAL_SERVER_ERROR, HttpResponseStatus.SERVICE_UNAVAILABLE ->
-                                OutcomeHandlerResult.Retry()
-
-                            else -> OutcomeHandlerResult.DoNotRetry()
-                        }
-                    }
-
-                    is OperationOutcome.Failure -> {
-                        OutcomeHandlerResult.Retry()
-                    }
-                }
-            }
-            executeWithRetry(
-                group,
-                retryPolicy.maxAttempts,
-                retryPolicy.initialDelayMillis.toDouble(),
-                retryPolicy.exp,
-                outcomeHandler,
-                operation
-            )
-        } else {
-            operation()
-        }
-    }
-
-    fun healthCheck(nonce: ByteArray): CompletableFuture<ByteArray?> {
-        return executeWithRetry {
-            sendRequest(profile.serverURI, HttpMethod.TRACE, nonce)
-        }.thenApply {
-            val status = it.status()
-            if (it.status() != HttpResponseStatus.OK) {
-                throw HttpException(status)
-            } else {
-                it.content()
-            }
-        }.thenApply { maybeByteBuf ->
-            maybeByteBuf?.let {
-                val result = ByteArray(it.readableBytes())
-                it.getBytes(0, result)
-                result
-            }
-        }
-    }
-
-    fun get(key: String): CompletableFuture<ByteArray?> {
-        return executeWithRetry {
-            sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
-        }.thenApply {
-            val status = it.status()
-            if (it.status() == HttpResponseStatus.NOT_FOUND) {
-                null
-            } else if (it.status() != HttpResponseStatus.OK) {
-                throw HttpException(status)
-            } else {
-                it.content()
-            }
-        }.thenApply { maybeByteBuf ->
-            maybeByteBuf?.let {
-                val result = ByteArray(it.readableBytes())
-                it.getBytes(0, result)
-                result
-            }
-        }
-    }
-
-    fun put(key: String, content: ByteArray): CompletableFuture<Unit> {
-        return executeWithRetry {
-            sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content)
-        }.thenApply {
-            val status = it.status()
-            if (it.status() != HttpResponseStatus.CREATED && it.status() != HttpResponseStatus.OK) {
-                throw HttpException(status)
-            }
-        }
-    }
-
-    private fun sendRequest(uri: URI, method: HttpMethod, body: ByteArray?): CompletableFuture<FullHttpResponse> {
-        val responseFuture = CompletableFuture<FullHttpResponse>()
-        // Custom handler for processing responses
-        pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
-            override fun operationComplete(channelFuture: Future<Channel>) {
-                if (channelFuture.isSuccess) {
-                    val channel = channelFuture.now
-                    val pipeline = channel.pipeline()
-                    channel.pipeline().addLast("handler", object : SimpleChannelInboundHandler<FullHttpResponse>() {
-                        override fun channelRead0(
-                            ctx: ChannelHandlerContext,
-                            response: FullHttpResponse
-                        ) {
-                            pipeline.removeLast()
-                            pool.release(channel)
-                            responseFuture.complete(response)
-                        }
-
-                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                            val ex = when (cause) {
-                                is DecoderException -> cause.cause
-                                else -> cause
-                            }
-                            responseFuture.completeExceptionally(ex)
-                            ctx.close()
-                            pipeline.removeLast()
-                            pool.release(channel)
-                        }
-                    })
-                    // Prepare the HTTP request
-                    val request: FullHttpRequest = let {
-                        val content: ByteBuf? = body?.takeIf(ByteArray::isNotEmpty)?.let(Unpooled::wrappedBuffer)
-                        DefaultFullHttpRequest(
-                            HttpVersion.HTTP_1_1,
-                            method,
-                            uri.rawPath,
-                            content ?: Unpooled.buffer(0)
-                        ).apply {
-                            headers().apply {
-                                if (content != null) {
-                                    set(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_OCTET_STREAM)
-                                    set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes())
-                                }
-                                set(HttpHeaderNames.HOST, profile.serverURI.host)
-                                set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                                set(
-                                    HttpHeaderNames.ACCEPT_ENCODING,
-                                    HttpHeaderValues.GZIP.toString() + "," + HttpHeaderValues.DEFLATE.toString()
-                                )
-                                // Add basic auth if configured
-                                (profile.authentication as? Configuration.Authentication.BasicAuthenticationCredentials)?.let { credentials ->
-                                    val auth = "${credentials.username}:${credentials.password}"
-                                    val encodedAuth = Base64.getEncoder().encodeToString(auth.toByteArray())
-                                    set(HttpHeaderNames.AUTHORIZATION, "Basic $encodedAuth")
-                                }
-                            }
-                        }
-                    }
-
-                    // Set headers
-                    // Send the request
-                    channel.writeAndFlush(request)
-                } else {
-                    responseFuture.completeExceptionally(channelFuture.cause())
-                }
-            }
-        })
-        return responseFuture
-    }
-
-    fun shutDown(): NettyFuture<*> {
-        return group.shutdownGracefully()
-    }
-
-    override fun close() {
-        shutDown().sync()
-    }
-}

gbcs-client/src/main/kotlin/net/woggioni/gbcs/client/Exception.kt

@@ -1,9 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.handler.codec.http.HttpResponseStatus
-
-class HttpException(private val status : HttpResponseStatus) : RuntimeException(status.reasonPhrase()) {
-
-    override val message: String
-        get() = "Http status ${status.code()}: ${status.reasonPhrase()}"
-}

gbcs-client/src/main/kotlin/net/woggioni/gbcs/client/impl/Parser.kt

@@ -1,108 +0,0 @@
-package net.woggioni.gbcs.client.impl
-
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.client.GradleBuildCacheClient
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import java.net.URI
-import java.nio.file.Files
-import java.nio.file.Path
-import java.security.KeyStore
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-import java.time.Duration
-
-object Parser {
-
-    fun parse(document: Document): GradleBuildCacheClient.Configuration {
-        val root = document.documentElement
-        val profiles = mutableMapOf<String, GradleBuildCacheClient.Configuration.Profile>()
-
-        for (child in root.asIterable()) {
-            val tagName = child.localName
-            when (tagName) {
-                "profile" -> {
-                    val name =
-                        child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
-                    val uri = child.renderAttribute("base-url")?.let(::URI)
-                        ?: throw ConfigurationException("base-url attribute is required")
-                    var authentication: GradleBuildCacheClient.Configuration.Authentication? = null
-                    var retryPolicy: GradleBuildCacheClient.Configuration.RetryPolicy? = null
-                    for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
-                            "tls-client-auth" -> {
-                                val keyStoreFile = gchild.renderAttribute("key-store-file")
-                                val keyStorePassword =
-                                    gchild.renderAttribute("key-store-password")
-                                val keyAlias = gchild.renderAttribute("key-alias")
-                                val keyPassword = gchild.renderAttribute("key-password")
-
-                                val keystore = KeyStore.getInstance("PKCS12").apply {
-                                    Files.newInputStream(Path.of(keyStoreFile)).use {
-                                        load(it, keyStorePassword?.toCharArray())
-                                    }
-                                }
-                                val key = keystore.getKey(keyAlias, keyPassword?.toCharArray()) as PrivateKey
-                                val certChain = keystore.getCertificateChain(keyAlias).asSequence()
-                                    .map { it as X509Certificate }
-                                    .toList()
-                                    .toTypedArray()
-                                authentication =
-                                    GradleBuildCacheClient.Configuration.Authentication.TlsClientAuthenticationCredentials(
-                                        key,
-                                        certChain
-                                    )
-                            }
-
-                            "basic-auth" -> {
-                                val username = gchild.renderAttribute("user")
-                                    ?: throw ConfigurationException("username attribute is required")
-                                val password = gchild.renderAttribute("password")
-                                    ?: throw ConfigurationException("password attribute is required")
-                                authentication =
-                                    GradleBuildCacheClient.Configuration.Authentication.BasicAuthenticationCredentials(
-                                        username,
-                                        password
-                                    )
-                            }
-
-                            "retry-policy" -> {
-                                val maxAttempts =
-                                    gchild.renderAttribute("max-attempts")
-                                        ?.let(String::toInt)
-                                        ?: throw ConfigurationException("max-attempts attribute is required")
-                                val initialDelay =
-                                    gchild.renderAttribute("initial-delay")
-                                        ?.let(Duration::parse)
-                                        ?: Duration.ofSeconds(1)
-                                val exp =
-                                    gchild.renderAttribute("exp")
-                                        ?.let(String::toDouble)
-                                        ?: 2.0f
-                                retryPolicy = GradleBuildCacheClient.Configuration.RetryPolicy(
-                                    maxAttempts,
-                                    initialDelay.toMillis(),
-                                    exp.toDouble()
-                                )
-                            }
-                        }
-                    }
-                    val maxConnections = child.renderAttribute("max-connections")
-                        ?.let(String::toInt)
-                        ?: 50
-                    val connectionTimeout = child.renderAttribute("connection-timeout")
-                        ?.let(Duration::parse)
-                    profiles[name] = GradleBuildCacheClient.Configuration.Profile(
-                        uri,
-                        authentication,
-                        connectionTimeout,
-                        maxConnections,
-                        retryPolicy
-                    )
-                }
-            }
-        }
-        return GradleBuildCacheClient.Configuration(profiles)
-    }
-}

gbcs-client/src/main/kotlin/net/woggioni/gbcs/client/retry.kt

@@ -1,75 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.util.concurrent.EventExecutorGroup
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.TimeUnit
-
-sealed class OperationOutcome<T> {
-    class Success<T>(val result: T) : OperationOutcome<T>()
-    class Failure<T>(val ex: Throwable) : OperationOutcome<T>()
-}
-
-sealed class OutcomeHandlerResult {
-    class Retry(val suggestedDelayMillis: Long? = null) : OutcomeHandlerResult()
-    class DoNotRetry : OutcomeHandlerResult()
-}
-
-fun interface OutcomeHandler<T> {
-    fun shouldRetry(result: OperationOutcome<T>): OutcomeHandlerResult
-}
-
-fun <T> executeWithRetry(
-    eventExecutorGroup: EventExecutorGroup,
-    maxAttempts: Int,
-    initialDelay: Double,
-    exp: Double,
-    outcomeHandler: OutcomeHandler<T>,
-    cb: () -> CompletableFuture<T>
-): CompletableFuture<T> {
-    val finalResult = cb()
-    var future = finalResult
-    var shortCircuit = false
-    for (i in 1 until maxAttempts) {
-        future = future.handle { result, ex ->
-            val operationOutcome = if (ex == null) {
-                OperationOutcome.Success(result)
-            } else {
-                OperationOutcome.Failure(ex.cause ?: ex)
-            }
-            if (shortCircuit) {
-                when(operationOutcome) {
-                    is OperationOutcome.Failure -> throw operationOutcome.ex
-                    is OperationOutcome.Success -> CompletableFuture.completedFuture(operationOutcome.result)
-                }
-            } else {
-                when(val outcomeHandlerResult = outcomeHandler.shouldRetry(operationOutcome)) {
-                    is OutcomeHandlerResult.Retry -> {
-                        val res = CompletableFuture<T>()
-                        val delay = run {
-                            val scheduledDelay = (initialDelay * Math.pow(exp, i.toDouble())).toLong()
-                            outcomeHandlerResult.suggestedDelayMillis?.coerceAtMost(scheduledDelay) ?: scheduledDelay
-                        }
-                        eventExecutorGroup.schedule({
-                            cb().handle { result, ex ->
-                                if (ex == null) {
-                                    res.complete(result)
-                                } else {
-                                    res.completeExceptionally(ex)
-                                }
-                            }
-                        }, delay, TimeUnit.MILLISECONDS)
-                        res
-                    }
-                    is OutcomeHandlerResult.DoNotRetry -> {
-                        shortCircuit = true
-                        when(operationOutcome) {
-                            is OperationOutcome.Failure -> throw operationOutcome.ex
-                            is OperationOutcome.Success -> CompletableFuture.completedFuture(operationOutcome.result)
-                        }
-                    }
-                }
-            }
-        }.thenCompose { it }
-    }
-    return future
-}

gbcs-client/src/main/resources/net/woggioni/gbcs/client/schema/gbcs-client.xsd

@@ -1,50 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xs:schema targetNamespace="urn:net.woggioni.gbcs.client"
-           xmlns:xs="http://www.w3.org/2001/XMLSchema"
-           xmlns:gbcs-client="urn:net.woggioni.gbcs.client"
-           elementFormDefault="unqualified"
->
-    <xs:element name="profiles" type="gbcs-client:profilesType"/>
-
-    <xs:complexType name="profilesType">
-        <xs:sequence minOccurs="0">
-            <xs:element name="profile" type="gbcs-client:profileType" maxOccurs="unbounded"/>
-        </xs:sequence>
-    </xs:complexType>
-
-    <xs:complexType name="profileType">
-        <xs:sequence>
-            <xs:choice>
-                <xs:element name="no-auth" type="gbcs-client:noAuthType"/>
-                <xs:element name="basic-auth" type="gbcs-client:basicAuthType"/>
-                <xs:element name="tls-client-auth" type="gbcs-client:tlsClientAuthType"/>
-            </xs:choice>
-            <xs:element name="retry-policy" type="gbcs-client:retryType" minOccurs="0"/>
-        </xs:sequence>
-        <xs:attribute name="name" type="xs:token" use="required"/>
-        <xs:attribute name="base-url" type="xs:anyURI" use="required"/>
-        <xs:attribute name="max-connections" type="xs:positiveInteger" default="50"/>
-        <xs:attribute name="connection-timeout" type="xs:duration"/>
-    </xs:complexType>
-
-    <xs:complexType name="noAuthType"/>
-
-    <xs:complexType name="basicAuthType">
-        <xs:attribute name="user" type="xs:token" use="required"/>
-        <xs:attribute name="password" type="xs:string" use="required"/>
-    </xs:complexType>
-
-    <xs:complexType name="tlsClientAuthType">
-        <xs:attribute name="key-store-file" type="xs:anyURI" use="required"/>
-        <xs:attribute name="key-store-password" type="xs:string" use="required"/>
-        <xs:attribute name="key-alias" type="xs:token" use="required"/>
-        <xs:attribute name="key-password" type="xs:string" use="optional"/>
-    </xs:complexType>
-
-    <xs:complexType name="retryType">
-        <xs:attribute name="max-attempts" type="xs:positiveInteger" use="required"/>
-        <xs:attribute name="initial-delay" type="xs:duration" default="PT1S"/>
-        <xs:attribute name="exp" type="xs:double" default="2.0"/>
-    </xs:complexType>
-
-</xs:schema>

gbcs-client/src/test/kotlin/net/woggioni/gbcs/client/RetryTest.kt

@@ -1,148 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.util.concurrent.DefaultEventExecutorGroup
-import io.netty.util.concurrent.EventExecutorGroup
-import net.woggioni.gbcs.common.contextLogger
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.extension.ExtensionContext
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.Arguments
-import org.junit.jupiter.params.provider.ArgumentsProvider
-import org.junit.jupiter.params.provider.ArgumentsSource
-import java.util.concurrent.CompletableFuture
-import java.util.stream.Stream
-import kotlin.random.Random
-
-class RetryTest {
-
-    data class TestArgs(
-        val seed: Int,
-        val maxAttempt: Int,
-        val initialDelay: Double,
-        val exp: Double,
-    )
-
-    class TestArguments : ArgumentsProvider {
-        override fun provideArguments(context: ExtensionContext): Stream<out Arguments> {
-            return Stream.of(
-                TestArgs(
-                    seed = 101325,
-                    maxAttempt = 5,
-                    initialDelay = 50.0,
-                    exp = 2.0,
-                ),
-                TestArgs(
-                    seed = 101325,
-                    maxAttempt = 20,
-                    initialDelay = 100.0,
-                    exp = 1.1,
-                ),
-                TestArgs(
-                    seed = 123487,
-                    maxAttempt = 20,
-                    initialDelay = 100.0,
-                    exp = 2.0,
-                ),
-                TestArgs(
-                    seed = 20082024,
-                    maxAttempt = 10,
-                    initialDelay = 100.0,
-                    exp = 2.0,
-                )
-            ).map {
-                object: Arguments {
-                    override fun get() = arrayOf(it)
-                }
-            }
-        }
-    }
-
-    @ArgumentsSource(TestArguments::class)
-    @ParameterizedTest
-    fun test(testArgs: TestArgs) {
-        val log = contextLogger()
-        log.debug("Start")
-        val executor: EventExecutorGroup = DefaultEventExecutorGroup(1)
-        val attempts = mutableListOf<Pair<Long, OperationOutcome<Int>>>()
-        val outcomeHandler = OutcomeHandler<Int> { outcome ->
-            when(outcome) {
-                is OperationOutcome.Success -> {
-                    if(outcome.result % 10 == 0) {
-                        OutcomeHandlerResult.DoNotRetry()
-                    } else {
-                        OutcomeHandlerResult.Retry(null)
-                    }
-                }
-                is OperationOutcome.Failure -> {
-                    when(outcome.ex) {
-                        is IllegalStateException -> {
-                            log.debug(outcome.ex.message, outcome.ex)
-                            OutcomeHandlerResult.Retry(null)
-                        }
-                        else -> {
-                            OutcomeHandlerResult.DoNotRetry()
-                        }
-                    }
-                }
-            }
-        }
-        val random = Random(testArgs.seed)
-
-        val future =
-            executeWithRetry(executor, testArgs.maxAttempt, testArgs.initialDelay, testArgs.exp, outcomeHandler) {
-                val now = System.nanoTime()
-                val result = CompletableFuture<Int>()
-                executor.submit {
-                    val n = random.nextInt(0, Integer.MAX_VALUE)
-                    log.debug("Got new number: {}", n)
-                    if(n % 3 == 0) {
-                        val ex = IllegalStateException("Value $n can be divided by 3")
-                        result.completeExceptionally(ex)
-                        attempts += now to OperationOutcome.Failure(ex)
-                    } else if(n % 7 == 0) {
-                        val ex = RuntimeException("Value $n can be divided by 7")
-                        result.completeExceptionally(ex)
-                        attempts += now to OperationOutcome.Failure(ex)
-                    } else {
-                        result.complete(n)
-                        attempts += now to OperationOutcome.Success(n)
-                    }
-                }
-                result
-            }
-        Assertions.assertTrue(attempts.size <= testArgs.maxAttempt)
-        val result = future.handle { res, ex ->
-            if(ex != null) {
-                val err = ex.cause ?: ex
-                log.debug(err.message, err)
-                OperationOutcome.Failure(err)
-            } else {
-                OperationOutcome.Success(res)
-            }
-        }.get()
-        for ((index, attempt) in attempts.withIndex()) {
-            val (timestamp, value) = attempt
-            if (index > 0) {
-                /* Check the delay for subsequent attempts is correct */
-                val previousAttempt = attempts[index - 1]
-                val expectedTimestamp =
-                    previousAttempt.first + testArgs.initialDelay * Math.pow(testArgs.exp, index.toDouble()) * 1e6
-                val actualTimestamp = timestamp
-                val err = Math.abs(expectedTimestamp - actualTimestamp) / expectedTimestamp
-                Assertions.assertTrue(err < 1e-3)
-            }
-            if (index == attempts.size - 1 && index < testArgs.maxAttempt - 1) {
-                /*
-                 * If the last attempt index is lower than the maximum number of attempts, then
-                 * check the outcome handler returns DoNotRetry
-                 */
-                Assertions.assertTrue(outcomeHandler.shouldRetry(value) is OutcomeHandlerResult.DoNotRetry)
-            } else if (index < attempts.size - 1) {
-                /*
-                 * If the attempt is not the last attempt check the outcome handler returns Retry
-                 */
-                Assertions.assertTrue(outcomeHandler.shouldRetry(value) is OutcomeHandlerResult.Retry)
-            }
-        }
-    }
-}

gbcs-client/src/test/resources/logback.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE configuration>
-
-<configuration>
-    <import class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
-    <import class="ch.qos.logback.core.ConsoleAppender"/>
-
-    <appender name="console" class="ConsoleAppender">
-        <target>System.err</target>
-        <encoder class="PatternLayoutEncoder">
-            <pattern>%d [%highlight(%-5level)] \(%thread\) %logger{36} -%kvp- %msg %n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="info">
-        <appender-ref ref="console"/>
-    </root>
-    <logger name="io.netty" level="info"/>
-    <logger name="com.google.code.yanf4j" level="warn"/>
-    <logger name="net.rubyeye.xmemcached" level="warn"/>
-</configuration>

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

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs-client:profiles xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-                      xmlns:gbcs-client="urn:net.woggioni.gbcs.client"
-                      xs:schemaLocation="urn:net.woggioni.gbcs.client jms://net.woggioni.gbcs.client/net/woggioni/gbcs/client/schema/gbcs-client.xsd"
-                      >
-    <profile name="profile1" base-url="https://gbcs1.example.com/">
-        <tls-client-auth
-                key-store-file="keystore.pfx"
-                key-store-password="password"
-                key-alias="woggioni@c962475fa38"
-                key-password="key-password"/>
-    </profile>
-    <profile name="profile2" base-url="https://gbcs2.example.com/">
-        <basic-auth user="user" password="password"/>
-    </profile>
-</gbcs-client:profiles>

gbcs-common/build.gradle

@@ -1,21 +0,0 @@
-
-plugins {
-    id 'java-library'
-    id 'maven-publish'
-    alias catalog.plugins.kotlin.jvm
-}
-
-dependencies {
-    implementation project(':gbcs-api')
-    implementation catalog.slf4j.api
-    implementation catalog.jwo
-    implementation catalog.netty.buffer
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from(components["java"])
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-module net.woggioni.gbcs.common {
-    requires java.xml;
-    requires java.logging;
-    requires org.slf4j;
-    requires kotlin.stdlib;
-    requires net.woggioni.jwo;
-    requires io.netty.buffer;
-
-    provides java.net.spi.URLStreamHandlerProvider with net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory;
-    exports net.woggioni.gbcs.common;
-}

gbcs-common/src/main/kotlin/net/woggioni/gbcs/common/ByteBufInputStream.kt

@@ -1,25 +0,0 @@
-package net.woggioni.gbcs.common
-
-import io.netty.buffer.ByteBuf
-import java.io.InputStream
-
-class ByteBufInputStream(private val buf : ByteBuf) : InputStream() {
-    override fun read(): Int {
-        return buf.takeIf {
-            it.readableBytes() > 0
-        }?.let(ByteBuf::readByte)
-            ?.let(Byte::toInt) ?: -1
-    }
-
-    override fun read(b: ByteArray, off: Int, len: Int): Int {
-        val readableBytes = buf.readableBytes()
-        if(readableBytes == 0) return -1
-        val result = len.coerceAtMost(readableBytes)
-        buf.readBytes(b, off, result)
-        return result
-    }
-
-    override fun close() {
-        buf.release()
-    }
-}

gbcs-common/src/main/kotlin/net/woggioni/gbcs/common/ByteBufOutputStream.kt

@@ -1,19 +0,0 @@
-package net.woggioni.gbcs.common
-
-import io.netty.buffer.ByteBuf
-import java.io.InputStream
-import java.io.OutputStream
-
-class ByteBufOutputStream(private val buf : ByteBuf) : OutputStream() {
-    override fun write(b: Int) {
-        buf.writeByte(b)
-    }
-
-    override fun write(b: ByteArray, off: Int, len: Int) {
-        buf.writeBytes(b, off, len)
-    }
-
-    override fun close() {
-        buf.release()
-    }
-}

gbcs-common/src/main/kotlin/net/woggioni/gbcs/common/Exception.kt

@@ -1,7 +0,0 @@
-package net.woggioni.gbcs.common
-
-class ResourceNotFoundException(msg : String? = null, cause: Throwable? = null) : RuntimeException(msg, cause) {
-}
-
-class ModuleNotFoundException(msg : String? = null, cause: Throwable? = null) : RuntimeException(msg, cause) {
-}

gbcs-common/src/main/kotlin/net/woggioni/gbcs/common/GBCS.kt

@@ -1,29 +0,0 @@
-package net.woggioni.gbcs.common
-
-import net.woggioni.jwo.JWO
-import java.net.URI
-import java.net.URL
-import java.security.MessageDigest
-
-object GBCS {
-    fun String.toUrl() : URL = URL.of(URI(this), null)
-
-    const val GBCS_NAMESPACE_URI: String = "urn:net.woggioni.gbcs.server"
-    const val GBCS_PREFIX: String = "gbcs"
-    const val XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"
-
-    fun digest(
-        data: ByteArray,
-        md: MessageDigest = MessageDigest.getInstance("MD5")
-    ): ByteArray {
-        md.update(data)
-        return md.digest()
-    }
-
-    fun digestString(
-        data: ByteArray,
-        md: MessageDigest = MessageDigest.getInstance("MD5")
-    ): String {
-        return JWO.bytesToHex(digest(data, md))
-    }
-}

gbcs-common/src/main/resources/META-INF/services/java.net.spi.URLStreamHandlerProvider

@@ -1 +0,0 @@
-net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory

gbcs-memcached/build.gradle

@@ -1,3 +1,6 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
     id 'java-library'
     id 'maven-publish'
@@ -6,10 +9,10 @@ plugins {
 
 configurations {
     bundle {
+        extendsFrom runtimeClasspath
         canBeResolved = true
         canBeConsumed = false
         visible = false
-        transitive = false
 
         resolutionStrategy {
             dependencies {
@@ -19,30 +22,21 @@ configurations {
             }
         }
     }
-
-    release {
-        transitive = false
-        canBeConsumed = true
-        canBeResolved = true
-        visible = true
-    }
 }
-
 dependencies {
-    implementation project(':gbcs-common')
+    compileOnly project(':gbcs-base')
-    implementation project(':gbcs-api')
+    compileOnly project(':gbcs-api')
-    implementation catalog.jwo
+    compileOnly catalog.jwo
-    implementation catalog.slf4j.api
+    implementation catalog.xmemcached
-    implementation catalog.netty.common
-    implementation catalog.netty.codec.memcache
-
-    bundle catalog.netty.codec.memcache
-
-    testRuntimeOnly catalog.logback.classic
 }
 
-tasks.named(JavaPlugin.TEST_TASK_NAME, Test) {
+tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
-    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
+    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) {
@@ -55,14 +49,16 @@ tasks.named(BasePlugin.ASSEMBLE_TASK_NAME) {
     dependsOn(bundleTask)
 }
 
-artifacts {
+def bundleArtifact = artifacts.add('archives', bundleTask.get().archiveFile.get().asFile) {
-    release(bundleTask)
+    type = 'tar'
+    builtBy bundleTask
 }
 
+
 publishing {
     publications {
         maven(MavenPublication) {
-            artifact bundleTask
+            artifact bundleArtifact
         }
     }
 }

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

@@ -0,0 +1,14 @@
+import net.woggioni.gbcs.api.CacheProvider;
+
+module net.woggioni.gbcs.memcached {
+    requires net.woggioni.gbcs.base;
+    requires net.woggioni.gbcs.api;
+    requires com.googlecode.xmemcached;
+    requires net.woggioni.jwo;
+    requires java.xml;
+    requires kotlin.stdlib;
+
+    provides CacheProvider with net.woggioni.gbcs.memcached.MemcachedCacheProvider;
+
+    opens net.woggioni.gbcs.memcached.schema;
+}

gbcs-memcached/src/main/kotlin/net/woggioni/gbcs/memcached/MemcachedCache.kt

@@ -0,0 +1,60 @@
+package net.woggioni.gbcs.memcached
+
+import net.rubyeye.xmemcached.MemcachedClient
+import net.rubyeye.xmemcached.XMemcachedClientBuilder
+import net.rubyeye.xmemcached.command.BinaryCommandFactory
+import net.rubyeye.xmemcached.transcoders.CompressionMode
+import net.rubyeye.xmemcached.transcoders.SerializingTranscoder
+import net.woggioni.gbcs.api.Cache
+import net.woggioni.gbcs.api.exception.ContentTooLargeException
+import net.woggioni.gbcs.base.HostAndPort
+import net.woggioni.jwo.JWO
+import java.io.ByteArrayInputStream
+import java.net.InetSocketAddress
+import java.nio.channels.Channels
+import java.nio.channels.ReadableByteChannel
+import java.nio.charset.StandardCharsets
+import java.security.MessageDigest
+import java.time.Duration
+
+class MemcachedCache(
+    servers: List<HostAndPort>,
+    private val maxAge: Duration,
+    maxSize : Int,
+    digestAlgorithm: String?,
+    compressionMode: CompressionMode,
+) : Cache {
+    private val memcachedClient = XMemcachedClientBuilder(
+        servers.stream().map { addr: HostAndPort -> InetSocketAddress(addr.host, addr.port) }.toList()
+    ).apply {
+        commandFactory = BinaryCommandFactory()
+        digestAlgorithm?.let { dAlg ->
+            setKeyProvider { key ->
+                val md = MessageDigest.getInstance(dAlg)
+                md.update(key.toByteArray(StandardCharsets.UTF_8))
+                JWO.bytesToHex(md.digest())
+            }
+        }
+        transcoder = SerializingTranscoder(maxSize).apply {
+            setCompressionMode(compressionMode)
+        }
+    }.build()
+
+    override fun get(key: String): ReadableByteChannel? {
+        return memcachedClient.get<ByteArray>(key)
+            ?.let(::ByteArrayInputStream)
+            ?.let(Channels::newChannel)
+    }
+
+    override fun put(key: String, content: ByteArray) {
+        try {
+            memcachedClient[key, maxAge.toSeconds().toInt()] = content
+        } catch (e: IllegalArgumentException) {
+            throw ContentTooLargeException(e.message, e)
+        }
+    }
+
+    override fun close() {
+        memcachedClient.shutdown()
+    }
+}

gbcs-memcached/src/main/kotlin/net/woggioni/gbcs/memcached/MemcachedCacheConfiguration.kt

@@ -0,0 +1,26 @@
+package net.woggioni.gbcs.memcached
+
+import net.rubyeye.xmemcached.transcoders.CompressionMode
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.base.HostAndPort
+import java.time.Duration
+
+data class MemcachedCacheConfiguration(
+    var servers: List<HostAndPort>,
+    var maxAge: Duration = Duration.ofDays(1),
+    var maxSize: Int = 0x100000,
+    var digestAlgorithm: String? = null,
+    var compressionMode: CompressionMode = CompressionMode.ZIP,
+) : Configuration.Cache {
+    override fun materialize() = MemcachedCache(
+        servers,
+        maxAge,
+        maxSize,
+        digestAlgorithm,
+        compressionMode
+    )
+
+    override fun getNamespaceURI() = "urn:net.woggioni.gbcs-memcached"
+
+    override fun getTypeName() = "memcachedCacheType"
+}

gbcs-memcached/src/main/kotlin/net/woggioni/gbcs/memcached/MemcachedCacheProvider.kt

@@ -0,0 +1,85 @@
+package net.woggioni.gbcs.memcached
+
+import net.rubyeye.xmemcached.transcoders.CompressionMode
+import net.woggioni.gbcs.api.CacheProvider
+import net.woggioni.gbcs.base.GBCS
+import net.woggioni.gbcs.base.HostAndPort
+import net.woggioni.gbcs.base.Xml
+import net.woggioni.gbcs.base.Xml.Companion.asIterable
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import java.time.Duration
+import java.util.zip.Deflater
+
+class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
+    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd"
+
+    override fun getXmlType() = "memcachedCacheType"
+
+    override fun getXmlNamespace()= "urn:net.woggioni.gbcs-memcached"
+
+    override fun deserialize(el: Element): MemcachedCacheConfiguration {
+        val servers = mutableListOf<HostAndPort>()
+        val maxAge = el.getAttribute("max-age")
+            .takeIf(String::isNotEmpty)
+            ?.let(Duration::parse)
+            ?: Duration.ofDays(1)
+        val maxSize = el.getAttribute("max-size")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toInt)
+            ?: 0x100000
+        val enableCompression = el.getAttribute("enable-compression")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toBoolean)
+            ?: false
+        val compressionMode = el.getAttribute("compression-mode")
+            .takeIf(String::isNotEmpty)
+            ?.let {
+                when(it) {
+                    "gzip" -> CompressionMode.GZIP
+                    "zip" -> CompressionMode.ZIP
+                    else -> CompressionMode.ZIP
+                }
+            }
+            ?: CompressionMode.ZIP
+        val digestAlgorithm = el.getAttribute("digest").takeIf(String::isNotEmpty)
+        for (child in el.asIterable()) {
+            when (child.nodeName) {
+                "server" -> {
+                    servers.add(HostAndPort(child.getAttribute("host"), child.getAttribute("port").toInt()))
+                }
+            }
+        }
+
+        return MemcachedCacheConfiguration(
+            servers,
+            maxAge,
+            maxSize,
+            digestAlgorithm,
+            compressionMode,
+        )
+    }
+
+    override fun serialize(doc: Document, cache : MemcachedCacheConfiguration) = cache.run {
+        val result = doc.createElementNS(xmlNamespace,"cache")
+        Xml.of(doc, result) {
+            attr("xs:type", xmlType, GBCS.XML_SCHEMA_NAMESPACE_URI)
+            for (server in servers) {
+                node("server", xmlNamespace) {
+                    attr("host", server.host)
+                    attr("port", server.port.toString())
+                }
+            }
+            attr("max-age", maxAge.toString())
+            attr("max-size", maxSize.toString())
+            digestAlgorithm?.let { digestAlgorithm ->
+                attr("digest", digestAlgorithm)
+            }
+            attr("compression-mode", when(compressionMode) {
+                CompressionMode.GZIP -> "gzip"
+                CompressionMode.ZIP -> "zip"
+            })
+        }
+        result
+    }
+}

gbcs-memcached/src/main/resources/META-INF/services/net.woggioni.gbcs.api.CacheProvider

@@ -0,0 +1 @@
+net.woggioni.gbcs.memcached.MemcachedCacheProvider

gbcs-memcached/src/main/resources/net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd

@@ -1,28 +1,26 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xs:schema targetNamespace="urn:net.woggioni.gbcs.server.memcache"
+<xs:schema targetNamespace="urn:net.woggioni.gbcs-memcached"
-           xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
+           xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
-           xmlns:gbcs="urn:net.woggioni.gbcs.server"
+           xmlns:gbcs="urn:net.woggioni.gbcs"
            xmlns:xs="http://www.w3.org/2001/XMLSchema">
 
-    <xs:import schemaLocation="jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd" namespace="urn:net.woggioni.gbcs.server"/>
+    <xs:import schemaLocation="classpath:net/woggioni/gbcs/schema/gbcs.xsd" namespace="urn:net.woggioni.gbcs"/>
 
-    <xs:complexType name="memcacheServerType">
+    <xs:complexType name="memcachedServerType">
-        <xs:attribute name="host" type="xs:token" use="required"/>
+        <xs:attribute name="host" type="xs:string" use="required"/>
         <xs:attribute name="port" type="xs:positiveInteger" use="required"/>
-        <xs:attribute name="connection-timeout" type="xs:duration"/>
-        <xs:attribute name="max-connections" type="xs:positiveInteger" default="1"/>
     </xs:complexType>
 
-    <xs:complexType name="memcacheCacheType">
+    <xs:complexType name="memcachedCacheType">
         <xs:complexContent>
             <xs:extension base="gbcs:cacheType">
                 <xs:sequence maxOccurs="unbounded">
-                    <xs:element name="server" type="gbcs-memcache:memcacheServerType"/>
+                    <xs:element name="server" type="gbcs-memcached:memcachedServerType"/>
                 </xs:sequence>
                 <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
                 <xs:attribute name="max-size" type="xs:unsignedInt" default="1048576"/>
                 <xs:attribute name="digest" type="xs:token" />
-                <xs:attribute name="compression-mode" type="gbcs-memcache:compressionType"/>
+                <xs:attribute name="compression-type" type="gbcs-memcached:compressionType" default="deflate"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>

gbcs-server-memcache/src/main/java/module-info.java

@@ -1,19 +0,0 @@
-import net.woggioni.gbcs.api.CacheProvider;
-
-module net.woggioni.gbcs.server.memcache {
-    requires net.woggioni.gbcs.common;
-    requires net.woggioni.gbcs.api;
-    requires net.woggioni.jwo;
-    requires java.xml;
-    requires kotlin.stdlib;
-    requires io.netty.transport;
-    requires io.netty.codec;
-    requires io.netty.codec.memcache;
-    requires io.netty.common;
-    requires io.netty.buffer;
-    requires org.slf4j;
-
-    provides CacheProvider with net.woggioni.gbcs.server.memcache.MemcacheCacheProvider;
-
-    opens net.woggioni.gbcs.server.memcache.schema;
-}

gbcs-server-memcache/src/main/kotlin/net/woggioni/gbcs/server/memcache/Exception.kt

@@ -1,4 +0,0 @@
-package net.woggioni.gbcs.server.memcache
-
-class MemcacheException(status : Short, msg : String? = null, cause : Throwable? = null)
-    : RuntimeException(msg ?: "Memcached status $status", cause)

gbcs-server-memcache/src/main/kotlin/net/woggioni/gbcs/server/memcache/MemcacheCache.kt

@@ -1,23 +0,0 @@
-package net.woggioni.gbcs.server.memcache
-
-import io.netty.buffer.ByteBuf
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.server.memcache.client.MemcacheClient
-import java.nio.channels.ReadableByteChannel
-import java.util.concurrent.CompletableFuture
-
-class MemcacheCache(private val cfg : MemcacheCacheConfiguration) : Cache {
-    private val memcacheClient = MemcacheClient(cfg)
-
-    override fun get(key: String): CompletableFuture<ReadableByteChannel?> {
-        return memcacheClient.get(key)
-    }
-
-    override fun put(key: String, content: ByteBuf): CompletableFuture<Void> {
-        return memcacheClient.put(key, content, cfg.maxAge)
-    }
-
-    override fun close() {
-        memcacheClient.close()
-    }
-}

gbcs-server-memcache/src/main/kotlin/net/woggioni/gbcs/server/memcache/MemcacheCacheConfiguration.kt

@@ -1,40 +0,0 @@
-package net.woggioni.gbcs.server.memcache
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.HostAndPort
-import java.time.Duration
-
-data class MemcacheCacheConfiguration(
-    val servers: List<Server>,
-    val maxAge: Duration = Duration.ofDays(1),
-    val maxSize: Int = 0x100000,
-    val digestAlgorithm: String? = null,
-    val compressionMode: CompressionMode? = null,
-) : Configuration.Cache {
-
-    enum class CompressionMode {
-        /**
-         * Gzip mode
-         */
-        GZIP,
-
-        /**
-         * Deflate mode
-         */
-        DEFLATE
-    }
-
-    data class Server(
-        val endpoint : HostAndPort,
-        val connectionTimeoutMillis : Int?,
-        val maxConnections : Int
-    )
-
-
-    override fun materialize() = MemcacheCache(this)
-
-    override fun getNamespaceURI() = "urn:net.woggioni.gbcs.server.memcache"
-
-    override fun getTypeName() = "memcacheCacheType"
-}
-

gbcs-server-memcache/src/main/kotlin/net/woggioni/gbcs/server/memcache/MemcacheCacheProvider.kt

@@ -1,101 +0,0 @@
-package net.woggioni.gbcs.server.memcache
-
-import net.woggioni.gbcs.api.CacheProvider
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.common.GBCS
-import net.woggioni.gbcs.common.HostAndPort
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import org.w3c.dom.Element
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-
-
-class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd"
-
-    override fun getXmlType() = "memcacheCacheType"
-
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcache"
-
-    val xmlNamespacePrefix : String
-        get() = "gbcs-memcache"
-
-    override fun deserialize(el: Element): MemcacheCacheConfiguration {
-        val servers = mutableListOf<MemcacheCacheConfiguration.Server>()
-        val maxAge = el.renderAttribute("max-age")
-            ?.let(Duration::parse)
-            ?: Duration.ofDays(1)
-        val maxSize = el.renderAttribute("max-size")
-            ?.let(String::toInt)
-            ?: 0x100000
-        val compressionMode = el.renderAttribute("compression-mode")
-            ?.let {
-                when (it) {
-                    "gzip" -> MemcacheCacheConfiguration.CompressionMode.GZIP
-                    "deflate" -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
-                    else -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
-                }
-            }
-            ?: MemcacheCacheConfiguration.CompressionMode.DEFLATE
-        val digestAlgorithm = el.renderAttribute("digest")
-        for (child in el.asIterable()) {
-            when (child.nodeName) {
-                "server" -> {
-                    val host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
-                    val port = child.renderAttribute("port")?.toInt() ?: throw ConfigurationException("port attribute is required")
-                    val maxConnections = child.renderAttribute("max-connections")?.toInt() ?: 1
-                    val connectionTimeout = child.renderAttribute("connection-timeout")
-                        ?.let(Duration::parse)
-                        ?.let(Duration::toMillis)
-                        ?.let(Long::toInt)
-                        ?: 10000
-                    servers.add(MemcacheCacheConfiguration.Server(HostAndPort(host, port), connectionTimeout, maxConnections))
-                }
-            }
-        }
-
-        return MemcacheCacheConfiguration(
-            servers,
-            maxAge,
-            maxSize,
-            digestAlgorithm,
-            compressionMode,
-        )
-    }
-
-    override fun serialize(doc: Document, cache: MemcacheCacheConfiguration) = cache.run {
-        val result = doc.createElement("cache")
-        Xml.of(doc, result) {
-            attr("xmlns:${xmlNamespacePrefix}", xmlNamespace, namespaceURI = "http://www.w3.org/2000/xmlns/")
-
-            attr("xs:type", "${xmlNamespacePrefix}:$xmlType", GBCS.XML_SCHEMA_NAMESPACE_URI)
-            for (server in servers) {
-                node("server") {
-                    attr("host", server.endpoint.host)
-                    attr("port", server.endpoint.port.toString())
-                    server.connectionTimeoutMillis?.let { connectionTimeoutMillis ->
-                        attr("connection-timeout", Duration.of(connectionTimeoutMillis.toLong(), ChronoUnit.MILLIS).toString())
-                    }
-                    attr("max-connections", server.maxConnections.toString())
-                }
-            }
-            attr("max-age", maxAge.toString())
-            attr("max-size", maxSize.toString())
-            digestAlgorithm?.let { digestAlgorithm ->
-                attr("digest", digestAlgorithm)
-            }
-            compressionMode?.let { compressionMode ->
-                attr(
-                    "compression-mode", when (compressionMode) {
-                        MemcacheCacheConfiguration.CompressionMode.GZIP -> "gzip"
-                        MemcacheCacheConfiguration.CompressionMode.DEFLATE -> "deflate"
-                    }
-                )
-            }
-        }
-        result
-    }
-}

gbcs-server-memcache/src/main/kotlin/net/woggioni/gbcs/server/memcache/client/MemcacheClient.kt

@@ -1,258 +0,0 @@
-package net.woggioni.gbcs.server.memcache.client
-
-
-import io.netty.bootstrap.Bootstrap
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
-import io.netty.channel.Channel
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelOption
-import io.netty.channel.ChannelPipeline
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.pool.AbstractChannelPoolHandler
-import io.netty.channel.pool.ChannelPool
-import io.netty.channel.pool.FixedChannelPool
-import io.netty.channel.socket.nio.NioSocketChannel
-import io.netty.handler.codec.DecoderException
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheClientCodec
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheObjectAggregator
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
-import io.netty.handler.codec.memcache.binary.DefaultFullBinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.FullBinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.FullBinaryMemcacheResponse
-import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.gbcs.common.ByteBufInputStream
-import net.woggioni.gbcs.common.ByteBufOutputStream
-import net.woggioni.gbcs.common.GBCS.digest
-import net.woggioni.gbcs.common.HostAndPort
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.server.memcache.MemcacheCacheConfiguration
-import net.woggioni.gbcs.server.memcache.MemcacheException
-import net.woggioni.jwo.JWO
-import java.io.ByteArrayOutputStream
-import java.net.InetSocketAddress
-import java.nio.channels.Channels
-import java.nio.channels.ReadableByteChannel
-import java.security.MessageDigest
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.ConcurrentHashMap
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.GZIPInputStream
-import java.util.zip.GZIPOutputStream
-import java.util.zip.InflaterInputStream
-import io.netty.util.concurrent.Future as NettyFuture
-
-
-class MemcacheClient(private val cfg: MemcacheCacheConfiguration) : AutoCloseable {
-
-    private companion object {
-        @JvmStatic
-        private val log = contextLogger()
-    }
-
-    private val group: NioEventLoopGroup
-    private val connectionPool: MutableMap<HostAndPort, ChannelPool> = ConcurrentHashMap()
-
-    init {
-        group = NioEventLoopGroup()
-    }
-
-    private fun newConnectionPool(server: MemcacheCacheConfiguration.Server): FixedChannelPool {
-        val bootstrap = Bootstrap().apply {
-            group(group)
-            channel(NioSocketChannel::class.java)
-            option(ChannelOption.SO_KEEPALIVE, true)
-            remoteAddress(InetSocketAddress(server.endpoint.host, server.endpoint.port))
-            server.connectionTimeoutMillis?.let {
-                option(ChannelOption.CONNECT_TIMEOUT_MILLIS, it)
-            }
-        }
-        val channelPoolHandler = object : AbstractChannelPoolHandler() {
-
-            override fun channelCreated(ch: Channel) {
-                val pipeline: ChannelPipeline = ch.pipeline()
-                pipeline.addLast(BinaryMemcacheClientCodec())
-                pipeline.addLast(BinaryMemcacheObjectAggregator(Integer.MAX_VALUE))
-            }
-        }
-        return FixedChannelPool(bootstrap, channelPoolHandler, server.maxConnections)
-    }
-
-
-    private fun sendRequest(request: FullBinaryMemcacheRequest): CompletableFuture<FullBinaryMemcacheResponse> {
-
-        val server = cfg.servers.let { servers ->
-            if (servers.size > 1) {
-                val key = request.key().duplicate()
-                var checksum = 0
-                while (key.readableBytes() > 4) {
-                    val byte = key.readInt()
-                    checksum = checksum xor byte
-                }
-                while (key.readableBytes() > 0) {
-                    val byte = key.readByte()
-                    checksum = checksum xor byte.toInt()
-                }
-                servers[checksum % servers.size]
-            } else {
-                servers.first()
-            }
-        }
-
-        val response = CompletableFuture<FullBinaryMemcacheResponse>()
-        // Custom handler for processing responses
-        val pool = connectionPool.computeIfAbsent(server.endpoint) {
-            newConnectionPool(server)
-        }
-        pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
-            override fun operationComplete(channelFuture: NettyFuture<Channel>) {
-                if (channelFuture.isSuccess) {
-                    val channel = channelFuture.now
-                    val pipeline = channel.pipeline()
-                    channel.pipeline()
-                        .addLast("client-handler", object : SimpleChannelInboundHandler<FullBinaryMemcacheResponse>() {
-                            override fun channelRead0(
-                                ctx: ChannelHandlerContext,
-                                msg: FullBinaryMemcacheResponse
-                            ) {
-                                pipeline.removeLast()
-                                pool.release(channel)
-                                msg.touch("The method's caller must remember to release this")
-                                response.complete(msg.retain())
-                            }
-
-                            override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                                val ex = when (cause) {
-                                    is DecoderException -> cause.cause!!
-                                    else -> cause
-                                }
-                                ctx.close()
-                                pipeline.removeLast()
-                                pool.release(channel)
-                                response.completeExceptionally(ex)
-                            }
-                        })
-                    request.touch()
-                    channel.writeAndFlush(request)
-                } else {
-                    response.completeExceptionally(channelFuture.cause())
-                }
-            }
-        })
-        return response
-    }
-
-    private fun encodeExpiry(expiry: Duration): Int {
-        val expirySeconds = expiry.toSeconds()
-        return expirySeconds.toInt().takeIf { it.toLong() == expirySeconds }
-            ?: Instant.ofEpochSecond(expirySeconds).epochSecond.toInt()
-    }
-
-    fun get(key: String): CompletableFuture<ReadableByteChannel?> {
-        val request = (cfg.digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digest(key.toByteArray(), md)
-            } ?: key.toByteArray(Charsets.UTF_8)).let { digest ->
-            DefaultFullBinaryMemcacheRequest(Unpooled.wrappedBuffer(digest), null).apply {
-                setOpcode(BinaryMemcacheOpcodes.GET)
-            }
-        }
-        return sendRequest(request).thenApply { response ->
-            try {
-                when (val status = response.status()) {
-                    BinaryMemcacheResponseStatus.SUCCESS -> {
-                        val compressionMode = cfg.compressionMode
-                        val content = response.content().retain()
-                        content.touch()
-                        if (compressionMode != null) {
-                            when (compressionMode) {
-                                MemcacheCacheConfiguration.CompressionMode.GZIP -> {
-                                    GZIPInputStream(ByteBufInputStream(content))
-                                }
-
-                                MemcacheCacheConfiguration.CompressionMode.DEFLATE -> {
-                                    InflaterInputStream(ByteBufInputStream(content))
-                                }
-                            }
-                        } else {
-                            ByteBufInputStream(content)
-                        }.let(Channels::newChannel)
-                    }
-
-                    BinaryMemcacheResponseStatus.KEY_ENOENT -> {
-                        null
-                    }
-
-                    else -> throw MemcacheException(status)
-                }
-            } finally {
-                response.release()
-            }
-        }
-    }
-
-    fun put(key: String, content: ByteBuf, expiry: Duration, cas: Long? = null): CompletableFuture<Void> {
-        val request = (cfg.digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digest(key.toByteArray(), md)
-            } ?: key.toByteArray(Charsets.UTF_8)).let { digest ->
-            val extras = Unpooled.buffer(8, 8)
-            extras.writeInt(0)
-            extras.writeInt(encodeExpiry(expiry))
-            val compressionMode = cfg.compressionMode
-            content.retain()
-            val payload = if (compressionMode != null) {
-                val inputStream = ByteBufInputStream(content)
-                val buf = content.alloc().buffer()
-                buf.retain()
-                val outputStream = when (compressionMode) {
-                    MemcacheCacheConfiguration.CompressionMode.GZIP -> {
-                        GZIPOutputStream(ByteBufOutputStream(buf))
-                    }
-
-                    MemcacheCacheConfiguration.CompressionMode.DEFLATE -> {
-                        DeflaterOutputStream(ByteBufOutputStream(buf), Deflater(Deflater.DEFAULT_COMPRESSION, false))
-                    }
-                }
-                inputStream.use { i ->
-                    outputStream.use { o ->
-                        JWO.copy(i, o)
-                    }
-                }
-                buf
-            } else {
-                content
-            }
-            DefaultFullBinaryMemcacheRequest(Unpooled.wrappedBuffer(digest), extras, payload).apply {
-                setOpcode(BinaryMemcacheOpcodes.SET)
-                cas?.let(this::setCas)
-            }
-        }
-        return sendRequest(request).thenApply { response ->
-            try {
-                when (val status = response.status()) {
-                    BinaryMemcacheResponseStatus.SUCCESS -> null
-                    else -> throw MemcacheException(status)
-                }
-            } finally {
-                response.release()
-            }
-        }
-    }
-
-
-    fun shutDown(): NettyFuture<*> {
-        return group.shutdownGracefully()
-    }
-
-    override fun close() {
-        shutDown().sync()
-    }
-}

gbcs-server-memcache/src/main/resources/META-INF/services/net.woggioni.gbcs.api.CacheProvider

@@ -1 +0,0 @@
-net.woggioni.gbcs.server.memcache.MemcacheCacheProvider

gbcs-server/build.gradle

@@ -1,38 +0,0 @@
-plugins {
-    id 'java-library'
-    alias catalog.plugins.kotlin.jvm
-    id 'jacoco'
-    id 'maven-publish'
-}
-
-dependencies {
-    implementation catalog.jwo
-    implementation catalog.slf4j.api
-    implementation catalog.netty.codec.http
-
-    api project(':gbcs-common')
-    api project(':gbcs-api')
-
-//    runtimeOnly catalog.slf4j.jdk14
-    testRuntimeOnly catalog.logback.classic
-
-    testImplementation catalog.bcprov.jdk18on
-    testImplementation catalog.bcpkix.jdk18on
-
-    testRuntimeOnly project(":gbcs-server-memcache")
-}
-
-test {
-    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
-    systemProperty("jdk.httpclient.redirects.retrylimit", "1")
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from(components["java"])
-        }
-    }
-}
-
-

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

@@ -1,432 +0,0 @@
-package net.woggioni.gbcs.server
-
-import io.netty.bootstrap.ServerBootstrap
-import io.netty.buffer.ByteBuf
-import io.netty.channel.Channel
-import io.netty.channel.ChannelFuture
-import io.netty.channel.ChannelHandler.Sharable
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.channel.ChannelInitializer
-import io.netty.channel.ChannelOption
-import io.netty.channel.ChannelPromise
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.socket.nio.NioServerSocketChannel
-import io.netty.handler.codec.compression.CompressionOptions
-import io.netty.handler.codec.http.DefaultHttpContent
-import io.netty.handler.codec.http.HttpContentCompressor
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpObjectAggregator
-import io.netty.handler.codec.http.HttpRequest
-import io.netty.handler.codec.http.HttpServerCodec
-import io.netty.handler.ssl.ClientAuth
-import io.netty.handler.ssl.SslContext
-import io.netty.handler.ssl.SslContextBuilder
-import io.netty.handler.ssl.SslHandler
-import io.netty.handler.stream.ChunkedWriteHandler
-import io.netty.handler.timeout.IdleState
-import io.netty.handler.timeout.IdleStateEvent
-import io.netty.handler.timeout.IdleStateHandler
-import io.netty.util.AttributeKey
-import io.netty.util.concurrent.DefaultEventExecutorGroup
-import io.netty.util.concurrent.EventExecutorGroup
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.common.GBCS.toUrl
-import net.woggioni.gbcs.common.PasswordSecurity.decodePasswordHash
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import net.woggioni.gbcs.common.info
-import net.woggioni.gbcs.server.auth.AbstractNettyHttpAuthenticator
-import net.woggioni.gbcs.server.auth.Authorizer
-import net.woggioni.gbcs.server.auth.ClientCertificateValidator
-import net.woggioni.gbcs.server.auth.RoleAuthorizer
-import net.woggioni.gbcs.server.configuration.Parser
-import net.woggioni.gbcs.server.configuration.Serializer
-import net.woggioni.gbcs.server.exception.ExceptionHandler
-import net.woggioni.gbcs.server.handler.ServerHandler
-import net.woggioni.gbcs.server.throttling.ThrottlingHandler
-import net.woggioni.jwo.JWO
-import net.woggioni.jwo.Tuple2
-import java.io.OutputStream
-import java.net.InetSocketAddress
-import java.nio.file.Files
-import java.nio.file.Path
-import java.security.KeyStore
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-import java.util.Arrays
-import java.util.Base64
-import java.util.concurrent.TimeUnit
-import java.util.regex.Matcher
-import java.util.regex.Pattern
-import javax.naming.ldap.LdapName
-import javax.net.ssl.SSLPeerUnverifiedException
-
-class GradleBuildCacheServer(private val cfg: Configuration) {
-    private val log = contextLogger()
-
-    companion object {
-
-        val userAttribute: AttributeKey<Configuration.User> = AttributeKey.valueOf("user")
-        val groupAttribute: AttributeKey<Set<Configuration.Group>> = AttributeKey.valueOf("group")
-
-        val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
-        private const val SSL_HANDLER_NAME = "sslHandler"
-
-        fun loadConfiguration(configurationFile: Path): Configuration {
-            val doc = Files.newInputStream(configurationFile).use {
-                Xml.parseXml(configurationFile.toUri().toURL(), it)
-            }
-            return Parser.parse(doc)
-        }
-
-        fun dumpConfiguration(conf: Configuration, outputStream: OutputStream) {
-            Xml.write(Serializer.serialize(conf), outputStream)
-        }
-    }
-
-    private class HttpChunkContentCompressor(
-        threshold: Int,
-        vararg compressionOptions: CompressionOptions = emptyArray()
-    ) : HttpContentCompressor(threshold, *compressionOptions) {
-        override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise) {
-            var message: Any? = msg
-            if (message is ByteBuf) {
-                // convert ByteBuf to HttpContent to make it work with compression. This is needed as we use the
-                // ChunkedWriteHandler to send files when compression is enabled.
-                val buff = message
-                if (buff.isReadable) {
-                    // We only encode non empty buffers, as empty buffers can be used for determining when
-                    // the content has been flushed and it confuses the HttpContentCompressor
-                    // if we let it go
-                    message = DefaultHttpContent(buff)
-                }
-            }
-            super.write(ctx, message, promise)
-        }
-    }
-
-    @Sharable
-    private class ClientCertificateAuthenticator(
-        authorizer: Authorizer,
-        private val anonymousUserGroups: Set<Configuration.Group>?,
-        private val userExtractor: Configuration.UserExtractor?,
-        private val groupExtractor: Configuration.GroupExtractor?,
-    ) : AbstractNettyHttpAuthenticator(authorizer) {
-
-        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult? {
-            return try {
-                val sslHandler = (ctx.pipeline().get(SSL_HANDLER_NAME) as? SslHandler)
-                    ?: throw ConfigurationException("Client certificate authentication cannot be used when TLS is disabled")
-                val sslEngine = sslHandler.engine()
-                sslEngine.session.peerCertificates.takeIf {
-                    it.isNotEmpty()
-                }?.let { peerCertificates ->
-                    val clientCertificate = peerCertificates.first() as X509Certificate
-                    val user = userExtractor?.extract(clientCertificate)
-                    val group = groupExtractor?.extract(clientCertificate)
-                    val allGroups = ((user?.groups ?: emptySet()).asSequence() + sequenceOf(group).filterNotNull()).toSet()
-                    AuthenticationResult(user, allGroups)
-                } ?: anonymousUserGroups?.let{ AuthenticationResult(null, it) }
-            } catch (es: SSLPeerUnverifiedException) {
-                anonymousUserGroups?.let{ AuthenticationResult(null, it) }
-            }
-        }
-    }
-
-    @Sharable
-    private class NettyHttpBasicAuthenticator(
-        private val users: Map<String, Configuration.User>, authorizer: Authorizer
-    ) : AbstractNettyHttpAuthenticator(authorizer) {
-        private val log = contextLogger()
-
-        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult? {
-            val authorizationHeader = req.headers()[HttpHeaderNames.AUTHORIZATION] ?: let {
-                log.debug(ctx) {
-                    "Missing Authorization header"
-                }
-                return users[""]?.let { AuthenticationResult(it, it.groups) }
-            }
-            val cursor = authorizationHeader.indexOf(' ')
-            if (cursor < 0) {
-                log.debug(ctx) {
-                    "Invalid Authorization header: '$authorizationHeader'"
-                }
-                return users[""]?.let { AuthenticationResult(it, it.groups) }
-            }
-            val authenticationType = authorizationHeader.substring(0, cursor)
-            if ("Basic" != authenticationType) {
-                log.debug(ctx) {
-                    "Invalid authentication type header: '$authenticationType'"
-                }
-                return users[""]?.let { AuthenticationResult(it, it.groups) }
-            }
-            val (username, password) = Base64.getDecoder().decode(authorizationHeader.substring(cursor + 1))
-                .let(::String)
-                .let {
-                    val colon = it.indexOf(':')
-                    if (colon < 0) {
-                        log.debug(ctx) {
-                            "Missing colon from authentication"
-                        }
-                        return null
-                    }
-                    it.substring(0, colon) to it.substring(colon + 1)
-                }
-
-            return username.let(users::get)?.takeIf { user ->
-                user.password?.let { passwordAndSalt ->
-                    val (_, salt) = decodePasswordHash(passwordAndSalt)
-                    hashPassword(password, Base64.getEncoder().encodeToString(salt)) == passwordAndSalt
-                } ?: false
-            }?.let { user ->
-                AuthenticationResult(user, user.groups)
-            }
-        }
-    }
-
-    private class ServerInitializer(
-        private val cfg: Configuration,
-        private val eventExecutorGroup: EventExecutorGroup
-    ) : ChannelInitializer<Channel>() {
-
-        companion object {
-            private fun createSslCtx(tls: Configuration.Tls): SslContext {
-                val keyStore = tls.keyStore
-                return if (keyStore == null) {
-                    throw IllegalArgumentException("No keystore configured")
-                } else {
-                    val javaKeyStore = loadKeystore(keyStore.file, keyStore.password)
-                    val serverKey = javaKeyStore.getKey(
-                        keyStore.keyAlias, (keyStore.keyPassword ?: "").let(String::toCharArray)
-                    ) as PrivateKey
-                    val serverCert: Array<X509Certificate> =
-                        Arrays.stream(javaKeyStore.getCertificateChain(keyStore.keyAlias))
-                            .map { it as X509Certificate }
-                            .toArray { size -> Array<X509Certificate?>(size) { null } }
-                    SslContextBuilder.forServer(serverKey, *serverCert).apply {
-                        val clientAuth = tls.trustStore?.let { trustStore ->
-                            val ts = loadKeystore(trustStore.file, trustStore.password)
-                            trustManager(
-                                ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
-                            )
-                            if(trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
-                            else ClientAuth.OPTIONAL
-                        } ?: ClientAuth.NONE
-                        clientAuth(clientAuth)
-                    }.build()
-                }
-            }
-
-            fun loadKeystore(file: Path, password: String?): KeyStore {
-                val ext = JWO.splitExtension(file)
-                    .map(Tuple2<String, String>::get_2)
-                    .orElseThrow {
-                        IllegalArgumentException(
-                            "Keystore file '${file}' must have .jks, .p12, .pfx extension"
-                        )
-                    }
-                val keystore = when (ext.substring(1).lowercase()) {
-                    "jks" -> KeyStore.getInstance("JKS")
-                    "p12", "pfx" -> KeyStore.getInstance("PKCS12")
-                    else -> throw IllegalArgumentException(
-                        "Keystore file '${file}' must have .jks, .p12, .pfx extension"
-                    )
-                }
-                Files.newInputStream(file).use {
-                    keystore.load(it, password?.let(String::toCharArray))
-                }
-                return keystore
-            }
-        }
-
-        private val log = contextLogger()
-
-        private val serverHandler = let {
-            val cacheImplementation = cfg.cache.materialize()
-            val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
-            ServerHandler(cacheImplementation, prefix)
-        }
-
-        private val exceptionHandler = ExceptionHandler()
-        private val throttlingHandler = ThrottlingHandler(cfg)
-
-        private val authenticator = when (val auth = cfg.authentication) {
-            is Configuration.BasicAuthentication -> NettyHttpBasicAuthenticator(cfg.users, RoleAuthorizer())
-            is Configuration.ClientCertificateAuthentication -> {
-                ClientCertificateAuthenticator(
-                    RoleAuthorizer(),
-                    cfg.users[""]?.groups,
-                    userExtractor(auth),
-                    groupExtractor(auth)
-                )
-            }
-
-            else -> null
-        }
-
-        private val sslContext: SslContext? = cfg.tls?.let(Companion::createSslCtx)
-
-        private fun userExtractor(authentication: Configuration.ClientCertificateAuthentication) =
-            authentication.userExtractor?.let { extractor ->
-                val pattern = Pattern.compile(extractor.pattern)
-                val rdnType = extractor.rdnType
-                Configuration.UserExtractor { cert: X509Certificate ->
-                    val userName = LdapName(cert.subjectX500Principal.name).rdns.find {
-                        it.type == rdnType
-                    }?.let {
-                        pattern.matcher(it.value.toString())
-                    }?.takeIf(Matcher::matches)?.group(1)
-                    cfg.users[userName] ?: throw java.lang.RuntimeException("Failed to extract user")
-                }
-            }
-
-        private fun groupExtractor(authentication: Configuration.ClientCertificateAuthentication) =
-            authentication.groupExtractor?.let { extractor ->
-                val pattern = Pattern.compile(extractor.pattern)
-                val rdnType = extractor.rdnType
-                Configuration.GroupExtractor { cert: X509Certificate ->
-                    val groupName = LdapName(cert.subjectX500Principal.name).rdns.find {
-                        it.type == rdnType
-                    }?.let {
-                        pattern.matcher(it.value.toString())
-                    }?.takeIf(Matcher::matches)?.group(1)
-                    cfg.groups[groupName] ?: throw java.lang.RuntimeException("Failed to extract group")
-                }
-            }
-
-        override fun initChannel(ch: Channel) {
-            log.debug {
-                "Created connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
-            }
-            ch.closeFuture().addListener {
-                log.debug {
-                    "Closed connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
-                }
-            }
-            val pipeline = ch.pipeline()
-            cfg.connection.also { conn ->
-                val readTimeout = conn.readTimeout.toMillis()
-                val writeTimeout = conn.writeTimeout.toMillis()
-                if(readTimeout > 0 || writeTimeout > 0) {
-                    pipeline.addLast(
-                        IdleStateHandler(
-                            false,
-                            readTimeout,
-                            writeTimeout,
-                            0,
-                            TimeUnit.MILLISECONDS
-                        )
-                    )
-                }
-                val readIdleTimeout = conn.readIdleTimeout.toMillis()
-                val writeIdleTimeout = conn.writeIdleTimeout.toMillis()
-                val idleTimeout = conn.idleTimeout.toMillis()
-                if(readIdleTimeout > 0 || writeIdleTimeout > 0 || idleTimeout > 0) {
-                    pipeline.addLast(
-                        IdleStateHandler(
-                            true,
-                            readIdleTimeout,
-                            writeIdleTimeout,
-                            idleTimeout,
-                            TimeUnit.MILLISECONDS
-                        )
-                    )
-                }
-            }
-            pipeline.addLast(object : ChannelInboundHandlerAdapter() {
-                override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
-                    if (evt is IdleStateEvent) {
-                        when(evt.state()) {
-                            IdleState.READER_IDLE -> log.debug {
-                                "Read timeout reached on channel ${ch.id().asShortText()}, closing the connection"
-                            }
-                            IdleState.WRITER_IDLE -> log.debug {
-                                "Write timeout reached on channel ${ch.id().asShortText()}, closing the connection"
-                            }
-                            IdleState.ALL_IDLE -> log.debug {
-                                "Idle timeout reached on channel ${ch.id().asShortText()}, closing the connection"
-                            }
-                            null -> throw IllegalStateException("This should never happen")
-                        }
-                        ctx.close()
-                    }
-                }
-            })
-            sslContext?.newHandler(ch.alloc())?.also {
-                pipeline.addLast(SSL_HANDLER_NAME, it)
-            }
-            pipeline.addLast(HttpServerCodec())
-            pipeline.addLast(HttpChunkContentCompressor(1024))
-            pipeline.addLast(ChunkedWriteHandler())
-            pipeline.addLast(HttpObjectAggregator(cfg.connection.maxRequestSize))
-            authenticator?.let {
-                pipeline.addLast(it)
-            }
-            pipeline.addLast(throttlingHandler)
-            pipeline.addLast(eventExecutorGroup, serverHandler)
-            pipeline.addLast(exceptionHandler)
-        }
-    }
-
-    class ServerHandle(
-        httpChannelFuture: ChannelFuture,
-        private val executorGroups: Iterable<EventExecutorGroup>
-    ) : AutoCloseable {
-        private val httpChannel: Channel = httpChannelFuture.channel()
-        private val closeFuture: ChannelFuture = httpChannel.closeFuture()
-        private val log = contextLogger()
-
-        fun shutdown(): ChannelFuture {
-            return httpChannel.close()
-        }
-
-        override fun close() {
-            try {
-                closeFuture.sync()
-            } finally {
-                executorGroups.forEach {
-                    it.shutdownGracefully().sync()
-                }
-            }
-            log.info {
-                "GradleBuildCacheServer has been gracefully shut down"
-            }
-        }
-    }
-
-    fun run(): ServerHandle {
-        // Create the multithreaded event loops for the server
-        val bossGroup = NioEventLoopGroup(1)
-        val serverSocketChannel = NioServerSocketChannel::class.java
-        val workerGroup = NioEventLoopGroup(0)
-        val eventExecutorGroup = run {
-            val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
-                Thread.ofVirtual().factory()
-            } else {
-                null
-            }
-            DefaultEventExecutorGroup(Runtime.getRuntime().availableProcessors(), threadFactory)
-        }
-        val bootstrap = ServerBootstrap().apply {
-            // Configure the server
-            group(bossGroup, workerGroup)
-            channel(serverSocketChannel)
-            childHandler(ServerInitializer(cfg, eventExecutorGroup))
-            option(ChannelOption.SO_BACKLOG, cfg.incomingConnectionsBacklogSize)
-            childOption(ChannelOption.SO_KEEPALIVE, true)
-        }
-
-
-        // Bind and start to accept incoming connections.
-        val bindAddress = InetSocketAddress(cfg.host, cfg.port)
-        val httpChannel = bootstrap.bind(bindAddress).sync()
-        log.info {
-            "GradleBuildCacheServer is listening on ${cfg.host}:${cfg.port}"
-        }
-        return ServerHandle(httpChannel, setOf(bossGroup, workerGroup, eventExecutorGroup))
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/cache/FileSystemCache.kt

@@ -1,130 +0,0 @@
-package net.woggioni.gbcs.server.cache
-
-import io.netty.buffer.ByteBuf
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.common.ByteBufInputStream
-import net.woggioni.gbcs.common.GBCS.digestString
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.jwo.JWO
-import net.woggioni.jwo.LockFile
-import java.nio.channels.Channels
-import java.nio.channels.FileChannel
-import java.nio.file.Files
-import java.nio.file.Path
-import java.nio.file.StandardCopyOption
-import java.nio.file.StandardOpenOption
-import java.nio.file.attribute.BasicFileAttributes
-import java.security.MessageDigest
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.atomic.AtomicReference
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.Inflater
-import java.util.zip.InflaterInputStream
-
-class FileSystemCache(
-    val root: Path,
-    val maxAge: Duration,
-    val digestAlgorithm: String?,
-    val compressionEnabled: Boolean,
-    val compressionLevel: Int
-) : Cache {
-
-    private companion object {
-        @JvmStatic
-        private val log = contextLogger()
-    }
-
-    init {
-        Files.createDirectories(root)
-    }
-
-    private var nextGc = AtomicReference(Instant.now().plus(maxAge))
-
-    override fun get(key: String) = (digestAlgorithm
-        ?.let(MessageDigest::getInstance)
-        ?.let { md ->
-            digestString(key.toByteArray(), md)
-        } ?: key).let { digest ->
-        root.resolve(digest).takeIf(Files::exists)
-            ?.let { file ->
-                file.takeIf(Files::exists)?.let { file ->
-                    if (compressionEnabled) {
-                        val inflater = Inflater()
-                        Channels.newChannel(
-                            InflaterInputStream(
-                                Channels.newInputStream(
-                                    FileChannel.open(
-                                        file,
-                                        StandardOpenOption.READ
-                                    )
-                                ), inflater
-                            )
-                        )
-                    } else {
-                        FileChannel.open(file, StandardOpenOption.READ)
-                    }
-                }
-            }.also {
-                gc()
-            }.let {
-                CompletableFuture.completedFuture(it)
-            }
-    }
-
-    override fun put(key: String, content: ByteBuf): CompletableFuture<Void> {
-        (digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digestString(key.toByteArray(), md)
-            } ?: key).let { digest ->
-            val file = root.resolve(digest)
-            val tmpFile = Files.createTempFile(root, null, ".tmp")
-            try {
-                Files.newOutputStream(tmpFile).let {
-                    if (compressionEnabled) {
-                        val deflater = Deflater(compressionLevel)
-                        DeflaterOutputStream(it, deflater)
-                    } else {
-                        it
-                    }
-                }.use {
-                    JWO.copy(ByteBufInputStream(content), it)
-                }
-                Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
-            } catch (t: Throwable) {
-                Files.delete(tmpFile)
-                throw t
-            }
-        }.also {
-            gc()
-        }
-        return CompletableFuture.completedFuture(null)
-    }
-
-    private fun gc() {
-        val now = Instant.now()
-        val oldValue = nextGc.getAndSet(now.plus(maxAge))
-        if (oldValue < now) {
-            actualGc(now)
-        }
-    }
-
-    @Synchronized
-    private fun actualGc(now: Instant) {
-        Files.list(root).filter {
-            val creationTimeStamp = Files.readAttributes(it, BasicFileAttributes::class.java)
-                .creationTime()
-                .toInstant()
-            now > creationTimeStamp.plus(maxAge)
-        }.forEach { file ->
-            LockFile.acquire(file, false).use {
-                Files.delete(file)
-            }
-        }
-    }
-
-    override fun close() {}
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/cache/InMemoryCache.kt

@@ -1,150 +0,0 @@
-package net.woggioni.gbcs.server.cache
-
-import io.netty.buffer.ByteBuf
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.common.ByteBufInputStream
-import net.woggioni.gbcs.common.ByteBufOutputStream
-import net.woggioni.gbcs.common.GBCS.digestString
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.jwo.JWO
-import java.nio.channels.Channels
-import java.security.MessageDigest
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.PriorityBlockingQueue
-import java.util.concurrent.atomic.AtomicLong
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.Inflater
-import java.util.zip.InflaterInputStream
-
-class InMemoryCache(
-    val maxAge: Duration,
-    val maxSize: Long,
-    val digestAlgorithm: String?,
-    val compressionEnabled: Boolean,
-    val compressionLevel: Int
-) : Cache {
-
-    companion object {
-        @JvmStatic
-        private val log = contextLogger()
-    }
-
-    private val size = AtomicLong()
-    private val map = ConcurrentHashMap<String, ByteBuf>()
-    
-    private class RemovalQueueElement(val key: String, val value : ByteBuf, val expiry : Instant) : Comparable<RemovalQueueElement> {
-        override fun compareTo(other: RemovalQueueElement) = expiry.compareTo(other.expiry)
-    }
-
-    private val removalQueue = PriorityBlockingQueue<RemovalQueueElement>()
-
-    private var running = true
-    private val garbageCollector = Thread {
-        while(true) {
-            val el = removalQueue.take()
-            val buf = el.value
-            val now = Instant.now()
-            if(now > el.expiry) {
-                val removed = map.remove(el.key, buf)
-                if(removed) {
-                    updateSizeAfterRemoval(buf)
-                    //Decrease the reference count for map
-                    buf.release()
-                }
-                //Decrease the reference count for removalQueue
-                buf.release()
-            } else {
-                removalQueue.put(el)
-                Thread.sleep(minOf(Duration.between(now, el.expiry), Duration.ofSeconds(1)))
-            }
-        }
-    }.apply {
-        start()
-    }
-
-    private fun removeEldest() : Long {
-        while(true) {
-            val el = removalQueue.take()
-            val buf = el.value
-            val removed = map.remove(el.key, buf)
-            //Decrease the reference count for removalQueue
-            buf.release()
-            if(removed) {
-                val newSize = updateSizeAfterRemoval(buf)
-                //Decrease the reference count for map
-                buf.release()
-                return newSize
-            }
-        }
-    }
-
-    private fun updateSizeAfterRemoval(removed: ByteBuf) : Long {
-        return size.updateAndGet { currentSize : Long ->
-            currentSize - removed.readableBytes()
-        }
-    }
-
-    override fun close() {
-        running = false
-        garbageCollector.join()
-    }
-
-    override fun get(key: String) =
-        (digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digestString(key.toByteArray(), md)
-            } ?: key
-                ).let { digest ->
-                map[digest]
-                    ?.let { value ->
-                    val copy = value.retainedDuplicate()
-                    copy.touch("This has to be released by the caller of the cache")
-                    if (compressionEnabled) {
-                        val inflater = Inflater()
-                        Channels.newChannel(InflaterInputStream(ByteBufInputStream(copy), inflater))
-                    } else {
-                        Channels.newChannel(ByteBufInputStream(copy))
-                    }
-                }
-            }.let {
-                CompletableFuture.completedFuture(it)
-            }
-
-    override fun put(key: String, content: ByteBuf) =
-        (digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digestString(key.toByteArray(), md)
-            } ?: key).let { digest ->
-            content.retain()
-            val value = if (compressionEnabled) {
-                val deflater = Deflater(compressionLevel)
-                val buf = content.alloc().buffer()
-                buf.retain()
-                DeflaterOutputStream(ByteBufOutputStream(buf), deflater).use { outputStream ->
-                    ByteBufInputStream(content).use { inputStream ->
-                        JWO.copy(inputStream, outputStream)
-                    }
-                }
-                buf
-            } else {
-                content
-            }
-            val old = map.put(digest, value)
-            val delta = value.readableBytes() - (old?.readableBytes() ?: 0)
-            var newSize = size.updateAndGet { currentSize : Long ->
-                currentSize + delta
-            }
-            removalQueue.put(RemovalQueueElement(digest, value.retain(), Instant.now().plus(maxAge)))
-            while(newSize > maxSize) {
-                newSize = removeEldest()
-            }
-        }.let {
-            CompletableFuture.completedFuture<Void>(null)
-        }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/cache/InMemoryCacheConfiguration.kt

@@ -1,25 +0,0 @@
-package net.woggioni.gbcs.server.cache
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.GBCS
-import java.time.Duration
-
-data class InMemoryCacheConfiguration(
-    val maxAge: Duration,
-    val maxSize: Long,
-    val digestAlgorithm : String?,
-    val compressionEnabled: Boolean,
-    val compressionLevel: Int,
-) : Configuration.Cache {
-    override fun materialize() = InMemoryCache(
-        maxAge,
-        maxSize,
-        digestAlgorithm,
-        compressionEnabled,
-        compressionLevel
-    )
-
-    override fun getNamespaceURI() = GBCS.GBCS_NAMESPACE_URI
-
-    override fun getTypeName() = "inMemoryCacheType"
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/cache/InMemoryCacheProvider.kt

@@ -1,63 +0,0 @@
-package net.woggioni.gbcs.server.cache
-
-import net.woggioni.gbcs.api.CacheProvider
-import net.woggioni.gbcs.common.GBCS
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import org.w3c.dom.Element
-import java.time.Duration
-import java.util.zip.Deflater
-
-class InMemoryCacheProvider : CacheProvider<InMemoryCacheConfiguration> {
-
-    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/server/schema/gbcs.xsd"
-
-    override fun getXmlType() = "inMemoryCacheType"
-
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server"
-
-    override fun deserialize(el: Element): InMemoryCacheConfiguration {
-        val maxAge = el.renderAttribute("max-age")
-            ?.let(Duration::parse)
-            ?: Duration.ofDays(1)
-        val maxSize = el.renderAttribute("max-size")
-            ?.let(java.lang.Long::decode)
-            ?: 0x1000000
-        val enableCompression = el.renderAttribute("enable-compression")
-            ?.let(String::toBoolean)
-            ?: true
-        val compressionLevel = el.renderAttribute("compression-level")
-            ?.let(String::toInt)
-            ?: Deflater.DEFAULT_COMPRESSION
-        val digestAlgorithm = el.renderAttribute("digest") ?: "MD5"
-
-        return InMemoryCacheConfiguration(
-            maxAge,
-            maxSize,
-            digestAlgorithm,
-            enableCompression,
-            compressionLevel
-        )
-    }
-
-    override fun serialize(doc: Document, cache : InMemoryCacheConfiguration) = cache.run {
-        val result = doc.createElement("cache")
-        Xml.of(doc, result) {
-            val prefix = doc.lookupPrefix(GBCS.GBCS_NAMESPACE_URI)
-            attr("xs:type", "${prefix}:inMemoryCacheType", GBCS.XML_SCHEMA_NAMESPACE_URI)
-            attr("max-age", maxAge.toString())
-            attr("max-size", maxSize.toString())
-            digestAlgorithm?.let { digestAlgorithm ->
-                attr("digest", digestAlgorithm)
-            }
-            attr("enable-compression", compressionEnabled.toString())
-            compressionLevel.takeIf {
-                it != Deflater.DEFAULT_COMPRESSION
-            }?.let {
-                attr("compression-level", it.toString())
-            }
-        }
-        result
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/configuration/Parser.kt

@@ -1,298 +0,0 @@
-package net.woggioni.gbcs.server.configuration
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Configuration.Authentication
-import net.woggioni.gbcs.api.Configuration.BasicAuthentication
-import net.woggioni.gbcs.api.Configuration.Cache
-import net.woggioni.gbcs.api.Configuration.ClientCertificateAuthentication
-import net.woggioni.gbcs.api.Configuration.Group
-import net.woggioni.gbcs.api.Configuration.KeyStore
-import net.woggioni.gbcs.api.Configuration.Tls
-import net.woggioni.gbcs.api.Configuration.TlsCertificateExtractor
-import net.woggioni.gbcs.api.Configuration.TrustStore
-import net.woggioni.gbcs.api.Configuration.User
-import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import org.w3c.dom.Element
-import org.w3c.dom.TypeInfo
-import java.nio.file.Paths
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-
-object Parser {
-    fun parse(document: Document): Configuration {
-        val root = document.documentElement
-        val anonymousUser = User("", null, emptySet(), null)
-        var connection: Configuration.Connection = Configuration.Connection(
-            Duration.of(10, ChronoUnit.SECONDS),
-            Duration.of(10, ChronoUnit.SECONDS),
-            Duration.of(60, ChronoUnit.SECONDS),
-            Duration.of(30, ChronoUnit.SECONDS),
-            Duration.of(30, ChronoUnit.SECONDS),
-            67108864
-        )
-        var eventExecutor: Configuration.EventExecutor = Configuration.EventExecutor(true)
-        var cache: Cache? = null
-        var host = "127.0.0.1"
-        var port = 11080
-        var users: Map<String, User> = mapOf(anonymousUser.name to anonymousUser)
-        var groups = emptyMap<String, Group>()
-        var tls: Tls? = null
-        val serverPath = root.renderAttribute("path")
-        var incomingConnectionsBacklogSize = 1024
-        var authentication: Authentication? = null
-        for (child in root.asIterable()) {
-            val tagName = child.localName
-            when (tagName) {
-                "authentication" -> {
-                    for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
-                            "basic" -> {
-                                authentication = BasicAuthentication()
-                            }
-
-                            "client-certificate" -> {
-                                var tlsExtractorUser: TlsCertificateExtractor? = null
-                                var tlsExtractorGroup: TlsCertificateExtractor? = null
-                                for (ggchild in gchild.asIterable()) {
-                                    when (ggchild.localName) {
-                                        "group-extractor" -> {
-                                            val attrName = ggchild.renderAttribute("attribute-name")
-                                            val pattern = ggchild.renderAttribute("pattern")
-                                            tlsExtractorGroup = TlsCertificateExtractor(attrName, pattern)
-                                        }
-
-                                        "user-extractor" -> {
-                                            val attrName = ggchild.renderAttribute("attribute-name")
-                                            val pattern = ggchild.renderAttribute("pattern")
-                                            tlsExtractorUser = TlsCertificateExtractor(attrName, pattern)
-                                        }
-                                    }
-                                }
-                                authentication = ClientCertificateAuthentication(tlsExtractorUser, tlsExtractorGroup)
-                            }
-                        }
-                    }
-                }
-
-                "authorization" -> {
-                    var knownUsers = sequenceOf(anonymousUser)
-                    for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
-                            "users" -> {
-                                knownUsers += parseUsers(gchild)
-                            }
-
-                            "groups" -> {
-                                val pair = parseGroups(gchild, knownUsers)
-                                users = pair.first
-                                groups = pair.second
-                            }
-                        }
-                    }
-                }
-
-                "bind" -> {
-                    host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
-                    port = Integer.parseInt(child.renderAttribute("port"))
-                    incomingConnectionsBacklogSize = child.renderAttribute("incoming-connections-backlog-size")
-                        ?.let(Integer::parseInt)
-                        ?: 1024
-                }
-
-                "cache" -> {
-                    cache = (child as TypeInfo).let { tf ->
-                        val typeNamespace = tf.typeNamespace
-                        val typeName = tf.typeName
-                        CacheSerializers.index[typeNamespace to typeName]
-                            ?: throw IllegalArgumentException("Cache provider for namespace '$typeNamespace' with name '$typeName' not found")
-                    }.deserialize(child)
-                }
-
-                "connection" -> {
-                    val writeTimeout = child.renderAttribute("write-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
-                    val readTimeout = child.renderAttribute("read-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
-                    val idleTimeout = child.renderAttribute("idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS)
-                    val readIdleTimeout = child.renderAttribute("read-idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                    val writeIdleTimeout = child.renderAttribute("write-idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                    val maxRequestSize = child.renderAttribute("max-request-size")
-                        ?.let(String::toInt) ?: 67108864
-                    connection = Configuration.Connection(
-                        readTimeout,
-                        writeTimeout,
-                        idleTimeout,
-                        readIdleTimeout,
-                        writeIdleTimeout,
-                        maxRequestSize
-                    )
-                }
-
-                "event-executor" -> {
-                    val useVirtualThread = root.renderAttribute("use-virtual-threads")
-                        ?.let(String::toBoolean) ?: true
-                    eventExecutor = Configuration.EventExecutor(useVirtualThread)
-                }
-
-                "tls" -> {
-                    var keyStore: KeyStore? = null
-                    var trustStore: TrustStore? = null
-
-                    for (granChild in child.asIterable()) {
-                        when (granChild.localName) {
-                            "keystore" -> {
-                                val keyStoreFile = Paths.get(granChild.renderAttribute("file"))
-                                val keyStorePassword = granChild.renderAttribute("password")
-                                val keyAlias = granChild.renderAttribute("key-alias")
-                                val keyPassword = granChild.renderAttribute("key-password")
-                                keyStore = KeyStore(
-                                    keyStoreFile,
-                                    keyStorePassword,
-                                    keyAlias,
-                                    keyPassword
-                                )
-                            }
-
-                            "truststore" -> {
-                                val trustStoreFile = Paths.get(granChild.renderAttribute("file"))
-                                val trustStorePassword = granChild.renderAttribute("password")
-                                val checkCertificateStatus = granChild.renderAttribute("check-certificate-status")
-                                    ?.let(String::toBoolean)
-                                    ?: false
-                                val requireClientCertificate = child.renderAttribute("require-client-certificate")
-                                    ?.let(String::toBoolean) ?: false
-
-                                trustStore = TrustStore(
-                                    trustStoreFile,
-                                    trustStorePassword,
-                                    checkCertificateStatus,
-                                    requireClientCertificate
-                                )
-                            }
-                        }
-                    }
-                    tls = Tls(keyStore, trustStore)
-                }
-            }
-        }
-        return Configuration.of(
-            host,
-            port,
-            incomingConnectionsBacklogSize,
-            serverPath,
-            eventExecutor,
-            connection,
-            users,
-            groups,
-            cache!!,
-            authentication,
-            tls,
-        )
-    }
-
-    private fun parseRoles(root: Element) = root.asIterable().asSequence().map {
-        when (it.localName) {
-            "reader" -> Role.Reader
-            "writer" -> Role.Writer
-            else -> throw UnsupportedOperationException("Illegal node '${it.localName}'")
-        }
-    }.toSet()
-
-    private fun parseUserRefs(root: Element) = root.asIterable().asSequence().map {
-        when (it.localName) {
-            "user" -> it.renderAttribute("ref")
-            "anonymous" -> ""
-            else -> ConfigurationException("Unrecognized tag '${it.localName}'")
-        }
-    }
-
-    private fun parseQuota(el: Element): Configuration.Quota {
-        val calls = el.renderAttribute("calls")
-            ?.let(String::toLong)
-            ?: throw ConfigurationException("Missing attribute 'calls'")
-        val maxAvailableCalls = el.renderAttribute("max-available-calls")
-            ?.let(String::toLong)
-            ?: calls
-        val initialAvailableCalls = el.renderAttribute("initial-available-calls")
-            ?.let(String::toLong)
-            ?: maxAvailableCalls
-        val period = el.renderAttribute("period")
-            ?.let(Duration::parse)
-            ?: throw ConfigurationException("Missing attribute 'period'")
-        return Configuration.Quota(calls, period, initialAvailableCalls, maxAvailableCalls)
-    }
-
-    private fun parseUsers(root: Element): Sequence<User> {
-        return root.asIterable().asSequence().mapNotNull { child ->
-            when (child.localName) {
-                "user" -> {
-                    val username = child.renderAttribute("name")
-                    val password = child.renderAttribute("password")
-                    var quota: Configuration.Quota? = null
-                    for (gchild in child.asIterable()) {
-                        if (gchild.localName == "quota") {
-                            quota = parseQuota(gchild)
-                        }
-                    }
-                    User(username, password, emptySet(), quota)
-                }
-                "anonymous" -> {
-                    var quota: Configuration.Quota? = null
-                    for (gchild in child.asIterable()) {
-                        if (gchild.localName == "quota") {
-                            quota= parseQuota(gchild)
-                        }
-                    }
-                    User("", null, emptySet(), quota)
-                }
-                else -> null
-            }
-        }
-    }
-
-    private fun parseGroups(root: Element, knownUsers: Sequence<User>): Pair<Map<String, User>, Map<String, Group>> {
-        val knownUsersMap = knownUsers.associateBy(User::getName)
-        val userGroups = mutableMapOf<String, MutableSet<String>>()
-        val groups = root.asIterable().asSequence().filter {
-            it.localName == "group"
-        }.map { el ->
-            val groupName = el.renderAttribute("name") ?: throw ConfigurationException("Group name is required")
-            var roles = emptySet<Role>()
-            var userQuota: Configuration.Quota? = null
-            var groupQuota: Configuration.Quota? = null
-            for (child in el.asIterable()) {
-                when (child.localName) {
-                    "users" -> {
-                        parseUserRefs(child).mapNotNull(knownUsersMap::get).forEach { user ->
-                            userGroups.computeIfAbsent(user.name) {
-                                mutableSetOf()
-                            }.add(groupName)
-                        }
-                    }
-
-                    "roles" -> {
-                        roles = parseRoles(child)
-                    }
-                    "group-quota" -> {
-                        userQuota = parseQuota(child)
-                    }
-                    "user-quota" -> {
-                        groupQuota = parseQuota(child)
-                    }
-                }
-            }
-            groupName to Group(groupName, roles, userQuota, groupQuota)
-        }.toMap()
-        val users = knownUsersMap.map { (name, user) ->
-            name to User(name, user.password, userGroups[name]?.mapNotNull { groups[it] }?.toSet() ?: emptySet(), user.quota)
-        }.toMap()
-        return users to groups
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/exception/ExceptionHandler.kt

@@ -1,92 +0,0 @@
-package net.woggioni.gbcs.server.exception
-
-import io.netty.buffer.Unpooled
-import io.netty.channel.ChannelDuplexHandler
-import io.netty.channel.ChannelFutureListener
-import io.netty.channel.ChannelHandler
-import io.netty.channel.ChannelHandlerContext
-import io.netty.handler.codec.DecoderException
-import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.FullHttpResponse
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpVersion
-import io.netty.handler.timeout.ReadTimeoutException
-import io.netty.handler.timeout.WriteTimeoutException
-import net.woggioni.gbcs.api.exception.CacheException
-import net.woggioni.gbcs.api.exception.ContentTooLargeException
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import javax.net.ssl.SSLPeerUnverifiedException
-
-@ChannelHandler.Sharable
-class ExceptionHandler : ChannelDuplexHandler() {
-    private val log = contextLogger()
-
-    private val NOT_AUTHORIZED: FullHttpResponse = DefaultFullHttpResponse(
-        HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN, Unpooled.EMPTY_BUFFER
-    ).apply {
-        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-    }
-
-    private val TOO_BIG: FullHttpResponse = DefaultFullHttpResponse(
-        HttpVersion.HTTP_1_1, HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE, Unpooled.EMPTY_BUFFER
-    ).apply {
-        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-    }
-
-    private val NOT_AVAILABLE: FullHttpResponse = DefaultFullHttpResponse(
-        HttpVersion.HTTP_1_1, HttpResponseStatus.SERVICE_UNAVAILABLE, Unpooled.EMPTY_BUFFER
-    ).apply {
-        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-    }
-
-    private val SERVER_ERROR: FullHttpResponse = DefaultFullHttpResponse(
-        HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR, Unpooled.EMPTY_BUFFER
-    ).apply {
-        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        when (cause) {
-            is DecoderException -> {
-                log.error(cause.message, cause)
-                ctx.close()
-            }
-
-            is SSLPeerUnverifiedException -> {
-                ctx.writeAndFlush(NOT_AUTHORIZED.retainedDuplicate())
-                    .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
-            }
-
-            is ContentTooLargeException -> {
-                ctx.writeAndFlush(TOO_BIG.retainedDuplicate())
-                    .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
-            }
-            is ReadTimeoutException -> {
-                log.debug {
-                    val channelId = ctx.channel().id().asShortText()
-                    "Read timeout on channel $channelId, closing the connection"
-                }
-                ctx.close()
-            }
-            is WriteTimeoutException -> {
-                log.debug {
-                    val channelId = ctx.channel().id().asShortText()
-                    "Write timeout on channel $channelId, closing the connection"
-                }
-                ctx.close()
-            }
-            is CacheException -> {
-                log.error(cause.message, cause)
-                ctx.writeAndFlush(NOT_AVAILABLE.retainedDuplicate())
-                    .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
-            }
-            else -> {
-                log.error(cause.message, cause)
-                ctx.writeAndFlush(SERVER_ERROR.retainedDuplicate())
-                    .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
-            }
-        }
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/handler/ServerHandler.kt

@@ -1,161 +0,0 @@
-package net.woggioni.gbcs.server.handler
-
-import io.netty.buffer.Unpooled
-import io.netty.channel.ChannelFutureListener
-import io.netty.channel.ChannelHandler
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.DefaultFileRegion
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.DefaultHttpResponse
-import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpMethod
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpUtil
-import io.netty.handler.codec.http.LastHttpContent
-import io.netty.handler.stream.ChunkedNioStream
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.server.debug
-import net.woggioni.gbcs.server.warn
-import java.nio.channels.FileChannel
-import java.nio.file.Path
-
-@ChannelHandler.Sharable
-class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
-    SimpleChannelInboundHandler<FullHttpRequest>() {
-
-    private val log = contextLogger()
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
-        val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
-        val method = msg.method()
-        if (method === HttpMethod.GET) {
-            val path = Path.of(msg.uri())
-            val prefix = path.parent
-            val key = path.fileName?.toString() ?: let {
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                ctx.writeAndFlush(response)
-                return
-            }
-            if (serverPrefix == prefix) {
-                cache.get(key).thenApply { channel ->
-                    if(channel != null) {
-                        log.debug(ctx) {
-                            "Cache hit for key '$key'"
-                        }
-                        val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
-                        response.headers()[HttpHeaderNames.CONTENT_TYPE] = HttpHeaderValues.APPLICATION_OCTET_STREAM
-                        if (!keepAlive) {
-                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
-                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
-                        } else {
-                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                        }
-                        ctx.write(response)
-                        when (channel) {
-                            is FileChannel -> {
-                                val content = DefaultFileRegion(channel, 0, channel.size())
-                                if (keepAlive) {
-                                    ctx.write(content)
-                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
-                                } else {
-                                    ctx.writeAndFlush(content)
-                                        .addListener(ChannelFutureListener.CLOSE)
-                                }
-                            }
-                            else -> {
-                                val content = ChunkedNioStream(channel)
-                                if (keepAlive) {
-                                    ctx.write(content).addListener {
-                                        content.close()
-                                    }
-                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
-                                } else {
-                                    ctx.writeAndFlush(content)
-                                        .addListener(ChannelFutureListener.CLOSE)
-                                }
-                            }
-                        }
-                    } else {
-                        log.debug(ctx) {
-                            "Cache miss for key '$key'"
-                        }
-                        val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
-                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                        ctx.writeAndFlush(response)
-                    }
-                }.whenComplete { _, ex -> ex?.let(ctx::fireExceptionCaught) }
-            } else {
-                log.warn(ctx) {
-                    "Got request for unhandled path '${msg.uri()}'"
-                }
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                ctx.writeAndFlush(response)
-            }
-        } else if (method === HttpMethod.PUT) {
-            val path = Path.of(msg.uri())
-            val prefix = path.parent
-            val key = path.fileName.toString()
-
-            if (serverPrefix == prefix) {
-                log.debug(ctx) {
-                    "Added value for key '$key' to build cache"
-                }
-                cache.put(key, msg.content()).thenRun {
-                    val response = DefaultFullHttpResponse(
-                        msg.protocolVersion(), HttpResponseStatus.CREATED,
-                        Unpooled.copiedBuffer(key.toByteArray())
-                    )
-                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
-                    ctx.writeAndFlush(response)
-                }.whenComplete { _, ex ->
-                    ctx.fireExceptionCaught(ex)
-                }
-            } else {
-                log.warn(ctx) {
-                    "Got request for unhandled path '${msg.uri()}'"
-                }
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-                ctx.writeAndFlush(response)
-            }
-        } else if(method == HttpMethod.TRACE) {
-            val replayedRequestHead = ctx.alloc().buffer()
-            replayedRequestHead.writeCharSequence("TRACE ${Path.of(msg.uri())} ${msg.protocolVersion().text()}\r\n", Charsets.US_ASCII)
-            msg.headers().forEach { (key, value) ->
-                replayedRequestHead.apply {
-                    writeCharSequence(key, Charsets.US_ASCII)
-                    writeCharSequence(": ", Charsets.US_ASCII)
-                    writeCharSequence(value, Charsets.UTF_8)
-                    writeCharSequence("\r\n", Charsets.US_ASCII)
-                }
-            }
-            replayedRequestHead.writeCharSequence("\r\n", Charsets.US_ASCII)
-            val requestBody = msg.content()
-            requestBody.retain()
-            val responseBody = ctx.alloc().compositeBuffer(2).apply {
-                addComponents(true, replayedRequestHead)
-                addComponents(true, requestBody)
-            }
-            val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK, responseBody)
-            response.headers().apply {
-                set(HttpHeaderNames.CONTENT_TYPE, "message/http")
-                set(HttpHeaderNames.CONTENT_LENGTH, responseBody.readableBytes())
-            }
-            ctx.writeAndFlush(response)
-        } else {
-            log.warn(ctx) {
-                "Got request with unhandled method '${msg.method().name()}'"
-            }
-            val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.METHOD_NOT_ALLOWED)
-            response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-            ctx.writeAndFlush(response)
-        }
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/throttling/BucketManager.kt

@@ -1,91 +0,0 @@
-package net.woggioni.gbcs.server.throttling
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.jwo.Bucket
-import java.net.InetSocketAddress
-import java.util.Arrays
-import java.util.concurrent.ConcurrentHashMap
-import java.util.function.Function
-
-class BucketManager private constructor(
-    private val bucketsByUser: Map<Configuration.User, List<Bucket>> = HashMap(),
-    private val bucketsByGroup: Map<Configuration.Group, Bucket> = HashMap(),
-    loader: Function<InetSocketAddress, Bucket>?
-) {
-
-    private class BucketsByAddress(
-        private val map: MutableMap<ByteArrayKey, Bucket>,
-        private val loader: Function<InetSocketAddress, Bucket>
-    ) {
-        fun getBucket(socketAddress : InetSocketAddress) = map.computeIfAbsent(ByteArrayKey(socketAddress.address.address))  {
-            loader.apply(socketAddress)
-        }
-    }
-
-    private val bucketsByAddress: BucketsByAddress? = loader?.let {
-        BucketsByAddress(ConcurrentHashMap(), it)
-    }
-
-    private class ByteArrayKey(val array: ByteArray) {
-        override fun equals(other: Any?) = (other as? ByteArrayKey)?.let { bak ->
-            array contentEquals bak.array
-        } ?: false
-
-        override fun hashCode() = Arrays.hashCode(array)
-    }
-
-    fun getBucketByAddress(address : InetSocketAddress) : Bucket? {
-        return bucketsByAddress?.getBucket(address)
-    }
-
-    fun getBucketByUser(user : Configuration.User) = bucketsByUser[user]
-    fun getBucketByGroup(group : Configuration.Group) = bucketsByGroup[group]
-
-    companion object {
-        fun from(cfg : Configuration) : BucketManager {
-            val bucketsByUser = cfg.users.values.asSequence().map { user ->
-                val buckets = (
-                        user.quota
-                            ?.let { quota ->
-                                sequenceOf(quota)
-                            } ?: user.groups.asSequence()
-                                .mapNotNull(Configuration.Group::getUserQuota)
-                ).map { quota ->
-                    Bucket.local(
-                        quota.maxAvailableCalls,
-                        quota.calls,
-                        quota.period,
-                        quota.initialAvailableCalls
-                    )
-                }.toList()
-                user to buckets
-            }.toMap()
-            val bucketsByGroup = cfg.groups.values.asSequence().filter {
-                it.groupQuota != null
-            }.map { group ->
-                val quota = group.groupQuota
-                val bucket = Bucket.local(
-                    quota.maxAvailableCalls,
-                    quota.calls,
-                    quota.period,
-                    quota.initialAvailableCalls
-                )
-                group to bucket
-            }.toMap()
-            return BucketManager(
-                bucketsByUser,
-                bucketsByGroup,
-                cfg.users[""]?.quota?.let { anonymousUserQuota ->
-                    Function {
-                        Bucket.local(
-                            anonymousUserQuota.maxAvailableCalls,
-                            anonymousUserQuota.calls,
-                            anonymousUserQuota.period,
-                            anonymousUserQuota.initialAvailableCalls
-                        )
-                    }
-                }
-            )
-        }
-    }
-}

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/throttling/ThrottlingHandler.kt

@@ -1,99 +0,0 @@
-package net.woggioni.gbcs.server.throttling
-
-import io.netty.channel.ChannelHandler.Sharable
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpVersion
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.server.GradleBuildCacheServer
-import net.woggioni.jwo.Bucket
-import net.woggioni.jwo.LongMath
-import java.net.InetSocketAddress
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-import java.util.concurrent.TimeUnit
-
-
-@Sharable
-class ThrottlingHandler(cfg: Configuration) :
-    ChannelInboundHandlerAdapter() {
-
-    private val log = contextLogger()
-    private val bucketManager = BucketManager.from(cfg)
-
-    private val connectionConfiguration = cfg.connection
-
-    /**
-     * If the suggested waiting time from the bucket is lower than this
-     * amount, then the server will simply wait by itself before sending a response
-     * instead of replying with 429
-     */
-    private val waitThreshold = minOf(
-        connectionConfiguration.idleTimeout,
-        connectionConfiguration.readIdleTimeout,
-        connectionConfiguration.writeIdleTimeout
-    ).dividedBy(2)
-
-    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        val buckets = mutableListOf<Bucket>()
-        val user = ctx.channel().attr(GradleBuildCacheServer.userAttribute).get()
-        if (user != null) {
-            bucketManager.getBucketByUser(user)?.let(buckets::addAll)
-        }
-        val groups = ctx.channel().attr(GradleBuildCacheServer.groupAttribute).get() ?: emptySet()
-        if (groups.isNotEmpty()) {
-            groups.forEach { group ->
-                bucketManager.getBucketByGroup(group)?.let(buckets::add)
-            }
-        }
-        if (user == null && groups.isEmpty()) {
-            bucketManager.getBucketByAddress(ctx.channel().remoteAddress() as InetSocketAddress)?.let(buckets::add)
-        }
-        if (buckets.isEmpty()) {
-            return super.channelRead(ctx, msg)
-        } else {
-            handleBuckets(buckets, ctx, msg, true)
-        }
-    }
-
-    private fun handleBuckets(buckets : List<Bucket>, ctx : ChannelHandlerContext, msg : Any, delayResponse : Boolean) {
-        var nextAttempt = -1L
-        for (bucket in buckets) {
-            val bucketNextAttempt = bucket.removeTokensWithEstimate(1)
-            if (bucketNextAttempt > nextAttempt) {
-                nextAttempt = bucketNextAttempt
-            }
-        }
-        if(nextAttempt < 0) {
-            super.channelRead(ctx, msg)
-            return
-        }
-        val waitDuration = Duration.of(LongMath.ceilDiv(nextAttempt, 100_000_000L) * 100L, ChronoUnit.MILLIS)
-        if (delayResponse && waitDuration < waitThreshold) {
-            ctx.executor().schedule({
-                handleBuckets(buckets, ctx, msg, false)
-            }, waitDuration.toMillis(), TimeUnit.MILLISECONDS)
-        } else {
-            sendThrottledResponse(ctx, waitDuration)
-        }
-    }
-
-    private fun sendThrottledResponse(ctx: ChannelHandlerContext, retryAfter: Duration) {
-        val response = DefaultFullHttpResponse(
-            HttpVersion.HTTP_1_1,
-            HttpResponseStatus.TOO_MANY_REQUESTS
-        )
-        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-        retryAfter.seconds.takeIf {
-            it > 0
-        }?.let {
-            response.headers()[HttpHeaderNames.RETRY_AFTER] = retryAfter.seconds
-        }
-
-        ctx.writeAndFlush(response)
-    }
-}

gbcs-server/src/main/resources/META-INF/services/net.woggioni.gbcs.api.CacheProvider

@@ -1,2 +0,0 @@
-net.woggioni.gbcs.server.cache.FileSystemCacheProvider
-net.woggioni.gbcs.server.cache.InMemoryCacheProvider

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

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server
-             xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="8080" incoming-connections-backlog-size="1024"/>
-    <connection
-            max-request-size="67108864"
-            idle-timeout="PT30S"
-            read-timeout="PT10S"
-            write-timeout="PT10S"
-            read-idle-timeout="PT60S"
-            write-idle-timeout="PT60S"/>
-    <event-executor use-virtual-threads="true"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

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

@@ -1,30 +0,0 @@
-package net.woggioni.gbcs.server.test.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");
-    }
-}

gbcs-server/src/test/kotlin/net/woggioni/gbcs/server/test/AbstractBasicAuthServerTest.kt

@@ -1,86 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
-import net.woggioni.gbcs.server.configuration.Serializer
-import net.woggioni.gbcs.server.test.utils.NetworkUtils
-import java.net.URI
-import java.net.http.HttpRequest
-import java.nio.charset.StandardCharsets
-import java.nio.file.Path
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-import java.util.Base64
-import java.util.zip.Deflater
-import kotlin.random.Random
-
-
-abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
-
-    private lateinit var cacheDir : Path
-
-    protected val random = Random(101325)
-    protected val keyValuePair = newEntry(random)
-    protected val serverPath = "gbcs"
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, null)
-
-    abstract protected val users : List<Configuration.User>
-
-    override fun setUp() {
-        this.cacheDir = testDir.resolve("cache")
-        cfg = Configuration.of(
-            "127.0.0.1",
-            NetworkUtils.getFreePort(),
-            50,
-            serverPath,
-            Configuration.EventExecutor(false),
-            Configuration.Connection(
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(60, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                0x1000
-            ),
-            users.asSequence().map { it.name to it}.toMap(),
-            sequenceOf(writersGroup, readersGroup).map { it.name to it}.toMap(),
-            FileSystemCacheConfiguration(this.cacheDir,
-                maxAge = Duration.ofSeconds(3600 * 24),
-                digestAlgorithm = "MD5",
-                compressionLevel = Deflater.DEFAULT_COMPRESSION,
-                compressionEnabled = false
-            ),
-            Configuration.BasicAuthentication(),
-            null,
-        )
-        Xml.write(Serializer.serialize(cfg), System.out)
-    }
-
-    override fun tearDown() {
-    }
-
-    protected fun buildAuthorizationHeader(user : Configuration.User, password : String) : String {
-        val b64 = Base64.getEncoder().encode("${user.name}:${password}".toByteArray(Charsets.UTF_8)).let{
-            String(it, StandardCharsets.UTF_8)
-        }
-        return "Basic $b64"
-    }
-
-    protected fun newRequestBuilder(key : String) = HttpRequest.newBuilder()
-        .uri(URI.create("http://${cfg.host}:${cfg.port}/$serverPath/$key"))
-
-
-    protected fun newEntry(random : Random) : Pair<String, ByteArray> {
-        val key = ByteArray(0x10).let {
-            random.nextBytes(it)
-            Base64.getUrlEncoder().encodeToString(it)
-        }
-        val value = ByteArray(0x1000).also {
-            random.nextBytes(it)
-        }
-        return key to value
-    }
-}

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

@@ -1,56 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import net.woggioni.gbcs.common.GBCS.toUrl
-import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.server.configuration.Parser
-import net.woggioni.gbcs.server.configuration.Serializer
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.io.TempDir
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.ValueSource
-import org.xml.sax.SAXParseException
-import java.nio.file.Files
-import java.nio.file.Path
-
-class ConfigurationTest {
-
-    @ValueSource(
-        strings = [
-            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-default.xml",
-            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached.xml",
-            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-tls.xml",
-            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached-tls.xml",
-        ]
-    )
-    @ParameterizedTest
-    fun test(configurationUrl: String, @TempDir testDir: Path) {
-        GbcsUrlStreamHandlerFactory.install()
-        val doc = Xml.parseXml(configurationUrl.toUrl())
-        val cfg = Parser.parse(doc)
-        val configFile = testDir.resolve("gbcs.xml")
-        Files.newOutputStream(configFile).use {
-            Xml.write(Serializer.serialize(cfg), it)
-        }
-        Xml.write(Serializer.serialize(cfg), System.out)
-
-        val parsed = Parser.parse(Xml.parseXml(configFile.toUri().toURL()))
-        Assertions.assertEquals(cfg, parsed)
-    }
-
-    @ValueSource(
-        strings = [
-            "classpath:net/woggioni/gbcs/server/test/invalid/invalid-user-ref.xml",
-            "classpath:net/woggioni/gbcs/server/test/invalid/duplicate-anonymous-user.xml",
-            "classpath:net/woggioni/gbcs/server/test/invalid/duplicate-anonymous-user2.xml",
-            "classpath:net/woggioni/gbcs/server/test/invalid/multiple-user-quota.xml",
-        ]
-    )
-    @ParameterizedTest
-    fun invalidConfigurationTest(configurationUrl: String) {
-        GbcsUrlStreamHandlerFactory.install()
-        Assertions.assertThrows(SAXParseException::class.java) {
-            Xml.parseXml(configurationUrl.toUrl())
-        }
-    }
-}

gbcs-server/src/test/kotlin/net/woggioni/gbcs/server/test/NoAnonymousUserBasicAuthServerTest.kt

@@ -1,52 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-
-class NoAnonymousUserBasicAuthServerTest : AbstractBasicAuthServerTest() {
-
-    companion object {
-        private const val PASSWORD = "anotherPassword"
-    }
-
-    override val users = listOf(
-        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup), null),
-        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup), null),
-        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup), null),
-    )
-
-    @Test
-    @Order(1)
-    fun putWithNoAuthorizationHeader() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun getWithNoAuthorizationHeader() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-}

gbcs-server/src/test/kotlin/net/woggioni/gbcs/server/test/NoAnonymousUserTlsServerTest.kt

@@ -1,47 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-class NoAnonymousUserTlsServerTest : AbstractTlsServerTest() {
-
-    override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup), null),
-        Configuration.User("user2", null, setOf(writersGroup), null),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup), null),
-    )
-
-    @Test
-    @Order(1)
-    fun getAsAnonymousUser() {
-        val (key, _) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun putAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-}

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

@@ -1,151 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Role
-import org.bouncycastle.asn1.x500.X500Name
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-
-class TlsServerTest : AbstractTlsServerTest() {
-
-    override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup), null),
-        Configuration.User("user2", null, setOf(writersGroup), null),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup), null),
-        Configuration.User("", null, setOf(readersGroup), null)
-    )
-
-    @Test
-    @Order(1)
-    fun putAsAReaderUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles && Role.Writer !in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun getAsAWriterUser() {
-        val (key, _) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Writer in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(3)
-    fun putAsAWriterUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Writer in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.CREATED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(4)
-    fun getAsAReaderUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(5)
-    fun getMissingKeyAsAReaderUser() {
-        val (key, _) = newEntry(random)
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(6)
-    fun getAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(7)
-    fun putAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(8)
-    fun traceAsAnonymousUser() {
-        val client: HttpClient = getHttpClient(null)
-        val requestBuilder = newRequestBuilder("").method(
-            "TRACE",
-            HttpRequest.BodyPublishers.ofByteArray("sfgsdgfaiousfiuhsd".toByteArray())
-        )
-
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        println(String(response.body()))
-    }
-}

gbcs-server/src/test/resources/logback.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE configuration>
-
-<configuration>
-    <import class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
-    <import class="ch.qos.logback.core.ConsoleAppender"/>
-
-    <appender name="console" class="ConsoleAppender">
-        <target>System.err</target>
-        <encoder class="PatternLayoutEncoder">
-            <pattern>%d [%highlight(%-5level)] \(%thread\) %logger{36} -%kvp- %msg %n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="info">
-        <appender-ref ref="console"/>
-    </root>
-    <logger name="io.netty" level="debug"/>
-    <logger name="com.google.code.yanf4j" level="warn"/>
-    <logger name="net.rubyeye.xmemcached" level="warn"/>
-</configuration>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/invalid/duplicate-anonymous-user.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1"/>
-            <user name="user2" password="password2"/>
-            <anonymous>
-                <quota calls="10" period="P3D"/>
-            </anonymous>
-            <anonymous>
-                <quota calls="15" period="P3D"/>
-            </anonymous>
-        </users>
-    </authorization>
-</gbcs:server>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/invalid/duplicate-anonymous-user2.xml

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1"/>
-            <user name="user2" password="password2"/>
-        </users>
-        <groups>
-            <group name="group1">
-                <users>
-                    <anonymous/>
-                    <user ref="user1"/>
-                    <anonymous/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-</gbcs:server>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/invalid/invalid-user-ref.xml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1"/>
-            <user name="user2" password="password2"/>
-        </users>
-        <groups>
-            <group name="readers">
-                <users>
-                    <user ref="user1"/>
-                    <user ref="user5"/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-</gbcs:server>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/invalid/multiple-user-quota.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1">
-                <quota calls="10" period="PT20S"/>
-                <quota calls="20" period="PT20S"/>
-            </user>
-        </users>
-    </authorization>
-</gbcs:server>

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

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="22"/>
-    <connection
-            write-timeout="PT25M"
-            read-timeout="PT20M"
-            read-idle-timeout="PT10M"
-            write-idle-timeout="PT11M"
-            idle-timeout="PT30M"
-            max-request-size="101325"/>
-    <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/valid/gbcs-memcached-tls.xml

@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server.memcache jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd"
->
-    <bind host="0.0.0.0" port="8443" incoming-connections-backlog-size="4096"/>
-    <connection
-            max-request-size="67108864"
-            idle-timeout="PT30S"
-            read-idle-timeout="PT60S"
-            write-idle-timeout="PT60S"
-            read-timeout="PT5M"
-            write-timeout="PT5M"/>
-    <event-executor use-virtual-threads="true"/>
-    <cache xs:type="gbcs-memcache:memcacheCacheType" max-age="P7D" max-size="16777216" compression-mode="deflate">
-        <server host="memcached" port="11211"/>
-    </cache>
-    <authorization>
-        <users>
-            <user name="woggioni">
-                <quota calls="1000" period="PT1S"/>
-            </user>
-            <user name="gitea">
-                <quota calls="10" period="PT1S" initial-available-calls="100" max-available-calls="100"/>
-            </user>
-            <anonymous>
-                <quota calls="2" period="PT5S"/>
-            </anonymous>
-        </users>
-        <groups>
-            <group name="writers">
-                <users>
-                    <user ref="woggioni"/>
-                    <user ref="gitea"/>
-                </users>
-                <roles>
-                    <reader/>
-                    <writer/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-    <authentication>
-        <client-certificate>
-            <user-extractor attribute-name="CN" pattern="(.*)"/>
-        </client-certificate>
-    </authentication>
-    <tls>
-        <keystore file="/home/luser/ssl/gbcs.woggioni.net.pfx" key-alias="gbcs.woggioni.net" password="KEYSTORE_PASSWOR" key-password="KEY_PASSWORD"/>
-        <truststore file="/home/luser/ssl/woggioni.net.pfx" check-certificate-status="false" password="TRUSTSTORE_PASSWORD"/>
-    </tls>
-</gbcs:server>

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

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server.memcache jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="50"/>
-    <connection
-            write-timeout="PT25M"
-            read-timeout="PT20M"
-            read-idle-timeout="PT10M"
-            write-idle-timeout="PT11M"
-            idle-timeout="PT30M"
-            max-request-size="101325"/>
-    <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs-memcache:memcacheCacheType" max-age="P7D" max-size="101325" digest="SHA-256">
-        <server host="127.0.0.1" port="11211" max-connections="10" connection-timeout="PT20S"/>
-    </cache>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/valid/gbcs-tls.xml

@@ -1,68 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="180"/>
-    <connection
-            write-timeout="PT25M"
-            read-timeout="PT20M"
-            read-idle-timeout="PT10M"
-            write-idle-timeout="PT11M"
-            idle-timeout="PT30M"
-            max-request-size="4096"/>
-    <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs:inMemoryCacheType" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1">
-                <quota calls="3600" period="PT1H"/>
-            </user>
-            <user name="user2" password="password2"/>
-            <user name="user3" password="password3"/>
-            <anonymous>
-                <quota calls="10" period="PT1M"/>
-            </anonymous>
-        </users>
-        <groups>
-            <group name="readers">
-                <users>
-                    <user ref="user1"/>
-                    <anonymous/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-                <user-quota calls="30" period="PT1M"/>
-                <group-quota calls="10" period="PT1S"/>
-            </group>
-            <group name="writers">
-                <users>
-                    <user ref="user2"/>
-                </users>
-                <roles>
-                    <writer/>
-                </roles>
-            </group>
-            <group name="readers-writers">
-                <users>
-                    <user ref="user3"/>
-                </users>
-                <roles>
-                    <reader/>
-                    <writer/>
-                </roles>
-                <group-quota calls="1000" period="P1D"/>
-            </group>
-        </groups>
-    </authorization>
-    <authentication>
-        <client-certificate>
-            <group-extractor pattern="group-pattern" attribute-name="O"/>
-            <user-extractor pattern="user-pattern" attribute-name="CN"/>
-        </client-certificate>
-    </authentication>
-    <tls>
-        <keystore file="keystore.pfx" key-alias="key1" password="password" key-password="key-password"/>
-        <truststore file="truststore.pfx" password="password" check-certificate-status="true" require-client-certificate="true"/>
-    </tls>
-</gbcs:server>

gradle.properties

@@ -2,11 +2,8 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true
 
-gbcs.version = 0.1.3
+gbcs.version = 0.0.1
 
-lys.version = 2025.02.05
+lys.version = 2025.01.09
 
 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
-docker.registry.url=gitea.woggioni.net
-
-jpms-check.configurationName = runtimeClasspath

settings.gradle

@@ -1,5 +1,6 @@
 pluginManagement {
     repositories {
+        mavenLocal()
         maven {
             url = getProperty('gitea.maven.url')
         }
@@ -26,9 +27,8 @@ dependencyResolutionManagement {
 rootProject.name = 'gbcs'
 
 include 'gbcs-api'
-include 'gbcs-common'
+include 'gbcs-base'
-include 'gbcs-server-memcache'
+include 'gbcs-memcached'
 include 'gbcs-cli'
-include 'docker'
+
-include 'gbcs-client'
+
-include 'gbcs-server'

src/main/java/module-info.java

@@ -1,8 +1,7 @@
 import net.woggioni.gbcs.api.CacheProvider;
-import net.woggioni.gbcs.server.cache.FileSystemCacheProvider;
+import net.woggioni.gbcs.cache.FileSystemCacheProvider;
-import net.woggioni.gbcs.server.cache.InMemoryCacheProvider;
 
-module net.woggioni.gbcs.server {
+module net.woggioni.gbcs {
     requires java.sql;
     requires java.xml;
     requires java.logging;
@@ -16,14 +15,14 @@ module net.woggioni.gbcs.server {
     requires io.netty.codec;
     requires org.slf4j;
     requires net.woggioni.jwo;
-    requires net.woggioni.gbcs.common;
+    requires net.woggioni.gbcs.base;
     requires net.woggioni.gbcs.api;
 
-    exports net.woggioni.gbcs.server;
+    exports net.woggioni.gbcs;
 
-    opens net.woggioni.gbcs.server;
+    opens net.woggioni.gbcs;
-    opens net.woggioni.gbcs.server.schema;
+    opens net.woggioni.gbcs.schema;
 
     uses CacheProvider;
-    provides CacheProvider with FileSystemCacheProvider, InMemoryCacheProvider;
+    provides CacheProvider with FileSystemCacheProvider;
 }