added Graal native image build for the server

added Jacoco test report

.gitea/workflows/build.yaml

@@ -9,11 +9,6 @@ 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
@@ -49,7 +44,7 @@ jobs:
           target: release
           cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       -
-        name: Build gbcs memcached Docker image
+        name: Build gbcs memcache Docker image
         uses: docker/build-push-action@v5.3.0
         with:
           context: "docker/build/docker"
@@ -57,9 +52,9 @@ jobs:
           push: true
           pull: true
           tags: |
-            gitea.woggioni.net/woggioni/gbcs:memcached
+            gitea.woggioni.net/woggioni/gbcs:memcache
-            gitea.woggioni.net/woggioni/gbcs:memcached-${{ steps.retrieve-version.outputs.VERSION }}
+            gitea.woggioni.net/woggioni/gbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-memcached
+          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

Dockerfile

@@ -1,2 +0,0 @@
-FROM gitea.woggioni.net/woggioni/gbcs:memcached
-COPY --chown=luser:luser conf/gbcs-memcached.xml /home/luser/.config/gbcs/gbcs.xml

build.gradle

@@ -41,11 +41,17 @@ allprojects { subproject ->
             withSourcesJar()
             modularity.inferModulePath = true
             toolchain {
-                languageVersion = JavaLanguageVersion.of(21)
+                languageVersion = JavaLanguageVersion.of(23)
                 vendor = JvmVendorSpec.ORACLE
             }
         }
 
+        dependencies {
+            testImplementation catalog.junit.jupiter.api
+            testImplementation catalog.junit.jupiter.params
+            testRuntimeOnly catalog.junit.jupiter.engine
+        }
+
         test {
             useJUnitPlatform()
         }
@@ -66,6 +72,15 @@ allprojects { subproject ->
         }
     }
 
+    pluginManager.withPlugin('jacoco') {
+        test {
+            finalizedBy jacocoTestReport
+        }
+        jacocoTestReport {
+            dependsOn test
+        }
+    }
+
     pluginManager.withPlugin(catalog.plugins.kotlin.jvm.get().pluginId) {
         tasks.withType(KotlinCompile.class) {
             compilerOptions.jvmTarget = JvmTarget.JVM_21

conf/gbcs-memcached.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server useVirtualThreads="true" 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

@@ -1,36 +0,0 @@
-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: .
-    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,21 +1,16 @@
-FROM alpine:latest AS base-release
+FROM eclipse-temurin:21-jre-alpine 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
 ADD gbcs-cli-envelope-*.jar gbcs.jar
-ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]
 
-FROM base-release AS release-memcached
+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-memcached*.tar
+RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcache*.tar
 WORKDIR /home/luser
-ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]
-
-FROM release-memcached as compose
-COPY --chown=luser:luser conf/gbcs-memcached.xml /home/luser/.config/gbcs/gbcs.xml

docker/build.gradle

@@ -19,7 +19,7 @@ configurations {
 
 dependencies {
     docker project(path: ':gbcs-cli', configuration: 'release')
-    docker project(path: ':gbcs-server-memcached', configuration: 'release')
+    docker project(path: ':gbcs-server-memcache', configuration: 'release')
 }
 
 Provider<Task> cleanTaskProvider = tasks.named(BasePlugin.CLEAN_TASK_NAME) {}
@@ -46,22 +46,22 @@ Provider<DockerTagImage> dockerTag = tasks.register('dockerTagImage', DockerTagI
     tag = version
 }
 
-Provider<DockerTagImage> dockerTagMemcached = tasks.register('dockerTagMemcachedImage', DockerTagImage) {
+Provider<DockerTagImage> dockerTagMemcache = tasks.register('dockerTagMemcacheImage', DockerTagImage) {
     group = 'docker'
     repository = 'gitea.woggioni.net/woggioni/gbcs'
-    imageId = 'gitea.woggioni.net/woggioni/gbcs:memcached'
+    imageId = 'gitea.woggioni.net/woggioni/gbcs:memcache'
-    tag = "${version}-memcached"
+    tag = "${version}-memcache"
 }
 
 Provider<DockerPushImage> dockerPush = tasks.register('dockerPushImage', DockerPushImage) {
     group = 'docker'
-    dependsOn dockerTag, dockerTagMemcached
+    dependsOn dockerTag, dockerTagMemcache
     registryCredentials {
         url = getProperty('docker.registry.url')
         username = 'woggioni'
         password = System.getenv().get("PUBLISHER_TOKEN")
     }
-    images = [dockerTag.flatMap{ it.tag }, dockerTagMemcached.flatMap{ it.tag }]
+    images = [dockerTag.flatMap{ it.tag }, dockerTagMemcache.flatMap{ it.tag }]
 }
 
 

gbcs-api/build.gradle

@@ -5,6 +5,7 @@ plugins {
 }
 
 dependencies {
+    api catalog.netty.buffer
 }
 
 publishing {

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

@@ -1,6 +1,7 @@
 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,11 +1,14 @@
 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 {
-    ReadableByteChannel get(String key);
+    CompletableFuture<ReadableByteChannel> get(String key);
 
-    void put(String key, byte[] content) throws ContentTooLargeException;
+    CompletableFuture<Void> put(String key, ByteBuf content) throws ContentTooLargeException;
 }

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

@@ -2,10 +2,12 @@ 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;
@@ -14,19 +16,48 @@ 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;
     }
 
     @Value
@@ -35,7 +66,7 @@ public class Configuration {
         String name;
         String password;
         Set<Group> groups;
-
+        Quota quota;
 
         public Set<Role> getRoles() {
             return groups.stream()
@@ -55,12 +86,22 @@ public class Configuration {
     }
 
     @Value
-    public static class Tls {
+    public static class Throttling {
         KeyStore keyStore;
         TrustStore trustStore;
         boolean verifyClients;
     }
 
+    public enum ClientCertificate {
+        REQUIRED, OPTIONAL
+    }
+
+    @Value
+    public static class Tls {
+        KeyStore keyStore;
+        TrustStore trustStore;
+    }
+
     @Value
     public static class KeyStore {
         Path file;
@@ -74,6 +115,7 @@ public class Configuration {
         Path file;
         String password;
         boolean checkCertificateStatus;
+        boolean requireClientCertificate;
     }
 
     @Value
@@ -101,24 +143,28 @@ 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

@@ -0,0 +1,11 @@
+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-cli/build.gradle

@@ -16,6 +16,8 @@ import net.woggioni.gradle.graalvm.NativeImageTask
 import net.woggioni.gradle.graalvm.JlinkPlugin
 import net.woggioni.gradle.graalvm.JlinkTask
 
+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')
 
@@ -33,7 +35,7 @@ configurations {
 }
 
 envelopeJar {
-    mainModule = 'net.woggioni.gbcs.cli'
+    mainModule = mainModuleName
     mainClass = mainClassName
 
     extraClasspath = ["plugins"]
@@ -50,20 +52,31 @@ dependencies {
 
 //    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'] = 'logging.properties'
+//    systemProperties['log.config.source'] = 'net/woggioni/gbcs/cli/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'
+//    systemProperties['org.slf4j.simpleLogger.defaultLogLevel'] = 'debug'
+//    systemProperties['org.slf4j.simpleLogger.log.com.google.code.yanf4j'] = 'warn'
+//    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
+    mainModule = mainModuleName
 }
 
 tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
     mainClass = mainClassName
+    mainModule = mainModuleName
     useMusl = true
     buildStaticImage = true
 }

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

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

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

@@ -1,15 +1,16 @@
 package net.woggioni.gbcs.cli
 
-import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
-import net.woggioni.gbcs.common.contextLogger
 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 picocli.CommandLine
 import picocli.CommandLine.Model.CommandSpec
@@ -24,8 +25,12 @@ class GradleBuildCacheServerCli : GbcsCommand() {
     companion object {
         @JvmStatic
         fun main(vararg args: String) {
-            Thread.currentThread().contextClassLoader = GradleBuildCacheServerCli::class.java.classLoader
+            val currentClassLoader = GradleBuildCacheServerCli::class.java.classLoader
-            GbcsUrlStreamHandlerFactory.install()
+            Thread.currentThread().contextClassLoader = currentClassLoader
+            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")
@@ -44,6 +49,7 @@ class GradleBuildCacheServerCli : GbcsCommand() {
                     addSubcommand(BenchmarkCommand())
                     addSubcommand(PutCommand())
                     addSubcommand(GetCommand())
+                    addSubcommand(HealthCheckCommand())
                 })
             System.exit(commandLine.execute(*args))
         }

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

@@ -1,18 +1,17 @@
 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.gbcs.cli.impl.GbcsCommand
+import net.woggioni.jwo.JWO
-import net.woggioni.gbcs.client.GbcsClient
 import picocli.CommandLine
 import java.security.SecureRandom
 import java.time.Duration
 import java.time.Instant
-import java.util.Base64
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.Future
 import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.Semaphore
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.random.Random
 
@@ -34,99 +33,110 @@ class BenchmarkCommand : GbcsCommand() {
     )
     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")
         }
-        val client = GbcsClient(profile)
+        GradleBuildCacheClient(profile).use { client ->
 
-        val entryGenerator = sequence {
+            val entryGenerator = sequence {
-            val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
+                val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
-            while (true) {
+                while (true) {
-                val key = Base64.getUrlEncoder().encode(random.nextBytes(16)).toString(Charsets.UTF_8)
+                    val key = JWO.bytesToHex(random.nextBytes(16))
-                val value = random.nextBytes(0x1000)
+                    val content = random.nextInt().toByte()
-                yield(key to value)
+                    val value = ByteArray(size, { _ -> content })
-            }
+                    yield(key to value)
-        }
-
-        val entries = let {
-            val completionQueue = LinkedBlockingQueue<Future<Pair<String, ByteArray>>>(numberOfEntries)
-            val start = Instant.now()
-            val totalElapsedTime = AtomicLong(0)
-            entryGenerator.take(numberOfEntries).forEach { entry ->
-                val requestStart = System.nanoTime()
-                val future = client.put(entry.first, entry.second).thenApply { entry }
-                future.whenComplete { _, _ ->
-                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
-                    completionQueue.put(future)
                 }
             }
 
-            val inserted = sequence<Pair<String, ByteArray>> {
-                var completionCounter = 0
-                while (completionCounter < numberOfEntries) {
-                    val future = completionQueue.take()
-                    try {
-                        yield(future.get())
-                    } catch (ee: ExecutionException) {
-                        val cause = ee.cause ?: ee
-                        log.error(cause.message, cause)
-                    }
-                    completionCounter += 1
-                }
-            }.toList()
-            val end = Instant.now()
             log.info {
-                val elapsed = Duration.between(start, end).toMillis()
+                "Starting insertion"
-                "Insertion rate: ${numberOfEntries.toDouble() / elapsed * 1000} ops/s"
             }
-            log.info {
+            val entries = let {
-                "Average time per insertion: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1000} ms"
+                val completionCounter = AtomicLong(0)
-            }
+                val completionQueue = LinkedBlockingQueue<Pair<String, ByteArray>>(numberOfEntries)
-            inserted
+                val start = Instant.now()
-        }
+                val semaphore = Semaphore(profile.maxConnections * 3)
-        log.info {
+                val iterator = entryGenerator.take(numberOfEntries).iterator()
-            "Inserted ${entries.size} entries"
+                while (completionCounter.get() < numberOfEntries) {
-        }
+                    if (iterator.hasNext()) {
-        if (entries.isNotEmpty()) {
+                        val entry = iterator.next()
-            val completionQueue = LinkedBlockingQueue<Future<Unit>>(entries.size)
+                        semaphore.acquire()
-            val start = Instant.now()
+                        val future = client.put(entry.first, entry.second).thenApply { entry }
-            val totalElapsedTime = AtomicLong(0)
+                        future.whenComplete { result, ex ->
-            entries.forEach { entry ->
+                            if (ex != null) {
-                val requestStart = System.nanoTime()
+                                log.error(ex.message, ex)
-                val future = client.get(entry.first).thenApply {
+                            } else {
-                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
+                                completionQueue.put(result)
-                    if (it == null) {
+                            }
-                        log.error {
+                            semaphore.release()
-                            "Missing entry for key '${entry.first}'"
+                            completionCounter.incrementAndGet()
-                        }
-                    } else if (!entry.second.contentEquals(it)) {
-                        log.error {
-                            "Retrieved a value different from what was inserted for key '${entry.first}'"
                         }
+                    } else {
+                        Thread.sleep(0)
                     }
                 }
-                future.whenComplete { _, _ ->
+
-                    completionQueue.put(future)
+                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
-            var completionCounter = 0
-            while (completionCounter < entries.size) {
-                completionQueue.take()
-                completionCounter += 1
-            }
-            val end = Instant.now()
-            log.info {
-                val elapsed = Duration.between(start, end).toMillis()
-                "Retrieval rate: ${entries.size.toDouble() / elapsed * 1000} ops/s"
             }
             log.info {
-                "Average time per retrieval: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1e6} ms"
+                "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")
             }
-        } 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,7 +1,7 @@
 package net.woggioni.gbcs.cli.impl.commands
 
 import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GbcsClient
+import net.woggioni.gbcs.client.GradleBuildCacheClient
 import net.woggioni.jwo.Application
 import picocli.CommandLine
 import java.nio.file.Path
@@ -28,8 +28,8 @@ class ClientCommand(app : Application) : GbcsCommand() {
     )
     var profileName : String? = null
 
-    val configuration : GbcsClient.Configuration by lazy {
+    val configuration : GradleBuildCacheClient.Configuration by lazy {
-        GbcsClient.Configuration.parse(configurationFile)
+        GradleBuildCacheClient.Configuration.parse(configurationFile)
     }
 
     override fun run() {

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

@@ -1,8 +1,8 @@
 package net.woggioni.gbcs.cli.impl.commands
 
-import net.woggioni.gbcs.common.contextLogger
 import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GbcsClient
+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
@@ -38,7 +38,7 @@ class GetCommand : GbcsCommand() {
             clientCommand.configuration.profiles[profileName]
                 ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
         }
-        GbcsClient(profile).use { client ->
+        GradleBuildCacheClient(profile).use { client ->
             client.get(key).thenApply { value ->
                 value?.let {
                     (output?.let(Files::newOutputStream) ?: System.out).use {

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

@@ -0,0 +1,45 @@
+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,8 +1,8 @@
 package net.woggioni.gbcs.cli.impl.commands
 
-import net.woggioni.gbcs.common.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.OutputStream

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

@@ -1,9 +1,9 @@
 package net.woggioni.gbcs.cli.impl.commands
 
-import net.woggioni.gbcs.common.contextLogger
 import net.woggioni.gbcs.cli.impl.GbcsCommand
 import net.woggioni.gbcs.cli.impl.converters.InputStreamConverter
-import net.woggioni.gbcs.client.GbcsClient
+import net.woggioni.gbcs.client.GradleBuildCacheClient
+import net.woggioni.gbcs.common.contextLogger
 import picocli.CommandLine
 import java.io.InputStream
 
@@ -39,7 +39,7 @@ class PutCommand : GbcsCommand() {
             clientCommand.configuration.profiles[profileName]
                 ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
         }
-        GbcsClient(profile).use { client ->
+        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,18 +1,20 @@
 package net.woggioni.gbcs.cli.impl.commands
 
-import net.woggioni.gbcs.server.GradleBuildCacheServer
-import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
 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.cli.impl.GbcsCommand
+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",
@@ -35,6 +37,14 @@ class ServerCommand(app : Application) : GbcsCommand() {
         }
     }
 
+    @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"],
@@ -42,10 +52,6 @@ class ServerCommand(app : Application) : GbcsCommand() {
     )
     private var configurationFile: Path = findConfigurationFile(app, "gbcs-server.xml")
 
-    val configuration : Configuration by lazy {
-        GradleBuildCacheServer.loadConfiguration(configurationFile)
-    }
-
     override fun run() {
         if (!Files.exists(configurationFile)) {
             Files.createDirectories(configurationFile.parent)
@@ -61,7 +67,11 @@ class ServerCommand(app : Application) : GbcsCommand() {
             }
         }
         val server = GradleBuildCacheServer(configuration)
-        server.run().use {
+        server.run().use { server ->
+            timeout?.let {
+                Thread.sleep(it)
+                server.shutdown()
+            }
         }
     }
 }

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

@@ -0,0 +1,11 @@
+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/resources/net/woggioni/gbcs/cli/logback.xml

@@ -15,6 +15,4 @@
     <root level="info">
         <appender-ref ref="console"/>
     </root>
-    <logger name="com.google.code.yanf4j" level="warn"/>
-    <logger name="net.rubyeye.xmemcached" level="warn"/>
 </configuration>

gbcs-client/build.gradle

@@ -10,6 +10,8 @@ dependencies {
     implementation catalog.slf4j.api
     implementation catalog.netty.buffer
     implementation catalog.netty.codec.http
+
+    testRuntimeOnly catalog.logback.classic
 }
 
 

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

@@ -30,23 +30,25 @@ 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.client.impl.Parser
+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 GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
+class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
     private val group: NioEventLoopGroup
     private var sslContext: SslContext
     private val log = contextLogger()
@@ -64,10 +66,18 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
             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 maxConnections : Int
+            val connectionTimeout: Duration?,
+            val maxConnections: Int,
+            val retryPolicy: RetryPolicy?,
         )
 
         companion object {
@@ -104,6 +114,9 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
             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() {
 
@@ -114,20 +127,29 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
             private var leaseCount = AtomicInteger()
 
             override fun channelReleased(ch: Channel) {
-                log.debug {
+                val activeLeases = leaseCount.decrementAndGet()
-                    "Released lease ${leaseCount.decrementAndGet()}"
+                log.trace {
+                    "Released channel ${ch.id().asShortText()}, number of active leases: $activeLeases"
                 }
             }
 
-            override fun channelAcquired(ch: Channel?) {
+            override fun channelAcquired(ch: Channel) {
-                log.debug {
+                val activeLeases = leaseCount.getAndIncrement()
-                    "Acquired lease ${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 ${connectionCount.getAndIncrement()}"
+                    "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()
 
@@ -139,37 +161,104 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
                 // HTTP handlers
                 pipeline.addLast("codec", HttpClientCodec())
                 pipeline.addLast("decompressor", HttpContentDecompressor())
-                pipeline.addLast("aggregator", HttpObjectAggregator(1048576))
+                pipeline.addLast("aggregator", HttpObjectAggregator(134217728))
                 pipeline.addLast("chunked", ChunkedWriteHandler())
             }
         }
         pool = FixedChannelPool(bootstrap, channelPoolHandler, profile.maxConnections)
     }
 
-    fun get(key: String): CompletableFuture<ByteArray?> {
+    private fun executeWithRetry(operation: () -> CompletableFuture<FullHttpResponse>): CompletableFuture<FullHttpResponse> {
-        return sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
+        val retryPolicy = profile.retryPolicy
-            .thenApply {
+        return if (retryPolicy != null) {
-                val status = it.status()
+            val outcomeHandler = OutcomeHandler<FullHttpResponse> { outcome ->
-                if (it.status() == HttpResponseStatus.NOT_FOUND) {
+                when (outcome) {
-                    null
+                    is OperationOutcome.Success -> {
-                } else if (it.status() != HttpResponseStatus.OK) {
+                        val response = outcome.result
-                    throw HttpException(status)
+                        val status = response.status()
-                } else {
+                        when (status) {
-                    it.content()
+                            HttpResponseStatus.TOO_MANY_REQUESTS -> {
-                }
+                                val retryAfter = response.headers()[HttpHeaderNames.RETRY_AFTER]?.let { headerValue ->
-            }.thenApply { maybeByteBuf ->
+                                    try {
-                maybeByteBuf?.let {
+                                        headerValue.toLong() * 1000
-                    val result = ByteArray(it.readableBytes())
+                                    } catch (nfe: NumberFormatException) {
-                    it.getBytes(0, result)
+                                        null
-                    result
+                                    }
+                                }
+                                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 sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content).thenApply {
+        return executeWithRetry {
+            sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content)
+        }.thenApply {
             val status = it.status()
-            if (it.status() != HttpResponseStatus.CREATED) {
+            if (it.status() != HttpResponseStatus.CREATED && it.status() != HttpResponseStatus.OK) {
                 throw HttpException(status)
             }
         }
@@ -188,9 +277,9 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
                             ctx: ChannelHandlerContext,
                             response: FullHttpResponse
                         ) {
-                            responseFuture.complete(response)
                             pipeline.removeLast()
                             pool.release(channel)
+                            responseFuture.complete(response)
                         }
 
                         override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
@@ -219,7 +308,7 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
                                     set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes())
                                 }
                                 set(HttpHeaderNames.HOST, profile.serverURI.host)
-                                set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                                set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
                                 set(
                                     HttpHeaderNames.ACCEPT_ENCODING,
                                     HttpHeaderValues.GZIP.toString() + "," + HttpHeaderValues.DEFLATE.toString()
@@ -237,6 +326,8 @@ class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
                     // Set headers
                     // Send the request
                     channel.writeAndFlush(request)
+                } else {
+                    responseFuture.completeExceptionally(channelFuture.cause())
                 }
             }
         })

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

@@ -1,9 +1,9 @@
 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 net.woggioni.gbcs.client.GbcsClient
 import org.w3c.dom.Document
 import java.net.URI
 import java.nio.file.Files
@@ -11,21 +11,24 @@ 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): GbcsClient.Configuration {
+    fun parse(document: Document): GradleBuildCacheClient.Configuration {
         val root = document.documentElement
-
+        val profiles = mutableMapOf<String, GradleBuildCacheClient.Configuration.Profile>()
-        val profiles = mutableMapOf<String, GbcsClient.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 name =
-                    val uri = child.renderAttribute("base-url")?.let(::URI) ?: throw ConfigurationException("base-url attribute is required")
+                        child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
-                    var authentication: GbcsClient.Configuration.Authentication? = null
+                    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" -> {
@@ -46,24 +49,60 @@ object Parser {
                                     .toList()
                                     .toTypedArray()
                                 authentication =
-                                    GbcsClient.Configuration.Authentication.TlsClientAuthenticationCredentials(key, certChain)
+                                    GradleBuildCacheClient.Configuration.Authentication.TlsClientAuthenticationCredentials(
+                                        key,
+                                        certChain
+                                    )
                             }
 
                             "basic-auth" -> {
-                                val username = gchild.renderAttribute("user") ?: throw ConfigurationException("username attribute is required")
+                                val username = gchild.renderAttribute("user")
-                                val password = gchild.renderAttribute("password") ?: throw ConfigurationException("password attribute is required")
+                                    ?: throw ConfigurationException("username attribute is required")
+                                val password = gchild.renderAttribute("password")
+                                    ?: throw ConfigurationException("password attribute is required")
                                 authentication =
-                                    GbcsClient.Configuration.Authentication.BasicAuthenticationCredentials(username, password)
+                                    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
-                    profiles[name] = GbcsClient.Configuration.Profile(uri, authentication, maxConnections)
+                    val connectionTimeout = child.renderAttribute("connection-timeout")
+                        ?.let(Duration::parse)
+                    profiles[name] = GradleBuildCacheClient.Configuration.Profile(
+                        uri,
+                        authentication,
+                        connectionTimeout,
+                        maxConnections,
+                        retryPolicy
+                    )
                 }
             }
         }
-        return GbcsClient.Configuration(profiles)
+        return GradleBuildCacheClient.Configuration(profiles)
     }
 }

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

@@ -0,0 +1,75 @@
+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

@@ -13,15 +13,22 @@
     </xs:complexType>
 
     <xs:complexType name="profileType">
-        <xs:choice>
+        <xs:sequence>
-            <xs:element name="basic-auth" type="gbcs-client:basicAuthType"/>
+            <xs:choice>
-            <xs:element name="tls-client-auth" type="gbcs-client:tlsClientAuthType"/>
+                <xs:element name="no-auth" type="gbcs-client:noAuthType"/>
-        </xs:choice>
+                <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"/>
@@ -34,4 +41,10 @@
         <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

@@ -0,0 +1,148 @@
+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

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

gbcs-common/build.gradle

@@ -9,6 +9,7 @@ dependencies {
     implementation project(':gbcs-api')
     implementation catalog.slf4j.api
     implementation catalog.jwo
+    implementation catalog.netty.buffer
 }
 
 publishing {

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

@@ -4,6 +4,8 @@ module net.woggioni.gbcs.common {
     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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,7 @@
+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,7 +1,9 @@
 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)
@@ -9,4 +11,19 @@ object GBCS {
     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/kotlin/net/woggioni/gbcs/common/GbcsUrlStreamHandlerFactory.kt

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

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

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

gbcs-native/build.gradle

@@ -0,0 +1,56 @@
+plugins {
+    id 'java-library'
+    alias catalog.plugins.sambal
+    alias catalog.plugins.graalvm.native.image
+}
+
+
+import net.woggioni.gradle.graalvm.*
+
+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.graal.NativeServer')
+
+tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
+    options.javaModuleMainClass = mainClassName
+}
+
+configurations {
+    release {
+        transitive = false
+        canBeConsumed = true
+        canBeResolved = true
+        visible = true
+    }
+}
+
+dependencies {
+    implementation catalog.jwo
+    implementation catalog.netty.transport
+    implementation project(':gbcs-server')
+    implementation project(':gbcs-server-memcache')
+
+//    runtimeOnly catalog.slf4j.jdk14
+    runtimeOnly catalog.logback.classic
+//    runtimeOnly catalog.slf4j.simple
+}
+
+tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask.class) {
+    mainClass = 'net.woggioni.gbcs.graal.ConfigureNativeServer'
+//    mainModule = mainModuleName
+    systemProperty('logback.configurationFile', 'classpath:net/woggioni/gbcs/graal/logback.xml')
+    systemProperty('io.netty.leakDetectionLevel', 'DISABLED')
+    modularity.inferModulePath = false
+    mergeConfiguration = true
+    enabled = false
+}
+
+tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
+    mainClass = mainClassName
+//    mainModule = mainModuleName
+    useMusl = true
+    buildStaticImage = true
+    linkAtBuildTime = false
+}
+

gbcs-native/native-image/jni-config.json

@@ -0,0 +1,6 @@
+[
+{
+  "name":"java.lang.Boolean",
+  "methods":[{"name":"getBoolean","parameterTypes":["java.lang.String"] }]
+}
+]

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

@@ -0,0 +1,2 @@
+Args=-O3 --gc=G1 --enable-url-protocols=jpms --initialize-at-run-time=io.netty --initialize-at-build-time=net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory,net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory$JpmsHandler,org.apache.logging.slf4j.SLF4JLogger
+#-H:TraceClassInitialization=io.netty.handler.ssl.BouncyCastleAlpnSslUtils

gbcs-native/native-image/predefined-classes-config.json

@@ -0,0 +1,8 @@
+[
+  {
+    "type":"agent-extracted",
+    "classes":[
+    ]
+  }
+]
+

gbcs-native/native-image/proxy-config.json

@@ -0,0 +1,2 @@
+[
+]

gbcs-native/native-image/reflect-config.json

@@ -0,0 +1,330 @@
+[
+{
+  "name":"ch.qos.logback.classic.encoder.PatternLayoutEncoder",
+  "queryAllPublicMethods":true,
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"ch.qos.logback.classic.joran.SerializedModelConfigurator",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"ch.qos.logback.classic.util.DefaultJoranConfigurator",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"ch.qos.logback.core.ConsoleAppender",
+  "queryAllPublicMethods":true,
+  "methods":[{"name":"<init>","parameterTypes":[] }, {"name":"setTarget","parameterTypes":["java.lang.String"] }]
+},
+{
+  "name":"ch.qos.logback.core.OutputStreamAppender",
+  "methods":[{"name":"setEncoder","parameterTypes":["ch.qos.logback.core.encoder.Encoder"] }]
+},
+{
+  "name":"ch.qos.logback.core.encoder.Encoder",
+  "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }]
+},
+{
+  "name":"ch.qos.logback.core.encoder.LayoutWrappingEncoder",
+  "methods":[{"name":"setParent","parameterTypes":["ch.qos.logback.core.spi.ContextAware"] }]
+},
+{
+  "name":"ch.qos.logback.core.pattern.PatternLayoutEncoderBase",
+  "methods":[{"name":"setPattern","parameterTypes":["java.lang.String"] }]
+},
+{
+  "name":"ch.qos.logback.core.spi.ContextAware",
+  "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }]
+},
+{
+  "name":"com.sun.crypto.provider.AESCipher$General",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.crypto.provider.ARCFOURCipher",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.crypto.provider.ChaCha20Cipher$ChaCha20Poly1305",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.crypto.provider.DESCipher",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.crypto.provider.DESedeCipher",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.crypto.provider.GaloisCounterMode$AESGCM",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.org.apache.xerces.internal.impl.dv.xs.ExtendedSchemaDVFactoryImpl",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.org.apache.xerces.internal.impl.dv.xs.SchemaDVFactoryImpl",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"io.netty.bootstrap.ServerBootstrap$1"
+},
+{
+  "name":"io.netty.bootstrap.ServerBootstrap$ServerBootstrapAcceptor",
+  "methods":[{"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }]
+},
+{
+  "name":"io.netty.buffer.AbstractByteBufAllocator",
+  "queryAllDeclaredMethods":true
+},
+{
+  "name":"io.netty.channel.AbstractChannelHandlerContext",
+  "fields":[{"name":"handlerState"}]
+},
+{
+  "name":"io.netty.channel.ChannelInboundHandlerAdapter",
+  "methods":[{"name":"channelActive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelInactive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"channelReadComplete","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRegistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelUnregistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelWritabilityChanged","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"userEventTriggered","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }]
+},
+{
+  "name":"io.netty.channel.ChannelInitializer",
+  "methods":[{"name":"channelRegistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }]
+},
+{
+  "name":"io.netty.channel.ChannelOutboundBuffer",
+  "fields":[{"name":"totalPendingSize"}, {"name":"unwritable"}]
+},
+{
+  "name":"io.netty.channel.DefaultChannelConfig",
+  "fields":[{"name":"autoRead"}, {"name":"writeBufferWaterMark"}]
+},
+{
+  "name":"io.netty.channel.DefaultChannelPipeline",
+  "fields":[{"name":"estimatorHandle"}]
+},
+{
+  "name":"io.netty.channel.DefaultChannelPipeline$HeadContext",
+  "methods":[{"name":"bind","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.net.SocketAddress","io.netty.channel.ChannelPromise"] }, {"name":"channelActive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelInactive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"channelReadComplete","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRegistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelUnregistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelWritabilityChanged","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"close","parameterTypes":["io.netty.channel.ChannelHandlerContext","io.netty.channel.ChannelPromise"] }, {"name":"connect","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.net.SocketAddress","java.net.SocketAddress","io.netty.channel.ChannelPromise"] }, {"name":"deregister","parameterTypes":["io.netty.channel.ChannelHandlerContext","io.netty.channel.ChannelPromise"] }, {"name":"disconnect","parameterTypes":["io.netty.channel.ChannelHandlerContext","io.netty.channel.ChannelPromise"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }, {"name":"flush","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"read","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"userEventTriggered","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"write","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object","io.netty.channel.ChannelPromise"] }]
+},
+{
+  "name":"io.netty.channel.DefaultChannelPipeline$TailContext",
+  "methods":[{"name":"channelActive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelInactive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"channelReadComplete","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelRegistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelUnregistered","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"channelWritabilityChanged","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }, {"name":"userEventTriggered","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }]
+},
+{
+  "name":"io.netty.channel.socket.nio.NioServerSocketChannel",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"io.netty.util.DefaultAttributeMap",
+  "fields":[{"name":"attributes"}]
+},
+{
+  "name":"io.netty.util.concurrent.DefaultPromise",
+  "fields":[{"name":"result"}]
+},
+{
+  "name":"io.netty.util.concurrent.SingleThreadEventExecutor",
+  "fields":[{"name":"state"}, {"name":"threadProperties"}]
+},
+{
+  "name":"io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueColdProducerFields",
+  "fields":[{"name":"producerLimit"}]
+},
+{
+  "name":"io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueConsumerFields",
+  "fields":[{"name":"consumerIndex"}]
+},
+{
+  "name":"io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueProducerFields",
+  "fields":[{"name":"producerIndex"}]
+},
+{
+  "name":"java.io.FilePermission"
+},
+{
+  "name":"java.lang.ProcessHandle",
+  "methods":[{"name":"current","parameterTypes":[] }, {"name":"pid","parameterTypes":[] }]
+},
+{
+  "name":"java.lang.RuntimePermission"
+},
+{
+  "name":"java.lang.Thread",
+  "fields":[{"name":"threadLocalRandomProbe"}]
+},
+{
+  "name":"java.net.NetPermission"
+},
+{
+  "name":"java.net.SocketPermission"
+},
+{
+  "name":"java.net.URLPermission",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.String","java.lang.String"] }]
+},
+{
+  "name":"java.nio.Bits",
+  "fields":[{"name":"MAX_MEMORY"}, {"name":"UNALIGNED"}]
+},
+{
+  "name":"java.nio.Buffer",
+  "fields":[{"name":"address"}]
+},
+{
+  "name":"java.nio.ByteBuffer",
+  "methods":[{"name":"alignedSlice","parameterTypes":["int"] }]
+},
+{
+  "name":"java.nio.DirectByteBuffer",
+  "methods":[{"name":"<init>","parameterTypes":["long","long"] }]
+},
+{
+  "name":"java.nio.channels.spi.SelectorProvider",
+  "methods":[{"name":"openServerSocketChannel","parameterTypes":["java.net.ProtocolFamily"] }]
+},
+{
+  "name":"java.security.AlgorithmParametersSpi"
+},
+{
+  "name":"java.security.AllPermission"
+},
+{
+  "name":"java.security.KeyStoreSpi"
+},
+{
+  "name":"java.security.SecureRandomParameters"
+},
+{
+  "name":"java.security.SecurityPermission"
+},
+{
+  "name":"java.util.PropertyPermission"
+},
+{
+  "name":"java.util.concurrent.ForkJoinTask",
+  "fields":[{"name":"aux"}, {"name":"status"}]
+},
+{
+  "name":"java.util.concurrent.atomic.AtomicBoolean",
+  "fields":[{"name":"value"}]
+},
+{
+  "name":"java.util.concurrent.atomic.AtomicReference",
+  "fields":[{"name":"value"}]
+},
+{
+  "name":"java.util.concurrent.atomic.Striped64",
+  "fields":[{"name":"base"}, {"name":"cellsBusy"}]
+},
+{
+  "name":"javax.security.auth.x500.X500Principal",
+  "fields":[{"name":"thisX500Name"}],
+  "methods":[{"name":"<init>","parameterTypes":["sun.security.x509.X500Name"] }]
+},
+{
+  "name":"javax.smartcardio.CardPermission"
+},
+{
+  "name":"jdk.internal.misc.Unsafe",
+  "methods":[{"name":"getUnsafe","parameterTypes":[] }]
+},
+{
+  "name":"sun.misc.Unsafe",
+  "fields":[{"name":"theUnsafe"}],
+  "methods":[{"name":"copyMemory","parameterTypes":["java.lang.Object","long","java.lang.Object","long","long"] }, {"name":"getAndAddLong","parameterTypes":["java.lang.Object","long","long"] }, {"name":"getAndSetObject","parameterTypes":["java.lang.Object","long","java.lang.Object"] }, {"name":"invokeCleaner","parameterTypes":["java.nio.ByteBuffer"] }, {"name":"storeFence","parameterTypes":[] }]
+},
+{
+  "name":"sun.nio.ch.SelectorImpl",
+  "fields":[{"name":"publicSelectedKeys"}, {"name":"selectedKeys"}]
+},
+{
+  "name":"sun.security.pkcs12.PKCS12KeyStore",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.pkcs12.PKCS12KeyStore$DualFormatPKCS12",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.provider.JavaKeyStore$JKS",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.provider.NativePRNG",
+  "methods":[{"name":"<init>","parameterTypes":[] }, {"name":"<init>","parameterTypes":["java.security.SecureRandomParameters"] }]
+},
+{
+  "name":"sun.security.provider.SHA",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.provider.X509Factory",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.rsa.RSAKeyFactory$Legacy",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.ssl.KeyManagerFactoryImpl$SunX509",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.ssl.SSLContextImpl$DefaultSSLContext",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.ssl.TrustManagerFactoryImpl$PKIXFactory",
+  "methods":[{"name":"<init>","parameterTypes":[] }]
+},
+{
+  "name":"sun.security.x509.AuthorityInfoAccessExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.AuthorityKeyIdentifierExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.BasicConstraintsExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.CRLDistributionPointsExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.CertificatePoliciesExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.KeyUsageExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.NetscapeCertTypeExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.PrivateKeyUsageExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.SubjectAlternativeNameExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.SubjectKeyIdentifierExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+}
+]

gbcs-native/native-image/resource-config.json

@@ -0,0 +1,40 @@
+{
+  "resources":{
+  "includes":[{
+    "pattern":"\\QMETA-INF/services/ch.qos.logback.classic.spi.Configurator\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/java.lang.System$LoggerFinder\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/java.net.spi.URLStreamHandlerProvider\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/java.nio.channels.spi.SelectorProvider\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/java.time.zone.ZoneRulesProvider\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/javax.xml.parsers.DocumentBuilderFactory\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/javax.xml.parsers.SAXParserFactory\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/net.woggioni.gbcs.api.CacheProvider\\E"
+  }, {
+    "pattern":"\\QMETA-INF/services/org.slf4j.spi.SLF4JServiceProvider\\E"
+  }, {
+    "pattern":"\\Qclasspath:net/woggioni/gbcs/graal/logback.xml\\E"
+  }, {
+    "pattern":"\\Qlogback-test.scmo\\E"
+  }, {
+    "pattern":"\\Qlogback.scmo\\E"
+  }, {
+    "pattern":"\\Qnet/woggioni/gbcs/graal/logback.xml\\E"
+  }, {
+    "pattern":"\\Qnet/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd\\E"
+  }, {
+    "pattern":"\\Qnet/woggioni/gbcs/server/schema/gbcs.xsd\\E"
+  }]},
+  "bundles":[{
+    "name":"com.sun.org.apache.xerces.internal.impl.xpath.regex.message",
+    "locales":[""]
+  }, {
+    "name": "com.sun.org.apache.xerces.internal.impl.msg.XMLSchemaMessages"
+  }]
+}

gbcs-native/native-image/serialization-config.json

@@ -0,0 +1,8 @@
+{
+  "types":[
+  ],
+  "lambdaCapturingTypes":[
+  ],
+  "proxies":[
+  ]
+}

gbcs-native/src/main/java/net/woggioni/gbcs/graal/ConfigureNativeServer.java

@@ -0,0 +1,10 @@
+package net.woggioni.gbcs.graal;
+
+import java.time.Duration;
+
+public class ConfigureNativeServer {
+
+    public static void main(String[] args) throws Exception {
+        NativeServer.run(Duration.ofSeconds(60));
+    }
+}

gbcs-native/src/main/java/net/woggioni/gbcs/graal/NativeServer.java

@@ -0,0 +1,45 @@
+package net.woggioni.gbcs.graal;
+
+import net.woggioni.gbcs.server.GradleBuildCacheServer;
+import net.woggioni.jwo.Application;
+
+import java.nio.file.Path;
+import java.time.Duration;
+
+public class NativeServer {
+
+    private static Path findConfigurationFile(Application app, String fileName) {
+        final var confDir = app.computeConfigurationDirectory();
+        final var  configurationFile = confDir.resolve(fileName);
+        return configurationFile;
+    }
+
+    static void run(Duration timeout) throws Exception {
+        final var app = Application.builder("gbcs")
+                .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")
+                .configurationDirectoryPropertyKey("net.woggioni.gbcs.conf.dir")
+                .build();
+
+        final var configurationFile = findConfigurationFile(app, "gbcs-server.xml");
+        final var cfg = GradleBuildCacheServer.Companion.loadConfiguration(configurationFile);
+        try(final var handle = new GradleBuildCacheServer(cfg).run()) {
+            if(timeout != null) {
+                Thread.sleep(timeout);
+                handle.shutdown();
+            }
+        }
+    }
+
+    private static void setPropertyIfNotPresent(String key, String value) {
+        final var previousValue = System.getProperty(key);
+        if(previousValue == null) {
+            System.setProperty(key, value);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        setPropertyIfNotPresent("logback.configurationFile", "net/woggioni/gbcs/graal/logback.xml");
+        setPropertyIfNotPresent("io.netty.leakDetectionLevel", "DISABLED");
+        run(null);
+    }
+}

gbcs-native/src/main/resources/net/woggioni/gbcs/graal/logback.xml

@@ -0,0 +1,18 @@
+<?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>
+</configuration>

gbcs-server-memcache/build.gradle

@@ -6,10 +6,10 @@ plugins {
 
 configurations {
     bundle {
-        extendsFrom runtimeClasspath
         canBeResolved = true
         canBeConsumed = false
         visible = false
+        transitive = false
 
         resolutionStrategy {
             dependencies {
@@ -29,10 +29,20 @@ configurations {
 }
 
 dependencies {
-    compileOnly project(':gbcs-common')
+    implementation project(':gbcs-common')
-    compileOnly project(':gbcs-api')
+    implementation project(':gbcs-api')
-    compileOnly catalog.jwo
+    implementation catalog.jwo
-    implementation catalog.xmemcached
+    implementation catalog.slf4j.api
+    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) {
+    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
 }
 
 Provider<Tar> bundleTask = tasks.register("bundle", Tar) {

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,40 @@
+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,6 +1,5 @@
-package net.woggioni.gbcs.server.memcached
+package net.woggioni.gbcs.server.memcache
 
-import net.rubyeye.xmemcached.transcoders.CompressionMode
 import net.woggioni.gbcs.api.CacheProvider
 import net.woggioni.gbcs.api.exception.ConfigurationException
 import net.woggioni.gbcs.common.GBCS
@@ -11,19 +10,21 @@ 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 MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcached/net/woggioni/gbcs/server/memcached/schema/gbcs-memcached.xsd"
 
-    override fun getXmlType() = "memcachedCacheType"
+class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
+    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd"
 
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcached"
+    override fun getXmlType() = "memcacheCacheType"
+
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcache"
 
     val xmlNamespacePrefix : String
-        get() = "gbcs-memcached"
+        get() = "gbcs-memcache"
 
-    override fun deserialize(el: Element): MemcachedCacheConfiguration {
+    override fun deserialize(el: Element): MemcacheCacheConfiguration {
-        val servers = mutableListOf<HostAndPort>()
+        val servers = mutableListOf<MemcacheCacheConfiguration.Server>()
         val maxAge = el.renderAttribute("max-age")
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
@@ -33,24 +34,30 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
         val compressionMode = el.renderAttribute("compression-mode")
             ?.let {
                 when (it) {
-                    "gzip" -> CompressionMode.GZIP
+                    "gzip" -> MemcacheCacheConfiguration.CompressionMode.GZIP
-                    "zip" -> CompressionMode.ZIP
+                    "deflate" -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
-                    else -> CompressionMode.ZIP
+                    else -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
                 }
             }
-            ?: CompressionMode.ZIP
+            ?: 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")
-                    servers.add(HostAndPort(host, port))
+                    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 MemcachedCacheConfiguration(
+        return MemcacheCacheConfiguration(
             servers,
             maxAge,
             maxSize,
@@ -59,7 +66,7 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
         )
     }
 
-    override fun serialize(doc: Document, cache: MemcachedCacheConfiguration) = cache.run {
+    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/")
@@ -67,8 +74,12 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
             attr("xs:type", "${xmlNamespacePrefix}:$xmlType", GBCS.XML_SCHEMA_NAMESPACE_URI)
             for (server in servers) {
                 node("server") {
-                    attr("host", server.host)
+                    attr("host", server.endpoint.host)
-                    attr("port", server.port.toString())
+                    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())
@@ -76,12 +87,14 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)
             }
-            attr(
+            compressionMode?.let { compressionMode ->
-                "compression-mode", when (compressionMode) {
+                attr(
-                    CompressionMode.GZIP -> "gzip"
+                    "compression-mode", when (compressionMode) {
-                    CompressionMode.ZIP -> "zip"
+                        MemcacheCacheConfiguration.CompressionMode.GZIP -> "gzip"
-                }
+                        MemcacheCacheConfiguration.CompressionMode.DEFLATE -> "deflate"
-            )
+                    }
+                )
+            }
         }
         result
     }

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

@@ -0,0 +1,258 @@
+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

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

gbcs-server-memcache/src/main/resources/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd

@@ -1,33 +1,35 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xs:schema targetNamespace="urn:net.woggioni.gbcs.server.memcached"
+<xs:schema targetNamespace="urn:net.woggioni.gbcs.server.memcache"
-           xmlns:gbcs-memcached="urn:net.woggioni.gbcs.server.memcached"
+           xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
            xmlns:gbcs="urn:net.woggioni.gbcs.server"
            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:complexType name="memcachedServerType">
+    <xs:complexType name="memcacheServerType">
         <xs:attribute name="host" type="xs:token" 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="memcachedCacheType">
+    <xs:complexType name="memcacheCacheType">
         <xs:complexContent>
             <xs:extension base="gbcs:cacheType">
                 <xs:sequence maxOccurs="unbounded">
-                    <xs:element name="server" type="gbcs-memcached:memcachedServerType"/>
+                    <xs:element name="server" type="gbcs-memcache:memcacheServerType"/>
                 </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-memcached:compressionType" default="zip"/>
+                <xs:attribute name="compression-mode" type="gbcs-memcache:compressionType"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>
 
     <xs:simpleType name="compressionType">
         <xs:restriction base="xs:token">
-            <xs:enumeration value="zip"/>
+            <xs:enumeration value="deflate"/>
             <xs:enumeration value="gzip"/>
         </xs:restriction>
     </xs:simpleType>

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

@@ -1,14 +0,0 @@
-import net.woggioni.gbcs.api.CacheProvider;
-
-module net.woggioni.gbcs.server.memcached {
-    requires net.woggioni.gbcs.common;
-    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.server.memcached.MemcachedCacheProvider;
-
-    opens net.woggioni.gbcs.server.memcached.schema;
-}

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

@@ -1,59 +0,0 @@
-package net.woggioni.gbcs.server.memcached
-
-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.common.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-server-memcached/src/main/kotlin/net/woggioni/gbcs/server/memcached/MemcachedCacheConfiguration.kt

@@ -1,26 +0,0 @@
-package net.woggioni.gbcs.server.memcached
-
-import net.rubyeye.xmemcached.transcoders.CompressionMode
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.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.server.memcached"
-
-    override fun getTypeName() = "memcachedCacheType"
-}

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

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

gbcs-server/build.gradle

@@ -1,6 +1,7 @@
 plugins {
     id 'java-library'
     alias catalog.plugins.kotlin.jvm
+    id 'jacoco'
     id 'maven-publish'
 }
 
@@ -17,11 +18,13 @@ dependencies {
 
     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-server-memcached")
+    testRuntimeOnly project(":gbcs-server-memcache")
+}
+
+test {
+    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
+    systemProperty("jdk.httpclient.redirects.retrylimit", "1")
 }
 
 publishing {

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

@@ -1,5 +1,6 @@
 import net.woggioni.gbcs.api.CacheProvider;
 import net.woggioni.gbcs.server.cache.FileSystemCacheProvider;
+import net.woggioni.gbcs.server.cache.InMemoryCacheProvider;
 
 module net.woggioni.gbcs.server {
     requires java.sql;
@@ -24,5 +25,5 @@ module net.woggioni.gbcs.server {
     opens net.woggioni.gbcs.server.schema;
 
     uses CacheProvider;
-    provides CacheProvider with FileSystemCacheProvider;
+    provides CacheProvider with FileSystemCacheProvider, InMemoryCacheProvider;
 }

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

@@ -2,66 +2,56 @@ package net.woggioni.gbcs.server
 
 import io.netty.bootstrap.ServerBootstrap
 import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
 import io.netty.channel.Channel
-import io.netty.channel.ChannelDuplexHandler
 import io.netty.channel.ChannelFuture
-import io.netty.channel.ChannelFutureListener
+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.DefaultFileRegion
-import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.channel.nio.NioEventLoopGroup
 import io.netty.channel.socket.nio.NioServerSocketChannel
-import io.netty.handler.codec.DecoderException
 import io.netty.handler.codec.compression.CompressionOptions
-import io.netty.handler.codec.http.DefaultFullHttpResponse
 import io.netty.handler.codec.http.DefaultHttpContent
-import io.netty.handler.codec.http.DefaultHttpResponse
-import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.FullHttpResponse
 import io.netty.handler.codec.http.HttpContentCompressor
 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.HttpRequest
-import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpServerCodec
-import io.netty.handler.codec.http.HttpUtil
-import io.netty.handler.codec.http.HttpVersion
-import io.netty.handler.codec.http.LastHttpContent
 import io.netty.handler.ssl.ClientAuth
 import io.netty.handler.ssl.SslContext
 import io.netty.handler.ssl.SslContextBuilder
-import io.netty.handler.stream.ChunkedNioFile
+import io.netty.handler.ssl.SslHandler
-import io.netty.handler.stream.ChunkedNioStream
 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.Cache
 import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Role
+import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.api.exception.ContentTooLargeException
-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.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.channels.FileChannel
 import java.nio.file.Files
 import java.nio.file.Path
 import java.security.KeyStore
@@ -69,14 +59,34 @@ 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.SSLEngine
 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,
@@ -99,62 +109,60 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         }
     }
 
+    @Sharable
     private class ClientCertificateAuthenticator(
         authorizer: Authorizer,
-        private val sslEngine: SSLEngine,
+        private val anonymousUserGroups: Set<Configuration.Group>?,
-        private val anonymousUserRoles: Set<Role>?,
         private val userExtractor: Configuration.UserExtractor?,
         private val groupExtractor: Configuration.GroupExtractor?,
     ) : AbstractNettyHttpAuthenticator(authorizer) {
 
-        companion object {
+        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult? {
-            private val log = contextLogger()
-        }
-
-        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): Set<Role>? {
             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)
-                    (group?.roles ?: emptySet()) + (user?.roles ?: emptySet())
+                    val allGroups = ((user?.groups ?: emptySet()).asSequence() + sequenceOf(group).filterNotNull()).toSet()
-                } ?: anonymousUserRoles
+                    AuthenticationResult(user, allGroups)
+                } ?: anonymousUserGroups?.let{ AuthenticationResult(null, it) }
             } catch (es: SSLPeerUnverifiedException) {
-                anonymousUserRoles
+                anonymousUserGroups?.let{ AuthenticationResult(null, it) }
             }
         }
     }
 
+    @Sharable
     private class NettyHttpBasicAuthenticator(
         private val users: Map<String, Configuration.User>, authorizer: Authorizer
     ) : AbstractNettyHttpAuthenticator(authorizer) {
+        private val log = contextLogger()
 
-        companion object {
+        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult? {
-            private val log = contextLogger()
-        }
-
-        override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): Set<Role>? {
             val authorizationHeader = req.headers()[HttpHeaderNames.AUTHORIZATION] ?: let {
                 log.debug(ctx) {
                     "Missing Authorization header"
                 }
-                return users[""]?.roles
+                return users[""]?.let { AuthenticationResult(it, it.groups) }
             }
             val cursor = authorizationHeader.indexOf(' ')
             if (cursor < 0) {
                 log.debug(ctx) {
                     "Invalid Authorization header: '$authorizationHeader'"
                 }
-                return users[""]?.roles
+                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[""]?.roles
+                return users[""]?.let { AuthenticationResult(it, it.groups) }
             }
             val (username, password) = Base64.getDecoder().decode(authorizationHeader.substring(cursor + 1))
                 .let(::String)
@@ -174,7 +182,9 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                     val (_, salt) = decodePasswordHash(passwordAndSalt)
                     hashPassword(password, Base64.getEncoder().encodeToString(salt)) == passwordAndSalt
                 } ?: false
-            }?.roles
+            }?.let { user ->
+                AuthenticationResult(user, user.groups)
+            }
         }
     }
 
@@ -198,15 +208,15 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                             .map { it as X509Certificate }
                             .toArray { size -> Array<X509Certificate?>(size) { null } }
                     SslContextBuilder.forServer(serverKey, *serverCert).apply {
-                        if (tls.isVerifyClients) {
+                        val clientAuth = tls.trustStore?.let { trustStore ->
-                            clientAuth(ClientAuth.OPTIONAL)
+                            val ts = loadKeystore(trustStore.file, trustStore.password)
-                            tls.trustStore?.let { trustStore ->
+                            trustManager(
-                                val ts = loadKeystore(trustStore.file, trustStore.password)
+                                ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
-                                trustManager(
+                            )
-                                    ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
+                            if(trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
-                                )
+                            else ClientAuth.OPTIONAL
-                            }
+                        } ?: ClientAuth.NONE
-                        }
+                        clientAuth(clientAuth)
                     }.build()
                 }
             }
@@ -233,6 +243,31 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
         }
 
+        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) =
@@ -264,182 +299,76 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
 
         override fun initChannel(ch: Channel) {
-            val pipeline = ch.pipeline()
+            log.debug {
-            val auth = cfg.authentication
+                "Created connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
-            var authenticator: AbstractNettyHttpAuthenticator? = null
-            if (auth is Configuration.BasicAuthentication) {
-                authenticator = (NettyHttpBasicAuthenticator(cfg.users, RoleAuthorizer()))
             }
-            if (sslContext != null) {
+            ch.closeFuture().addListener {
-                val sslHandler = sslContext.newHandler(ch.alloc())
+                log.debug {
-                pipeline.addLast(sslHandler)
+                    "Closed connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
-
+                }
-                if (auth is Configuration.ClientCertificateAuthentication) {
+            }
-                    authenticator = ClientCertificateAuthenticator(
+            val pipeline = ch.pipeline()
-                        RoleAuthorizer(),
+            cfg.connection.also { conn ->
-                        sslHandler.engine(),
+                val readTimeout = conn.readTimeout.toMillis()
-                        cfg.users[""]?.roles,
+                val writeTimeout = conn.writeTimeout.toMillis()
-                        userExtractor(auth),
+                if(readTimeout > 0 || writeTimeout > 0) {
-                        groupExtractor(auth)
+                    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(Int.MAX_VALUE))
+            pipeline.addLast(HttpObjectAggregator(cfg.connection.maxRequestSize))
             authenticator?.let {
                 pipeline.addLast(it)
             }
-            val cacheImplementation = cfg.cache.materialize()
+            pipeline.addLast(throttlingHandler)
-            val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
+            pipeline.addLast(eventExecutorGroup, serverHandler)
-            pipeline.addLast(eventExecutorGroup, ServerHandler(cacheImplementation, prefix))
+            pipeline.addLast(exceptionHandler)
-            pipeline.addLast(ExceptionHandler())
-        }
-    }
-
-    private 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"
-        }
-
-        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)
-                }
-
-                else -> {
-                    log.error(cause.message, cause)
-                    ctx.close()
-                }
-            }
-        }
-    }
-
-    private class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
-        SimpleChannelInboundHandler<FullHttpRequest>() {
-
-        companion object {
-            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()
-                if (serverPrefix == prefix) {
-                    cache.get(key)?.let { channel ->
-                        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 -> {
-                                if (keepAlive) {
-                                    ctx.write(ChunkedNioFile(channel))
-                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                                } else {
-                                    ctx.writeAndFlush(DefaultFileRegion(channel, 0, channel.size()))
-                                        .addListener(ChannelFutureListener.CLOSE)
-                                }
-                            }
-
-                            else -> {
-                                ctx.write(ChunkedNioStream(channel))
-                                ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                            }
-                        }
-                    } ?: let {
-                        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)
-                    }
-                } 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"
-                    }
-                    val bodyBytes = msg.content().run {
-                        if (isDirect) {
-                            ByteArray(readableBytes()).also {
-                                readBytes(it)
-                            }
-                        } else {
-                            array()
-                        }
-                    }
-                    cache.put(key, bodyBytes)
-                    val response = DefaultFullHttpResponse(
-                        msg.protocolVersion(), HttpResponseStatus.CREATED,
-                        Unpooled.copiedBuffer(key.toByteArray())
-                    )
-                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
-                    ctx.writeAndFlush(response)
-                } 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 {
-                log.warn(ctx) {
-                    "Got request with unhandled method '${msg.method().name()}'"
-                }
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-                ctx.writeAndFlush(response)
-            }
         }
     }
 
@@ -448,8 +377,8 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         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()
@@ -471,24 +400,23 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
     fun run(): ServerHandle {
         // Create the multithreaded event loops for the server
-        val bossGroup = NioEventLoopGroup(0)
+        val bossGroup = NioEventLoopGroup(1)
         val serverSocketChannel = NioServerSocketChannel::class.java
-        val workerGroup = bossGroup
+        val workerGroup = NioEventLoopGroup(0)
         val eventExecutorGroup = run {
-            val threadFactory = if (cfg.isUseVirtualThread) {
+            val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
                 Thread.ofVirtual().factory()
             } else {
                 null
             }
             DefaultEventExecutorGroup(Runtime.getRuntime().availableProcessors(), threadFactory)
         }
-        // A helper class that simplifies server configuration
         val bootstrap = ServerBootstrap().apply {
             // Configure the server
             group(bossGroup, workerGroup)
             channel(serverSocketChannel)
             childHandler(ServerInitializer(cfg, eventExecutorGroup))
-            option(ChannelOption.SO_BACKLOG, 128)
+            option(ChannelOption.SO_BACKLOG, cfg.incomingConnectionsBacklogSize)
             childOption(ChannelOption.SO_KEEPALIVE, true)
         }
 
@@ -501,22 +429,4 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         }
         return ServerHandle(httpChannel, setOf(bossGroup, workerGroup, eventExecutorGroup))
     }
-
-    companion object {
-
-        val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
-
-        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 val log = contextLogger()
-    }
 }

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/auth/Authenticator.kt

@@ -11,32 +11,48 @@ import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpVersion
 import io.netty.util.ReferenceCountUtil
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.api.Configuration.Group
 import net.woggioni.gbcs.api.Role
+import net.woggioni.gbcs.server.GradleBuildCacheServer
 
 
-abstract class AbstractNettyHttpAuthenticator(private val authorizer : Authorizer)
+abstract class AbstractNettyHttpAuthenticator(private val authorizer: Authorizer) : ChannelInboundHandlerAdapter() {
-        : ChannelInboundHandlerAdapter() {
 
     companion object {
         private val AUTHENTICATION_FAILED: FullHttpResponse = DefaultFullHttpResponse(
-                HttpVersion.HTTP_1_1, HttpResponseStatus.UNAUTHORIZED, Unpooled.EMPTY_BUFFER).apply {
+            HttpVersion.HTTP_1_1, HttpResponseStatus.UNAUTHORIZED, Unpooled.EMPTY_BUFFER
+        ).apply {
             headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
         }
 
         private val NOT_AUTHORIZED: FullHttpResponse = DefaultFullHttpResponse(
-                HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN, Unpooled.EMPTY_BUFFER).apply {
+            HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN, Unpooled.EMPTY_BUFFER
+        ).apply {
             headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
         }
     }
 
+    class AuthenticationResult(val user: Configuration.User?, val groups: Set<Group>)
 
-    abstract fun authenticate(ctx : ChannelHandlerContext, req : HttpRequest) : Set<Role>?
+    abstract fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult?
 
     override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        if(msg is HttpRequest) {
+        if (msg is HttpRequest) {
-            val roles = authenticate(ctx, msg) ?: return authenticationFailure(ctx, msg)
+            val result = authenticate(ctx, msg) ?: return authenticationFailure(ctx, msg)
+            ctx.channel().attr(GradleBuildCacheServer.userAttribute).set(result.user)
+            ctx.channel().attr(GradleBuildCacheServer.groupAttribute).set(result.groups)
+
+            val roles = (
+                (result.user?.let { user ->
+                    user.groups.asSequence().flatMap { group ->
+                        group.roles.asSequence()
+                    }
+                } ?: emptySequence<Role>()) +
+                        result.groups.asSequence().flatMap { it.roles.asSequence() }
+            ).toSet()
             val authorized = authorizer.authorize(roles, msg)
-            if(authorized) {
+            if (authorized) {
                 super.channelRead(ctx, msg)
             } else {
                 authorizationFailure(ctx, msg)

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/auth/ClientCertificateValidator.kt

@@ -19,8 +19,9 @@ import javax.net.ssl.X509TrustManager
 
 
 class ClientCertificateValidator private constructor(
-    private val sslHandler : SslHandler,
+    private val sslHandler: SslHandler,
-    private val x509TrustManager: X509TrustManager) : ChannelInboundHandlerAdapter() {
+    private val x509TrustManager: X509TrustManager
+) : ChannelInboundHandlerAdapter() {
     override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
         if (evt is SslHandshakeCompletionEvent) {
             if (evt.isSuccess) {
@@ -36,13 +37,14 @@ class ClientCertificateValidator private constructor(
     }
 
     companion object {
-        fun getTrustManager(trustStore : KeyStore?, certificateRevocationEnabled : Boolean) : X509TrustManager {
+        fun getTrustManager(trustStore: KeyStore?, certificateRevocationEnabled: Boolean): X509TrustManager {
-            return if(trustStore != null) {
+            return if (trustStore != null) {
                 val certificateFactory = CertificateFactory.getInstance("X.509")
                 val validator = CertPathValidator.getInstance("PKIX").apply {
                     val rc = revocationChecker as PKIXRevocationChecker
                     rc.options = EnumSet.of(
-                        PKIXRevocationChecker.Option.NO_FALLBACK)
+                        PKIXRevocationChecker.Option.NO_FALLBACK
+                    )
                 }
                 val params = PKIXParameters(trustStore).apply {
                     isRevocationEnabled = certificateRevocationEnabled
@@ -52,7 +54,7 @@ class ClientCertificateValidator private constructor(
                         val clientCertificateChain = certificateFactory.generateCertPath(chain.toList())
                         try {
                             validator.validate(clientCertificateChain, params)
-                        } catch (ex : CertPathValidatorException) {
+                        } catch (ex: CertPathValidatorException) {
                             throw CertificateException(ex)
                         }
                     }
@@ -62,7 +64,7 @@ class ClientCertificateValidator private constructor(
                     }
 
                     private val acceptedIssuers = trustStore.aliases().asSequence()
-                        .filter (trustStore::isCertificateEntry)
+                        .filter(trustStore::isCertificateEntry)
                         .map(trustStore::getCertificate)
                         .map { it as X509Certificate }
                         .toList()
@@ -72,11 +74,16 @@ class ClientCertificateValidator private constructor(
                 }
             } else {
                 val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
-                trustManagerFactory.trustManagers.asSequence().filter { it is X509TrustManager }.single() as X509TrustManager
+                trustManagerFactory.trustManagers.asSequence().filter { it is X509TrustManager }
+                    .single() as X509TrustManager
             }
         }
 
-        fun of(sslHandler : SslHandler, trustStore : KeyStore?, certificateRevocationEnabled : Boolean) : ClientCertificateValidator {
+        fun of(
+            sslHandler: SslHandler,
+            trustStore: KeyStore?,
+            certificateRevocationEnabled: Boolean
+        ): ClientCertificateValidator {
             return ClientCertificateValidator(sslHandler, getTrustManager(trustStore, certificateRevocationEnabled))
         }
     }

gbcs-server/src/main/kotlin/net/woggioni/gbcs/server/auth/UserAuthorizer.kt

@@ -8,7 +8,7 @@ class RoleAuthorizer : Authorizer {
 
     companion object {
         private val METHOD_MAP = mapOf(
-            Role.Reader to setOf(HttpMethod.GET, HttpMethod.HEAD),
+            Role.Reader to setOf(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.TRACE),
             Role.Writer to setOf(HttpMethod.PUT, HttpMethod.POST)
         )
     }

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

@@ -1,6 +1,10 @@
 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
@@ -13,13 +17,13 @@ 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,
@@ -28,7 +32,10 @@ class FileSystemCache(
     val compressionLevel: Int
 ) : Cache {
 
-    private fun lockFilePath(key: String): Path = root.resolve("$key.lock")
+    private companion object {
+        @JvmStatic
+        private val log = contextLogger()
+    }
 
     init {
         Files.createDirectories(root)
@@ -41,49 +48,60 @@ class FileSystemCache(
         ?.let { md ->
             digestString(key.toByteArray(), md)
         } ?: key).let { digest ->
-        LockFile.acquire(lockFilePath(digest), true).use {
+        root.resolve(digest).takeIf(Files::exists)
-            root.resolve(digest).takeIf(Files::exists)?.let { file ->
+            ?.let { file ->
-                if (compressionEnabled) {
+                file.takeIf(Files::exists)?.let { file ->
-                    val inflater = Inflater()
+                    if (compressionEnabled) {
-                    Channels.newChannel(InflaterInputStream(Files.newInputStream(file), inflater))
+                        val inflater = Inflater()
-                } else {
+                        Channels.newChannel(
-                    FileChannel.open(file, StandardOpenOption.READ)
+                            InflaterInputStream(
+                                Channels.newInputStream(
+                                    FileChannel.open(
+                                        file,
+                                        StandardOpenOption.READ
+                                    )
+                                ), inflater
+                            )
+                        )
+                    } else {
+                        FileChannel.open(file, StandardOpenOption.READ)
+                    }
                 }
+            }.also {
+                gc()
+            }.let {
+                CompletableFuture.completedFuture(it)
             }
-        }.also {
-            gc()
-        }
     }
 
-    override fun put(key: String, content: ByteArray) {
+    override fun put(key: String, content: ByteBuf): CompletableFuture<Void> {
         (digestAlgorithm
             ?.let(MessageDigest::getInstance)
             ?.let { md ->
                 digestString(key.toByteArray(), md)
             } ?: key).let { digest ->
-            LockFile.acquire(lockFilePath(digest), false).use {
+            val file = root.resolve(digest)
-                val file = root.resolve(digest)
+            val tmpFile = Files.createTempFile(root, null, ".tmp")
-                val tmpFile = Files.createTempFile(root, null, ".tmp")
+            try {
-                try {
+                Files.newOutputStream(tmpFile).let {
-                    Files.newOutputStream(tmpFile).let {
+                    if (compressionEnabled) {
-                        if (compressionEnabled) {
+                        val deflater = Deflater(compressionLevel)
-                            val deflater = Deflater(compressionLevel)
+                        DeflaterOutputStream(it, deflater)
-                            DeflaterOutputStream(it, deflater)
+                    } else {
-                        } else {
+                        it
-                            it
-                        }
-                    }.use {
-                        it.write(content)
                     }
-                    Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
+                }.use {
-                } catch (t: Throwable) {
+                    JWO.copy(ByteBufInputStream(content), it)
-                    Files.delete(tmpFile)
-                    throw t
                 }
+                Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
+            } catch (t: Throwable) {
+                Files.delete(tmpFile)
+                throw t
             }
         }.also {
             gc()
         }
+        return CompletableFuture.completedFuture(null)
     }
 
     private fun gc() {
@@ -97,37 +115,16 @@ class FileSystemCache(
     @Synchronized
     private fun actualGc(now: Instant) {
         Files.list(root).filter {
-            !it.fileName.toString().endsWith(".lock")
-        }.filter {
             val creationTimeStamp = Files.readAttributes(it, BasicFileAttributes::class.java)
                 .creationTime()
                 .toInstant()
             now > creationTimeStamp.plus(maxAge)
         }.forEach { file ->
-            val lockFile = lockFilePath(file.fileName.toString())
+            LockFile.acquire(file, false).use {
-            LockFile.acquire(lockFile, false).use {
                 Files.delete(file)
             }
-            Files.delete(lockFile)
         }
     }
 
     override fun close() {}
-
-    companion object {
-        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-server/src/main/kotlin/net/woggioni/gbcs/server/cache/InMemoryCache.kt

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -19,54 +19,34 @@ 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())
+        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 users: Map<String, User> = mapOf(anonymousUser.name to anonymousUser)
         var groups = emptyMap<String, Group>()
         var tls: Tls? = null
         val serverPath = root.renderAttribute("path")
-        val useVirtualThread = root.renderAttribute("useVirtualThreads")
+        var incomingConnectionsBacklogSize = 1024
-            ?.let(String::toBoolean) ?: true
         var authentication: Authentication? = null
         for (child in root.asIterable()) {
             val tagName = child.localName
             when (tagName) {
-                "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"))
-                }
-
-                "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' not found")
-                    }.deserialize(child)
-                }
-
                 "authentication" -> {
                     for (gchild in child.asIterable()) {
                         when (gchild.localName) {
@@ -98,11 +78,73 @@ object Parser {
                     }
                 }
 
+                "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" -> {
-                    val verifyClients = child.renderAttribute("verify-clients")
-                        ?.let(String::toBoolean) ?: false
                     var keyStore: KeyStore? = null
                     var trustStore: TrustStore? = null
+
                     for (granChild in child.asIterable()) {
                         when (granChild.localName) {
                             "keystore" -> {
@@ -124,19 +166,35 @@ object Parser {
                                 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
+                                    checkCertificateStatus,
+                                    requireClientCertificate
                                 )
                             }
                         }
                     }
-                    tls = Tls(keyStore, trustStore, verifyClients)
+                    tls = Tls(keyStore, trustStore)
                 }
             }
         }
-        return Configuration(host, port, serverPath, users, groups, cache!!, authentication, tls, useVirtualThread)
+        return Configuration.of(
+            host,
+            port,
+            incomingConnectionsBacklogSize,
+            serverPath,
+            eventExecutor,
+            connection,
+            users,
+            groups,
+            cache!!,
+            authentication,
+            tls,
+        )
     }
 
     private fun parseRoles(root: Element) = root.asIterable().asSequence().map {
@@ -148,16 +206,54 @@ object Parser {
     }.toSet()
 
     private fun parseUserRefs(root: Element) = root.asIterable().asSequence().map {
-        it.renderAttribute("ref")
+        when (it.localName) {
-    }.toSet()
+            "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().filter {
+        return root.asIterable().asSequence().mapNotNull { child ->
-            it.localName == "user"
+            when (child.localName) {
-        }.map { el ->
+                "user" -> {
-            val username = el.renderAttribute("name")
+                    val username = child.renderAttribute("name")
-            val password = el.renderAttribute("password")
+                    val password = child.renderAttribute("password")
-            User(username, password, emptySet())
+                    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
+            }
         }
     }
 
@@ -169,6 +265,8 @@ object Parser {
         }.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" -> {
@@ -182,12 +280,18 @@ object Parser {
                     "roles" -> {
                         roles = parseRoles(child)
                     }
+                    "group-quota" -> {
+                        userQuota = parseQuota(child)
+                    }
+                    "user-quota" -> {
+                        groupQuota = parseQuota(child)
+                    }
                 }
             }
-            groupName to Group(groupName, roles)
+            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())
+            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/configuration/Serializer.kt

@@ -8,13 +8,18 @@ import org.w3c.dom.Document
 
 object Serializer {
 
-    fun serialize(conf : Configuration) : Document {
+    private fun Xml.serializeQuota(quota : Configuration.Quota) {
+        attr("calls", quota.calls.toString())
+        attr("period", quota.period.toString())
+        attr("max-available-calls", quota.maxAvailableCalls.toString())
+        attr("initial-available-calls", quota.initialAvailableCalls.toString())
+    }
 
+    fun serialize(conf : Configuration) : Document {
         val schemaLocations = CacheSerializers.index.values.asSequence().map {
             it.xmlNamespace to it.xmlSchemaLocation
         }.toMap()
         return Xml.of(GBCS.GBCS_NAMESPACE_URI, GBCS.GBCS_PREFIX + ":server") {
-            attr("useVirtualThreads", conf.isUseVirtualThread.toString())
 //            attr("xmlns:xs", GradleBuildCacheServer.XML_SCHEMA_NAMESPACE_URI)
             val value = schemaLocations.asSequence().map { (k, v) -> "$k $v" }.joinToString(" ")
             attr("xs:schemaLocation", value , namespaceURI = GBCS.XML_SCHEMA_NAMESPACE_URI)
@@ -27,6 +32,20 @@ object Serializer {
             node("bind") {
                 attr("host", conf.host)
                 attr("port", conf.port.toString())
+                attr("incoming-connections-backlog-size", conf.incomingConnectionsBacklogSize.toString())
+            }
+            node("connection") {
+                conf.connection.let { connection ->
+                    attr("read-timeout", connection.readTimeout.toString())
+                    attr("write-timeout", connection.writeTimeout.toString())
+                    attr("idle-timeout", connection.idleTimeout.toString())
+                    attr("read-idle-timeout", connection.readIdleTimeout.toString())
+                    attr("write-idle-timeout", connection.writeIdleTimeout.toString())
+                    attr("max-request-size", connection.maxRequestSize.toString())
+                }
+            }
+            node("event-executor") {
+                attr("use-virtual-threads", conf.eventExecutor.isUseVirtualThreads.toString())
             }
             val cache = conf.cache
             val serializer : CacheProvider<Configuration.Cache> =
@@ -41,9 +60,24 @@ object Serializer {
                                 user.password?.let { password ->
                                     attr("password", password)
                                 }
+                                user.quota?.let { quota ->
+                                    node("quota") {
+                                        serializeQuota(quota)
+                                    }
+                                }
                             }
                         }
                     }
+                    conf.users[""]
+                        ?.let { anonymousUser ->
+                            anonymousUser.quota?.let { quota ->
+                                node("anonymous") {
+                                    node("quota") {
+                                        serializeQuota(quota)
+                                    }
+                                }
+                            }
+                        }
                 }
                 node("groups") {
                     val groups = conf.users.values.asSequence()
@@ -79,6 +113,16 @@ object Serializer {
                                     }
                                 }
                             }
+                            group.userQuota?.let { quota ->
+                                node("user-quota") {
+                                    serializeQuota(quota)
+                                }
+                            }
+                            group.groupQuota?.let { quota ->
+                                node("group-quota") {
+                                    serializeQuota(quota)
+                                }
+                            }
                         }
                     }
                 }
@@ -132,6 +176,7 @@ object Serializer {
                                 attr("password", password)
                             }
                             attr("check-certificate-status", trustStore.isCheckCertificateStatus.toString())
+                            attr("require-client-certificate", trustStore.isRequireClientCertificate.toString())
                         }
                     }
                 }

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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,99 @@
+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 +1,2 @@
-net.woggioni.gbcs.server.cache.FileSystemCacheProvider
+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,8 +1,17 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+<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"/>
+    <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/>

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

@@ -8,6 +8,8 @@
     <xs:complexType name="serverType">
         <xs:sequence minOccurs="0">
             <xs:element name="bind" type="gbcs:bindType" maxOccurs="1"/>
+            <xs:element name="connection" type="gbcs:connectionType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="event-executor" type="gbcs:eventExecutorType" minOccurs="0" maxOccurs="1"/>
             <xs:element name="cache" type="gbcs:cacheType" maxOccurs="1"/>
             <xs:element name="authorization" type="gbcs:authorizationType" minOccurs="0">
                 <xs:key name="userId">
@@ -23,16 +25,41 @@
             <xs:element name="tls" type="gbcs:tlsType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
         <xs:attribute name="path" type="xs:string" use="optional"/>
-        <xs:attribute name="useVirtualThreads" type="xs:boolean" use="optional" default="true"/>
     </xs:complexType>
 
     <xs:complexType name="bindType">
         <xs:attribute name="host" type="xs:token" use="required"/>
         <xs:attribute name="port" type="xs:unsignedShort" use="required"/>
+        <xs:attribute name="incoming-connections-backlog-size" type="xs:unsignedInt" use="optional" default="1024"/>
+    </xs:complexType>
+
+    <xs:complexType name="connectionType">
+        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="idle-timeout" type="xs:duration" use="optional" default="PT30S"/>
+        <xs:attribute name="read-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
+        <xs:attribute name="write-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
+        <xs:attribute name="max-request-size" type="xs:unsignedInt" use="optional" default="67108864"/>
+    </xs:complexType>
+
+    <xs:complexType name="eventExecutorType">
+        <xs:attribute name="use-virtual-threads" type="xs:boolean" use="optional" default="true"/>
     </xs:complexType>
 
     <xs:complexType name="cacheType" abstract="true"/>
 
+    <xs:complexType name="inMemoryCacheType">
+        <xs:complexContent>
+            <xs:extension base="gbcs:cacheType">
+                <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
+                <xs:attribute name="max-size" type="xs:token" default="0x1000000"/>
+                <xs:attribute name="digest" type="xs:token" default="MD5"/>
+                <xs:attribute name="enable-compression" type="xs:boolean" default="true"/>
+                <xs:attribute name="compression-level" type="xs:byte" default="-1"/>
+            </xs:extension>
+        </xs:complexContent>
+    </xs:complexType>
+
     <xs:complexType name="fileSystemCacheType">
         <xs:complexContent>
             <xs:extension base="gbcs:cacheType">
@@ -77,17 +104,34 @@
         </xs:choice>
     </xs:complexType>
 
-    <xs:complexType name="usersType">
+    <xs:complexType name="quotaType">
+        <xs:attribute name="calls" type="xs:positiveInteger" use="required"/>
+        <xs:attribute name="period" type="xs:duration" use="required"/>
+        <xs:attribute name="max-available-calls" type="xs:positiveInteger" use="optional"/>
+        <xs:attribute name="initial-available-calls" type="xs:unsignedInt" use="optional"/>
+    </xs:complexType>
+
+    <xs:complexType name="anonymousUserType">
         <xs:sequence>
-            <xs:element name="user" type="gbcs:userType" minOccurs="0" maxOccurs="unbounded"/>
+            <xs:element name="quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="userType">
+        <xs:sequence>
+            <xs:element name="quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
+        </xs:sequence>
         <xs:attribute name="name" type="xs:token" use="required"/>
         <xs:attribute name="password" type="xs:string" use="optional"/>
     </xs:complexType>
 
+    <xs:complexType name="usersType">
+        <xs:sequence>
+            <xs:element name="user" type="gbcs:userType" minOccurs="0" maxOccurs="unbounded"/>
+            <xs:element name="anonymous" type="gbcs:anonymousUserType" minOccurs="0" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
     <xs:complexType name="groupsType">
         <xs:sequence>
             <xs:element name="group" type="gbcs:groupType" maxOccurs="unbounded" minOccurs="0"/>
@@ -103,6 +147,8 @@
                 </xs:unique>
             </xs:element>
             <xs:element name="roles" type="gbcs:rolesType" maxOccurs="1" minOccurs="0"/>
+            <xs:element name="user-quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="group-quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
         <xs:attribute name="name" type="xs:token"/>
     </xs:complexType>
@@ -139,7 +185,6 @@
             <xs:element name="keystore" type="gbcs:keyStoreType" />
             <xs:element name="truststore" type="gbcs:trustStoreType" minOccurs="0"/>
         </xs:all>
-        <xs:attribute name="verify-clients" type="xs:boolean" use="optional"/>
     </xs:complexType>
 
     <xs:complexType name="keyStoreType">
@@ -153,6 +198,7 @@
         <xs:attribute name="file" type="xs:string" use="required"/>
         <xs:attribute name="password" type="xs:string"/>
         <xs:attribute name="check-certificate-status" type="xs:boolean"/>
+        <xs:attribute name="require-client-certificate" type="xs:boolean" use="optional" default="false"/>
     </xs:complexType>
 
     <xs:complexType name="propertiesType">

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

@@ -11,6 +11,7 @@ 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
@@ -23,17 +24,27 @@ abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
     protected val random = Random(101325)
     protected val keyValuePair = newEntry(random)
     protected val serverPath = "gbcs"
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
+    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(
+        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,
@@ -44,7 +55,6 @@ abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
             ),
             Configuration.BasicAuthentication(),
             null,
-            true,
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }

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

@@ -1,7 +1,7 @@
 package net.woggioni.gbcs.server.test
 
-import net.woggioni.gbcs.server.GradleBuildCacheServer
 import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.server.GradleBuildCacheServer
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.MethodOrderer

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

@@ -18,6 +18,7 @@ import java.nio.file.Path
 import java.security.KeyStore
 import java.security.KeyStore.PasswordProtection
 import java.time.Duration
+import java.time.temporal.ChronoUnit
 import java.util.Base64
 import java.util.zip.Deflater
 import javax.net.ssl.KeyManagerFactory
@@ -44,8 +45,8 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
     private lateinit var trustStore: KeyStore
     protected lateinit var ca: X509Credentials
 
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
+    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, null)
     protected val random = Random(101325)
     protected val keyValuePair = newEntry(random)
     private val serverPath : String? = null
@@ -138,7 +139,17 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
         cfg = Configuration(
             "127.0.0.1",
             NetworkUtils.getFreePort(),
+            100,
             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,
@@ -147,16 +158,20 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
                 compressionLevel = Deflater.DEFAULT_COMPRESSION,
                 digestAlgorithm = "MD5"
             ),
+//            InMemoryCacheConfiguration(
+//                maxAge = Duration.ofSeconds(3600 * 24),
+//                compressionEnabled = true,
+//                compressionLevel = Deflater.DEFAULT_COMPRESSION,
+//                digestAlgorithm = "MD5"
+//            ),
             Configuration.ClientCertificateAuthentication(
                 Configuration.TlsCertificateExtractor("CN", "(.*)"),
                 null
             ),
             Configuration.Tls(
                 Configuration.KeyStore(this.serverKeyStoreFile, null, SERVER_CERTIFICATE_ENTRY, PASSWORD),
-                Configuration.TrustStore(this.trustStoreFile, null, false),
+                Configuration.TrustStore(this.trustStoreFile, null, false, false),
-                true
+            )
-            ),
-            false,
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }

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

@@ -10,6 +10,8 @@ import org.junit.jupiter.api.Test
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
+import java.time.Duration
+import java.time.temporal.ChronoUnit
 
 
 class BasicAuthServerTest : AbstractBasicAuthServerTest() {
@@ -19,10 +21,16 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
     }
 
     override val users = listOf(
-        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup)),
+        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup), null),
-        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup)),
+        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup), null),
-        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup)),
+        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup), null),
-        Configuration.User("", null, setOf(readersGroup))
+        Configuration.User("", null, setOf(readersGroup), null),
+        Configuration.User("user4", hashPassword(PASSWORD), setOf(readersGroup),
+            Configuration.Quota(1, Duration.of(1, ChronoUnit.DAYS), 0, 1)
+        ),
+        Configuration.User("user5", hashPassword(PASSWORD), setOf(readersGroup),
+            Configuration.Quota(1, Duration.of(5, ChronoUnit.SECONDS), 0, 1)
+        )
     )
 
     @Test
@@ -144,4 +152,41 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
         val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
         Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
     }
+
+    @Test
+    @Order(6)
+    fun getAsAThrottledUser() {
+        val client: HttpClient = HttpClient.newHttpClient()
+
+        val (key, value) = keyValuePair
+        val user = cfg.users.values.find {
+            it.name == "user4"
+        } ?: throw RuntimeException("user4 not found")
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .GET()
+
+        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        Assertions.assertEquals(HttpResponseStatus.TOO_MANY_REQUESTS.code(), response.statusCode())
+    }
+
+    @Test
+    @Order(7)
+    fun getAsAThrottledUser2() {
+        val client: HttpClient = HttpClient.newHttpClient()
+
+        val (key, value) = keyValuePair
+        val user = cfg.users.values.find {
+            it.name == "user5"
+        } ?: throw RuntimeException("user5 not found")
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .GET()
+
+        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
+        Assertions.assertArrayEquals(value, response.body())
+    }
 }

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

@@ -9,6 +9,7 @@ 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
 
@@ -16,9 +17,10 @@ class ConfigurationTest {
 
     @ValueSource(
         strings = [
-            "classpath:net/woggioni/gbcs/server/test/gbcs-default.xml",
+            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-default.xml",
-            "classpath:net/woggioni/gbcs/server/test/gbcs-memcached.xml",
+            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached.xml",
-            "classpath:net/woggioni/gbcs/server/test/gbcs-tls.xml",
+            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-tls.xml",
+            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached-tls.xml",
         ]
     )
     @ParameterizedTest
@@ -35,4 +37,20 @@ class ConfigurationTest {
         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

@@ -18,9 +18,9 @@ class NoAnonymousUserBasicAuthServerTest : AbstractBasicAuthServerTest() {
     }
 
     override val users = listOf(
-        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup)),
+        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup), null),
-        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup)),
+        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup), null),
-        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup)),
+        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup), null),
     )
 
     @Test

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

@@ -12,9 +12,9 @@ import java.net.http.HttpResponse
 class NoAnonymousUserTlsServerTest : AbstractTlsServerTest() {
 
     override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup)),
+        Configuration.User("user1", null, setOf(readersGroup), null),
-        Configuration.User("user2", null, setOf(writersGroup)),
+        Configuration.User("user2", null, setOf(writersGroup), null),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup)),
+        Configuration.User("user3", null, setOf(readersGroup, writersGroup), null),
     )
 
     @Test

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

@@ -3,7 +3,7 @@ package net.woggioni.gbcs.server.test
 import io.netty.handler.codec.http.HttpResponseStatus
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
+import net.woggioni.gbcs.server.cache.InMemoryCacheConfiguration
 import net.woggioni.gbcs.server.configuration.Serializer
 import net.woggioni.gbcs.server.test.utils.NetworkUtils
 import org.junit.jupiter.api.Assertions
@@ -15,6 +15,7 @@ import java.net.http.HttpRequest
 import java.net.http.HttpResponse
 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
@@ -22,7 +23,7 @@ import kotlin.random.Random
 
 class NoAuthServerTest : AbstractServerTest() {
 
-    private lateinit var cacheDir : Path
+    private lateinit var cacheDir: Path
 
     private val random = Random(101325)
     private val keyValuePair = newEntry(random)
@@ -33,19 +34,28 @@ class NoAuthServerTest : AbstractServerTest() {
         cfg = Configuration(
             "127.0.0.1",
             NetworkUtils.getFreePort(),
+            100,
             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
+            ),
             emptyMap(),
             emptyMap(),
-            FileSystemCacheConfiguration(
+            InMemoryCacheConfiguration(
-                this.cacheDir,
                 maxAge = Duration.ofSeconds(3600 * 24),
                 compressionEnabled = true,
                 digestAlgorithm = "MD5",
-                compressionLevel = Deflater.DEFAULT_COMPRESSION
+                compressionLevel = Deflater.DEFAULT_COMPRESSION,
+                maxSize = 0x1000000
             ),
             null,
             null,
-            true,
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }
@@ -53,10 +63,10 @@ class NoAuthServerTest : AbstractServerTest() {
     override fun tearDown() {
     }
 
-    fun newRequestBuilder(key : String) = HttpRequest.newBuilder()
+    fun newRequestBuilder(key: String) = HttpRequest.newBuilder()
         .uri(URI.create("http://${cfg.host}:${cfg.port}/$serverPath/$key"))
 
-    fun newEntry(random : Random) : Pair<String, ByteArray> {
+    fun newEntry(random: Random): Pair<String, ByteArray> {
         val key = ByteArray(0x10).let {
             random.nextBytes(it)
             Base64.getUrlEncoder().encodeToString(it)
@@ -85,10 +95,11 @@ class NoAuthServerTest : AbstractServerTest() {
     @Order(2)
     fun getWithNoAuthorizationHeader() {
         val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value ) = keyValuePair
+        val (key, value) = keyValuePair
         val requestBuilder = newRequestBuilder(key)
             .GET()
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        val response: HttpResponse<ByteArray> =
+            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
         Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
         Assertions.assertArrayEquals(value, response.body())
     }
@@ -101,31 +112,23 @@ class NoAuthServerTest : AbstractServerTest() {
         val (key, _) = newEntry(random)
         val requestBuilder = newRequestBuilder(key).GET()
 
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        val response: HttpResponse<ByteArray> =
+            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
         Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
     }
 
-//    @Test
+    @Test
-//    @Order(4)
+    @Order(4)
-//    fun manyRequestsTest() {
+    fun traceTest() {
-//        val client: HttpClient = HttpClient.newHttpClient()
+        val client: HttpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()
-//
+        val requestBuilder = newRequestBuilder("").method(
-//        for(i in 0 until 100000) {
+            "TRACE",
-//
+            HttpRequest.BodyPublishers.ofByteArray("sfgsdgfaiousfiuhsd".toByteArray())
-//            val newEntry = random.nextBoolean()
+        )
-//            val (key, _) = if(newEntry) {
+
-//                newEntry(random)
+        val response: HttpResponse<ByteArray> =
-//            } else {
+            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-//                keyValuePair
+        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-//            }
+        println(String(response.body()))
-//            val requestBuilder = newRequestBuilder(key).GET()
+    }
-//
-//            val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-//            if(newEntry) {
-//                Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
-//            } else {
-//                Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-//            }
-//        }
-//    }
 }

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

@@ -15,10 +15,10 @@ import java.net.http.HttpResponse
 class TlsServerTest : AbstractTlsServerTest() {
 
     override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup)),
+        Configuration.User("user1", null, setOf(readersGroup), null),
-        Configuration.User("user2", null, setOf(writersGroup)),
+        Configuration.User("user2", null, setOf(writersGroup), null),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup)),
+        Configuration.User("user3", null, setOf(readersGroup, writersGroup), null),
-        Configuration.User("", null, setOf(readersGroup))
+        Configuration.User("", null, setOf(readersGroup), null)
     )
 
     @Test
@@ -133,4 +133,19 @@ class TlsServerTest : AbstractTlsServerTest() {
         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/net/woggioni/gbcs/server/test/gbcs-memcached.xml

@@ -1,13 +0,0 @@
-<?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.server"
-             xmlns:gbcs-memcached="urn:net.woggioni.gbcs.server.memcached"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server.memcached jpms://net.woggioni.gbcs.server.memcached/net/woggioni/gbcs/server/memcached/schema/gbcs-memcached.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" />
-    <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="101325" digest="SHA-256">
-        <server host="127.0.0.1" port="11211"/>
-    </cache>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

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

@@ -0,0 +1,19 @@
+<?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

@@ -0,0 +1,25 @@
+<?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

@@ -0,0 +1,24 @@
+<?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,10 +1,15 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+<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"/>
-    <authentication>
+    <authorization>
-        <none/>
+        <users>
-    </authentication>
+            <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

@@ -0,0 +1,18 @@
+<?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>