fixed throttling retry-after estimation

.gitea/workflows/build.yaml

@@ -44,7 +44,7 @@ jobs:
           target: release
           cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       -
-        name: Build gbcs memcache Docker image
+        name: Build gbcs memcached Docker image
         uses: docker/build-push-action@v5.3.0
         with:
           context: "docker/build/docker"
@@ -52,9 +52,9 @@ jobs:
           push: true
           pull: true
           tags: |
-            gitea.woggioni.net/woggioni/gbcs:memcache
+            gitea.woggioni.net/woggioni/gbcs:memcached
-            gitea.woggioni.net/woggioni/gbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
+            gitea.woggioni.net/woggioni/gbcs:memcached-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-memcache
+          target: release-memcached
           cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
           cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       - name: Publish artifacts

build.gradle

@@ -46,12 +46,6 @@ allprojects { subproject ->
             }
         }
 
-        dependencies {
-            testImplementation catalog.junit.jupiter.api
-            testImplementation catalog.junit.jupiter.params
-            testRuntimeOnly catalog.junit.jupiter.engine
-        }
-
         test {
             useJUnitPlatform()
         }

docker/Dockerfile

@@ -7,10 +7,10 @@ FROM base-release AS release
 ADD gbcs-cli-envelope-*.jar gbcs.jar
 ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]
 
-FROM base-release AS release-memcache
+FROM base-release AS release-memcached
 ADD --chown=luser:luser gbcs-cli-envelope-*.jar gbcs.jar
 RUN mkdir plugins
 WORKDIR /home/luser/plugins
-RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcache*.tar
+RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcached*.tar
 WORKDIR /home/luser
 ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]

docker/build.gradle

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

gbcs-api/build.gradle

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

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

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

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

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

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

@@ -56,8 +56,7 @@ public class Configuration {
         @EqualsAndHashCode.Include
         String name;
         Set<Role> roles;
-        Quota groupQuota;
+        Quota quota;
-        Quota userQuota;
     }
 
     @Value
@@ -92,14 +91,11 @@ public class Configuration {
         boolean verifyClients;
     }
 
-    public enum ClientCertificate {
-        REQUIRED, OPTIONAL
-    }
-
     @Value
     public static class Tls {
         KeyStore keyStore;
         TrustStore trustStore;
+        boolean verifyClients;
     }
 
     @Value
@@ -115,7 +111,6 @@ public class Configuration {
         Path file;
         String password;
         boolean checkCertificateStatus;
-        boolean requireClientCertificate;
     }
 
     @Value

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

@@ -1,5 +1,7 @@
 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
@@ -8,11 +10,10 @@ import net.woggioni.gbcs.cli.impl.commands.GetCommand
 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
+import java.net.URI
 
 
 @CommandLine.Command(

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

@@ -1,17 +1,19 @@
 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.gbcs.client.GradleBuildCacheClient
 import net.woggioni.jwo.JWO
 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
 
@@ -33,13 +35,6 @@ 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 ->
@@ -53,60 +48,58 @@ class BenchmarkCommand : GbcsCommand() {
             while (true) {
                 val key = JWO.bytesToHex(random.nextBytes(16))
                 val content = random.nextInt().toByte()
-                val value = ByteArray(size, { _ -> content })
+                val value = ByteArray(0x1000, { _ -> content })
                 yield(key to value)
             }
         }
 
-        log.info {
-            "Starting insertion"
-        }
         val entries = let {
-            val completionCounter = AtomicLong(0)
+            val completionQueue = LinkedBlockingQueue<Future<Pair<String, ByteArray>>>(numberOfEntries)
-            val completionQueue = LinkedBlockingQueue<Pair<String, ByteArray>>(numberOfEntries)
             val start = Instant.now()
-            val semaphore = Semaphore(profile.maxConnections * 3)
+            val totalElapsedTime = AtomicLong(0)
-            val iterator = entryGenerator.take(numberOfEntries).iterator()
+            entryGenerator.take(numberOfEntries).forEach { entry ->
-            while(completionCounter.get() < numberOfEntries) {
+                val requestStart = System.nanoTime()
-                if(iterator.hasNext()) {
-                    val entry = iterator.next()
-                    semaphore.acquire()
                 val future = client.put(entry.first, entry.second).thenApply { entry }
-                    future.whenComplete { result, ex ->
+                future.whenComplete { _, _ ->
-                        if (ex != null) {
+                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
-                            log.error(ex.message, ex)
+                    completionQueue.put(future)
-                        } else {
-                            completionQueue.put(result)
-                        }
-                        semaphore.release()
-                        completionCounter.incrementAndGet()
-                    }
                 }
             }
 
-            val inserted = completionQueue.toList()
+            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()
-                val opsPerSecond = String.format("%.2f", numberOfEntries.toDouble() / elapsed * 1000)
+                "Insertion rate: ${numberOfEntries.toDouble() / elapsed * 1000} ops/s"
-                "Insertion rate: $opsPerSecond ops/s"
+            }
+            log.info {
+                "Average time per insertion: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1000} ms"
             }
             inserted
         }
         log.info {
             "Inserted ${entries.size} entries"
         }
-        log.info {
-            "Starting retrieval"
-        }
         if (entries.isNotEmpty()) {
-            val completionCounter = AtomicLong(0)
+            val completionQueue = LinkedBlockingQueue<Future<Unit>>(entries.size)
-            val semaphore = Semaphore(profile.maxConnections * 3)
             val start = Instant.now()
+            val totalElapsedTime = AtomicLong(0)
             entries.forEach { entry ->
-                semaphore.acquire()
+                val requestStart = System.nanoTime()
-
                 val future = client.get(entry.first).thenApply {
+                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
                     if (it == null) {
                         log.error {
                             "Missing entry for key '${entry.first}'"
@@ -118,15 +111,21 @@ class BenchmarkCommand : GbcsCommand() {
                     }
                 }
                 future.whenComplete { _, _ ->
-                    completionCounter.incrementAndGet()
+                    completionQueue.put(future)
-                    semaphore.release()
                 }
             }
+            var completionCounter = 0
+            while (completionCounter < entries.size) {
+                completionQueue.take()
+                completionCounter += 1
+            }
             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: ${entries.size.toDouble() / elapsed * 1000} ops/s"
-                "Retrieval rate: $opsPerSecond ops/s"
+            }
+            log.info {
+                "Average time per retrieval: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1e6} ms"
             }
         } 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/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.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
 import picocli.CommandLine
 import java.nio.file.Files
 import java.nio.file.Path

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.GradleBuildCacheClient
-import net.woggioni.gbcs.common.contextLogger
 import picocli.CommandLine
 import java.io.InputStream
 

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

@@ -1,12 +1,12 @@
 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.common.contextLogger
 import net.woggioni.gbcs.common.debug
 import net.woggioni.gbcs.common.info
-import net.woggioni.gbcs.server.GradleBuildCacheServer
+import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
 import net.woggioni.jwo.Application
 import net.woggioni.jwo.JWO
 import picocli.CommandLine

gbcs-client/build.gradle

@@ -10,8 +10,6 @@ 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

@@ -66,18 +66,11 @@ class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoC
             data class BasicAuthenticationCredentials(val username: String, val password: String) : Authentication()
         }
 
-        class RetryPolicy(
-            val maxAttempts: Int,
-            val initialDelayMillis: Long,
-            val exp: Double
-        )
-
         data class Profile(
             val serverURI: URI,
             val authentication: Authentication?,
             val connectionTimeout : Duration?,
-            val maxConnections: Int,
+            val maxConnections : Int
-            val retryPolicy: RetryPolicy?,
         )
 
         companion object {
@@ -168,55 +161,9 @@ class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoC
         pool = FixedChannelPool(bootstrap, channelPoolHandler, profile.maxConnections)
     }
 
-    private fun executeWithRetry(operation: () -> CompletableFuture<FullHttpResponse>): CompletableFuture<FullHttpResponse> {
-        val retryPolicy = profile.retryPolicy
-        return if (retryPolicy != null) {
-            val outcomeHandler = OutcomeHandler<FullHttpResponse> { outcome ->
-                when (outcome) {
-                    is OperationOutcome.Success -> {
-                        val response = outcome.result
-                        val status = response.status()
-                        when (status) {
-                            HttpResponseStatus.TOO_MANY_REQUESTS -> {
-                                val retryAfter = response.headers()[HttpHeaderNames.RETRY_AFTER]?.let { headerValue ->
-                                    try {
-                                        headerValue.toLong() * 1000
-                                    } catch (nfe: NumberFormatException) {
-                                        null
-                                    }
-                                }
-                                OutcomeHandlerResult.Retry(retryAfter)
-                            }
-
-                            HttpResponseStatus.INTERNAL_SERVER_ERROR, HttpResponseStatus.SERVICE_UNAVAILABLE ->
-                                OutcomeHandlerResult.Retry()
-
-                            else -> OutcomeHandlerResult.DoNotRetry()
-                        }
-                    }
-
-                    is OperationOutcome.Failure -> {
-                        OutcomeHandlerResult.Retry()
-                    }
-                }
-            }
-            executeWithRetry(
-                group,
-                retryPolicy.maxAttempts,
-                retryPolicy.initialDelayMillis.toDouble(),
-                retryPolicy.exp,
-                outcomeHandler,
-                operation
-            )
-        } else {
-            operation()
-        }
-    }
-
     fun get(key: String): CompletableFuture<ByteArray?> {
-        return executeWithRetry {
+        return sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
-            sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
+            .thenApply {
-        }.thenApply {
                 val status = it.status()
                 if (it.status() == HttpResponseStatus.NOT_FOUND) {
                     null
@@ -235,9 +182,7 @@ class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoC
     }
 
     fun put(key: String, content: ByteArray): CompletableFuture<Unit> {
-        return executeWithRetry {
+        return sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content).thenApply {
-            sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content)
-        }.thenApply {
             val status = it.status()
             if (it.status() != HttpResponseStatus.CREATED && it.status() != HttpResponseStatus.OK) {
                 throw HttpException(status)

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.GradleBuildCacheClient
 import org.w3c.dom.Document
 import java.net.URI
 import java.nio.file.Files
@@ -17,18 +17,16 @@ object Parser {
 
     fun parse(document: Document): GradleBuildCacheClient.Configuration {
         val root = document.documentElement
+
         val profiles = mutableMapOf<String, GradleBuildCacheClient.Configuration.Profile>()
 
         for (child in root.asIterable()) {
             val tagName = child.localName
             when (tagName) {
                 "profile" -> {
-                    val name =
+                    val name = child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
-                        child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
+                    val uri = child.renderAttribute("base-url")?.let(::URI) ?: throw ConfigurationException("base-url attribute is required")
-                    val uri = child.renderAttribute("base-url")?.let(::URI)
-                        ?: throw ConfigurationException("base-url attribute is required")
                     var authentication: GradleBuildCacheClient.Configuration.Authentication? = null
-                    var retryPolicy: GradleBuildCacheClient.Configuration.RetryPolicy? = null
                     for (gchild in child.asIterable()) {
                         when (gchild.localName) {
                             "tls-client-auth" -> {
@@ -49,42 +47,14 @@ object Parser {
                                     .toList()
                                     .toTypedArray()
                                 authentication =
-                                    GradleBuildCacheClient.Configuration.Authentication.TlsClientAuthenticationCredentials(
+                                    GradleBuildCacheClient.Configuration.Authentication.TlsClientAuthenticationCredentials(key, certChain)
-                                        key,
-                                        certChain
-                                    )
                             }
 
                             "basic-auth" -> {
-                                val username = gchild.renderAttribute("user")
+                                val username = gchild.renderAttribute("user") ?: throw ConfigurationException("username attribute is required")
-                                    ?: throw ConfigurationException("username attribute is required")
+                                val password = gchild.renderAttribute("password") ?: throw ConfigurationException("password attribute is required")
-                                val password = gchild.renderAttribute("password")
-                                    ?: throw ConfigurationException("password attribute is required")
                                 authentication =
-                                    GradleBuildCacheClient.Configuration.Authentication.BasicAuthenticationCredentials(
+                                    GradleBuildCacheClient.Configuration.Authentication.BasicAuthenticationCredentials(username, password)
-                                        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()
-                                )
                             }
                         }
                     }
@@ -93,13 +63,7 @@ object Parser {
                         ?: 50
                     val connectionTimeout = child.renderAttribute("connection-timeout")
                         ?.let(Duration::parse)
-                    profiles[name] = GradleBuildCacheClient.Configuration.Profile(
+                    profiles[name] = GradleBuildCacheClient.Configuration.Profile(uri, authentication, connectionTimeout, maxConnections)
-                        uri,
-                        authentication,
-                        connectionTimeout,
-                        maxConnections,
-                        retryPolicy
-                    )
                 }
             }
         }

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

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

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

@@ -13,14 +13,11 @@
     </xs:complexType>
 
     <xs:complexType name="profileType">
-        <xs:sequence>
         <xs:choice>
             <xs:element name="no-auth" type="gbcs-client:noAuthType"/>
             <xs:element name="basic-auth" type="gbcs-client:basicAuthType"/>
             <xs:element name="tls-client-auth" type="gbcs-client:tlsClientAuthType"/>
         </xs:choice>
-            <xs:element name="retry-policy" type="gbcs-client:retryType" minOccurs="0"/>
-        </xs:sequence>
         <xs:attribute name="name" type="xs:token" use="required"/>
         <xs:attribute name="base-url" type="xs:anyURI" use="required"/>
         <xs:attribute name="max-connections" type="xs:positiveInteger" default="50"/>
@@ -41,10 +38,4 @@
         <xs:attribute name="key-password" type="xs:string" use="optional"/>
     </xs:complexType>
 
-    <xs:complexType name="retryType">
-        <xs:attribute name="max-attempts" type="xs:positiveInteger" use="required"/>
-        <xs:attribute name="initial-delay" type="xs:duration" default="PT1S"/>
-        <xs:attribute name="exp" type="xs:double" default="2.0"/>
-    </xs:complexType>
-
 </xs:schema>

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

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

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

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

gbcs-common/build.gradle

@@ -9,7 +9,6 @@ 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,7 +4,6 @@ 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

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

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

@@ -1,9 +1,7 @@
 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)
@@ -11,19 +9,4 @@ 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,6 +5,7 @@ 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

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

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

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

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

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

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

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

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

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

@@ -1,242 +0,0 @@
-package net.woggioni.gbcs.server.memcache.client
-
-
-import io.netty.bootstrap.Bootstrap
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
-import io.netty.channel.Channel
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelOption
-import io.netty.channel.ChannelPipeline
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.pool.AbstractChannelPoolHandler
-import io.netty.channel.pool.ChannelPool
-import io.netty.channel.pool.FixedChannelPool
-import io.netty.channel.socket.nio.NioSocketChannel
-import io.netty.handler.codec.DecoderException
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheClientCodec
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheObjectAggregator
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
-import io.netty.handler.codec.memcache.binary.DefaultFullBinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.FullBinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.FullBinaryMemcacheResponse
-import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.gbcs.common.ByteBufInputStream
-import net.woggioni.gbcs.common.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("handler", object : SimpleChannelInboundHandler<FullBinaryMemcacheResponse>() {
-                            override fun channelRead0(
-                                ctx: ChannelHandlerContext,
-                                msg: FullBinaryMemcacheResponse
-                            ) {
-                                pipeline.removeLast()
-                                pool.release(channel)
-                                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)
-                            }
-                        })
-                    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 ->
-            when (val status = response.status()) {
-                BinaryMemcacheResponseStatus.SUCCESS -> {
-                    val compressionMode = cfg.compressionMode
-                    val content = response.content()
-                    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)
-            }
-        }
-    }
-
-    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
-            val payload = if (compressionMode != null) {
-                val inputStream = ByteBufInputStream(Unpooled.wrappedBuffer(content))
-                val baos = ByteArrayOutputStream()
-                val outputStream = when (compressionMode) {
-                    MemcacheCacheConfiguration.CompressionMode.GZIP -> {
-                        GZIPOutputStream(baos)
-                    }
-
-                    MemcacheCacheConfiguration.CompressionMode.DEFLATE -> {
-                        DeflaterOutputStream(baos, Deflater(Deflater.DEFAULT_COMPRESSION, false))
-                    }
-                }
-                inputStream.use { i ->
-                    outputStream.use { o ->
-                        JWO.copy(i, o)
-                    }
-                }
-                Unpooled.wrappedBuffer(baos.toByteArray())
-            } else {
-                content
-            }
-            DefaultFullBinaryMemcacheRequest(Unpooled.wrappedBuffer(digest), extras, payload).apply {
-                setOpcode(BinaryMemcacheOpcodes.SET)
-                cas?.let(this::setCas)
-            }
-        }
-        return sendRequest(request).thenApply { response ->
-            when(val status = response.status()) {
-                BinaryMemcacheResponseStatus.SUCCESS -> null
-                else -> throw MemcacheException(status)
-            }
-        }
-    }
-
-
-    fun shutDown(): NettyFuture<*> {
-        return group.shutdownGracefully()
-    }
-
-    override fun close() {
-        shutDown().sync()
-    }
-}

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

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

gbcs-server-memcached/build.gradle

@@ -6,10 +6,10 @@ plugins {
 
 configurations {
     bundle {
+        extendsFrom runtimeClasspath
         canBeResolved = true
         canBeConsumed = false
         visible = false
-        transitive = false
 
         resolutionStrategy {
             dependencies {
@@ -29,20 +29,10 @@ configurations {
 }
 
 dependencies {
-    implementation project(':gbcs-common')
+    compileOnly project(':gbcs-common')
-    implementation project(':gbcs-api')
+    compileOnly project(':gbcs-api')
-    implementation catalog.jwo
+    compileOnly catalog.jwo
-    implementation catalog.slf4j.api
+    implementation catalog.xmemcached
-    implementation catalog.netty.common
-    implementation catalog.netty.codec.memcache
-
-    bundle catalog.netty.codec.memcache
-
-    testRuntimeOnly catalog.logback.classic
-}
-
-tasks.named(JavaPlugin.TEST_TASK_NAME, Test) {
-    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
 }
 
 Provider<Tar> bundleTask = tasks.register("bundle", Tar) {

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

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

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

@@ -0,0 +1,26 @@
+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/kotlin/net/woggioni/gbcs/server/memcached/MemcachedCacheProvider.kt

@@ -1,5 +1,6 @@
-package net.woggioni.gbcs.server.memcache
+package net.woggioni.gbcs.server.memcached
 
+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
@@ -10,21 +11,19 @@ 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"
 
-class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
+    override fun getXmlType() = "memcachedCacheType"
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd"
 
-    override fun getXmlType() = "memcacheCacheType"
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcached"
-
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcache"
 
     val xmlNamespacePrefix : String
-        get() = "gbcs-memcache"
+        get() = "gbcs-memcached"
 
-    override fun deserialize(el: Element): MemcacheCacheConfiguration {
+    override fun deserialize(el: Element): MemcachedCacheConfiguration {
-        val servers = mutableListOf<MemcacheCacheConfiguration.Server>()
+        val servers = mutableListOf<HostAndPort>()
         val maxAge = el.renderAttribute("max-age")
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
@@ -34,30 +33,24 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
         val compressionMode = el.renderAttribute("compression-mode")
             ?.let {
                 when (it) {
-                    "gzip" -> MemcacheCacheConfiguration.CompressionMode.GZIP
+                    "gzip" -> CompressionMode.GZIP
-                    "deflate" -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
+                    "zip" -> CompressionMode.ZIP
-                    else -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
+                    else -> CompressionMode.ZIP
                 }
             }
-            ?: MemcacheCacheConfiguration.CompressionMode.DEFLATE
+            ?: CompressionMode.ZIP
         val digestAlgorithm = el.renderAttribute("digest")
         for (child in el.asIterable()) {
             when (child.nodeName) {
                 "server" -> {
                     val host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
                     val port = child.renderAttribute("port")?.toInt() ?: throw ConfigurationException("port attribute is required")
-                    val maxConnections = child.renderAttribute("max-connections")?.toInt() ?: 1
+                    servers.add(HostAndPort(host, port))
-                    val connectionTimeout = child.renderAttribute("connection-timeout")
-                        ?.let(Duration::parse)
-                        ?.let(Duration::toMillis)
-                        ?.let(Long::toInt)
-                        ?: 10000
-                    servers.add(MemcacheCacheConfiguration.Server(HostAndPort(host, port), connectionTimeout, maxConnections))
                 }
             }
         }
 
-        return MemcacheCacheConfiguration(
+        return MemcachedCacheConfiguration(
             servers,
             maxAge,
             maxSize,
@@ -66,7 +59,7 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
         )
     }
 
-    override fun serialize(doc: Document, cache: MemcacheCacheConfiguration) = cache.run {
+    override fun serialize(doc: Document, cache: MemcachedCacheConfiguration) = cache.run {
         val result = doc.createElement("cache")
         Xml.of(doc, result) {
             attr("xmlns:${xmlNamespacePrefix}", xmlNamespace, namespaceURI = "http://www.w3.org/2000/xmlns/")
@@ -74,12 +67,8 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
             attr("xs:type", "${xmlNamespacePrefix}:$xmlType", GBCS.XML_SCHEMA_NAMESPACE_URI)
             for (server in servers) {
                 node("server") {
-                    attr("host", server.endpoint.host)
+                    attr("host", server.host)
-                    attr("port", server.endpoint.port.toString())
+                    attr("port", server.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())
@@ -87,15 +76,13 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)
             }
-            compressionMode?.let { compressionMode ->
             attr(
                 "compression-mode", when (compressionMode) {
-                        MemcacheCacheConfiguration.CompressionMode.GZIP -> "gzip"
+                    CompressionMode.GZIP -> "gzip"
-                        MemcacheCacheConfiguration.CompressionMode.DEFLATE -> "deflate"
+                    CompressionMode.ZIP -> "zip"
                 }
             )
         }
-        }
         result
     }
 }

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

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

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

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

gbcs-server/build.gradle

@@ -18,8 +18,11 @@ 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-memcache")
+    testRuntimeOnly project(":gbcs-server-memcached")
 }
 
 test {

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

@@ -208,15 +208,15 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                             .map { it as X509Certificate }
                             .toArray { size -> Array<X509Certificate?>(size) { null } }
                     SslContextBuilder.forServer(serverKey, *serverCert).apply {
-                        val clientAuth = tls.trustStore?.let { trustStore ->
+                        if (tls.isVerifyClients) {
+                            clientAuth(ClientAuth.OPTIONAL)
+                            tls.trustStore?.let { trustStore ->
                                 val ts = loadKeystore(trustStore.file, trustStore.password)
                                 trustManager(
                                     ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
                                 )
-                            if(trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
+                            }
-                            else ClientAuth.OPTIONAL
+                        }
-                        } ?: ClientAuth.NONE
-                        clientAuth(clientAuth)
                     }.build()
                 }
             }
@@ -309,33 +309,8 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
             val pipeline = ch.pipeline()
             cfg.connection.also { conn ->
-                val readTimeout = conn.readTimeout.toMillis()
+                pipeline.addLast(IdleStateHandler(false, conn.readTimeout.toMillis(), conn.writeTimeout.toMillis(), 0, TimeUnit.MILLISECONDS))
-                val writeTimeout = conn.writeTimeout.toMillis()
+                pipeline.addLast(IdleStateHandler(true, conn.readIdleTimeout.toMillis(), conn.writeIdleTimeout.toMillis(), conn.idleTimeout.toMillis(), TimeUnit.MILLISECONDS))
-                if(readTimeout > 0 || writeTimeout > 0) {
-                    pipeline.addLast(
-                        IdleStateHandler(
-                            false,
-                            readTimeout,
-                            writeTimeout,
-                            0,
-                            TimeUnit.MILLISECONDS
-                        )
-                    )
-                }
-                val readIdleTimeout = conn.readIdleTimeout.toMillis()
-                val writeIdleTimeout = conn.writeIdleTimeout.toMillis()
-                val idleTimeout = conn.idleTimeout.toMillis()
-                if(readIdleTimeout > 0 || writeIdleTimeout > 0 || idleTimeout > 0) {
-                    pipeline.addLast(
-                        IdleStateHandler(
-                            true,
-                            readIdleTimeout,
-                            writeIdleTimeout,
-                            idleTimeout,
-                            TimeUnit.MILLISECONDS
-                        )
-                    )
-                }
             }
             pipeline.addLast(object : ChannelInboundHandlerAdapter() {
                 override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
@@ -400,9 +375,9 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
     fun run(): ServerHandle {
         // Create the multithreaded event loops for the server
-        val bossGroup = NioEventLoopGroup(1)
+        val bossGroup = NioEventLoopGroup(0)
         val serverSocketChannel = NioServerSocketChannel::class.java
-        val workerGroup = NioEventLoopGroup(0)
+        val workerGroup = bossGroup
         val eventExecutorGroup = run {
             val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
                 Thread.ofVirtual().factory()

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

@@ -0,0 +1,21 @@
+package net.woggioni.gbcs.server.cache
+
+import net.woggioni.jwo.JWO
+import java.security.MessageDigest
+
+object CacheUtils {
+    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/FileSystemCache.kt

@@ -1,11 +1,8 @@
 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.gbcs.server.cache.CacheUtils.digestString
 import net.woggioni.jwo.LockFile
 import java.nio.channels.Channels
 import java.nio.channels.FileChannel
@@ -17,7 +14,6 @@ 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
@@ -32,10 +28,7 @@ class FileSystemCache(
     val compressionLevel: Int
 ) : Cache {
 
-    private companion object {
-        @JvmStatic
     private val log = contextLogger()
-    }
 
     init {
         Files.createDirectories(root)
@@ -69,12 +62,10 @@ class FileSystemCache(
                 }
             }.also {
                 gc()
-            }.let {
-                CompletableFuture.completedFuture(it)
             }
     }
 
-    override fun put(key: String, content: ByteBuf): CompletableFuture<Void> {
+    override fun put(key: String, content: ByteArray) {
         (digestAlgorithm
             ?.let(MessageDigest::getInstance)
             ?.let { md ->
@@ -91,7 +82,7 @@ class FileSystemCache(
                         it
                     }
                 }.use {
-                    JWO.copy(ByteBufInputStream(content), it)
+                    it.write(content)
                 }
                 Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
             } catch (t: Throwable) {
@@ -101,7 +92,6 @@ class FileSystemCache(
         }.also {
             gc()
         }
-        return CompletableFuture.completedFuture(null)
     }
 
     private fun gc() {

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

@@ -1,19 +1,18 @@
 package net.woggioni.gbcs.server.cache
 
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
 import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.common.ByteBufInputStream
+import net.woggioni.gbcs.server.cache.CacheUtils.digestString
-import net.woggioni.gbcs.common.GBCS.digestString
+import java.io.ByteArrayInputStream
-import net.woggioni.jwo.JWO
 import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
 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.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
 import java.util.zip.Deflater
 import java.util.zip.DeflaterOutputStream
 import java.util.zip.Inflater
@@ -26,27 +25,33 @@ class InMemoryCache(
     val compressionLevel: Int
 ) : Cache {
 
-    private val map = ConcurrentHashMap<String, ByteBuf>()
+    private val map = ConcurrentHashMap<String, MapValue>()
 
-    private class RemovalQueueElement(val key: String, val value : ByteBuf, val expiry : Instant) : Comparable<RemovalQueueElement> {
+    private class MapValue(val rc: AtomicInteger, val payload : AtomicReference<ByteArray>)
+
+    private class RemovalQueueElement(val key: String, 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 {
+    private val garbageCollector = Thread({
         while(true) {
             val el = removalQueue.take()
             val now = Instant.now()
             if(now > el.expiry) {
-                map.remove(el.key, el.value)
+                val value = map[el.key] ?: continue
+                val rc = value.rc.decrementAndGet()
+                if(rc == 0) {
+                    map.remove(el.key)
+                }
             } else {
                 removalQueue.put(el)
                 Thread.sleep(minOf(Duration.between(now, el.expiry), Duration.ofSeconds(1)))
             }
         }
-    }.apply {
+    }).apply {
         start()
     }
 
@@ -63,19 +68,19 @@ class InMemoryCache(
             } ?: key
                 ).let { digest ->
                 map[digest]
+                    ?.let(MapValue::payload)
+                    ?.let(AtomicReference<ByteArray>::get)
                     ?.let { value ->
                     if (compressionEnabled) {
                         val inflater = Inflater()
-                        Channels.newChannel(InflaterInputStream(ByteBufInputStream(value), inflater))
+                        Channels.newChannel(InflaterInputStream(ByteArrayInputStream(value), inflater))
                     } else {
-                        Channels.newChannel(ByteBufInputStream(value))
+                        Channels.newChannel(ByteArrayInputStream(value))
                     }
                 }
-            }.let {
-                CompletableFuture.completedFuture(it)
             }
 
-    override fun put(key: String, content: ByteBuf) =
+    override fun put(key: String, content: ByteArray) {
         (digestAlgorithm
             ?.let(MessageDigest::getInstance)
             ?.let { md ->
@@ -85,15 +90,17 @@ class InMemoryCache(
                 val deflater = Deflater(compressionLevel)
                 val baos = ByteArrayOutputStream()
                 DeflaterOutputStream(baos, deflater).use { stream ->
-                    JWO.copy(ByteBufInputStream(content), stream)
+                    stream.write(content)
                 }
-                Unpooled.wrappedBuffer(baos.toByteArray())
+                baos.toByteArray()
             } else {
                 content
             }
-            map[digest] = value
+            val mapValue = map.computeIfAbsent(digest) {
-            removalQueue.put(RemovalQueueElement(digest, value, Instant.now().plus(maxAge)))
+                MapValue(AtomicInteger(0), AtomicReference())
-        }.let {
+            }
-            CompletableFuture.completedFuture<Void>(null)
+            mapValue.payload.set(value)
+            removalQueue.put(RemovalQueueElement(digest, Instant.now().plus(maxAge)))
+        }
     }
 }

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

@@ -6,6 +6,7 @@ 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.nio.file.Path
 import java.time.Duration
 import java.util.zip.Deflater
 

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

@@ -114,9 +114,9 @@ object Parser {
 
                 "connection" -> {
                     val writeTimeout = child.renderAttribute("write-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
+                        ?.let(Duration::parse) ?: Duration.of(10, ChronoUnit.SECONDS)
                     val readTimeout = child.renderAttribute("read-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
+                        ?.let(Duration::parse) ?: Duration.of(10, ChronoUnit.SECONDS)
                     val idleTimeout = child.renderAttribute("idle-timeout")
                         ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS)
                     val readIdleTimeout = child.renderAttribute("read-idle-timeout")
@@ -142,9 +142,10 @@ object Parser {
                 }
 
                 "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" -> {
@@ -166,19 +167,15 @@ 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)
+                    tls = Tls(keyStore, trustStore, verifyClients)
                 }
             }
         }
@@ -265,8 +262,7 @@ 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 quota: Configuration.Quota? = null
-            var groupQuota: Configuration.Quota? = null
             for (child in el.asIterable()) {
                 when (child.localName) {
                     "users" -> {
@@ -280,15 +276,12 @@ object Parser {
                     "roles" -> {
                         roles = parseRoles(child)
                     }
-                    "group-quota" -> {
+                    "quota" -> {
-                        userQuota = parseQuota(child)
+                        quota = parseQuota(child)
-                    }
-                    "user-quota" -> {
-                        groupQuota = parseQuota(child)
                     }
                 }
             }
-            groupName to Group(groupName, roles, userQuota, groupQuota)
+            groupName to Group(groupName, roles, quota)
         }.toMap()
         val users = knownUsersMap.map { (name, user) ->
             name to User(name, user.password, userGroups[name]?.mapNotNull { groups[it] }?.toSet() ?: emptySet(), user.quota)

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

@@ -8,14 +8,8 @@ import org.w3c.dom.Document
 
 object Serializer {
 
-    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()
@@ -62,7 +56,10 @@ object Serializer {
                                 }
                                 user.quota?.let { quota ->
                                     node("quota") {
-                                        serializeQuota(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())
                                     }
                                 }
                             }
@@ -73,7 +70,10 @@ object Serializer {
                             anonymousUser.quota?.let { quota ->
                                 node("anonymous") {
                                     node("quota") {
-                                        serializeQuota(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())
                                     }
                                 }
                             }
@@ -113,14 +113,12 @@ object Serializer {
                                     }
                                 }
                             }
-                            group.userQuota?.let { quota ->
+                            group.quota?.let { quota ->
-                                node("user-quota") {
+                                node("quota") {
-                                    serializeQuota(quota)
+                                    attr("calls", quota.calls.toString())
-                                }
+                                    attr("period", quota.period.toString())
-                            }
+                                    attr("max-available-calls", quota.maxAvailableCalls.toString())
-                            group.groupQuota?.let { quota ->
+                                    attr("initial-available-calls", quota.initialAvailableCalls.toString())
-                                node("group-quota") {
-                                    serializeQuota(quota)
                                 }
                             }
                         }
@@ -156,6 +154,9 @@ object Serializer {
 
             conf.tls?.let { tlsConfiguration ->
                 node("tls") {
+                    if(tlsConfiguration.isVerifyClients) {
+                        attr("verify-clients", "true")
+                    }
                     tlsConfiguration.keyStore?.let { keyStore ->
                         node("keystore") {
                             attr("file", keyStore.file.toString())
@@ -176,7 +177,6 @@ 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/handler/ServerHandler.kt

@@ -17,6 +17,7 @@ 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.api.exception.CacheException
 import net.woggioni.gbcs.common.contextLogger
 import net.woggioni.gbcs.server.debug
 import net.woggioni.gbcs.server.warn
@@ -42,8 +43,11 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                 return
             }
             if (serverPrefix == prefix) {
-                cache.get(key).thenApply { channel ->
+                try {
-                    if(channel != null) {
+                    cache.get(key)
+                } catch(ex : Throwable) {
+                    throw CacheException("Error accessing the cache backend", ex)
+                }?.let { channel ->
                     log.debug(ctx) {
                         "Cache hit for key '$key'"
                     }
@@ -57,18 +61,24 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                         response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
                     }
                     ctx.write(response)
-                        val content : Any = when (channel) {
+                    when (channel) {
-                            is FileChannel -> DefaultFileRegion(channel, 0, channel.size())
+                        is FileChannel -> {
-                            else -> ChunkedNioStream(channel)
-                        }
                             if (keepAlive) {
-                            ctx.write(content)
+                                ctx.write(DefaultFileRegion(channel, 0, channel.size()))
                                 ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
                             } else {
-                            ctx.writeAndFlush(content)
+                                ctx.writeAndFlush(DefaultFileRegion(channel, 0, channel.size()))
                                     .addListener(ChannelFutureListener.CLOSE)
                             }
-                    } else {
+                        }
+                        else -> {
+                            ctx.write(ChunkedNioStream(channel)).addListener { evt ->
+                                channel.close()
+                            }
+                            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
+                        }
+                    }
+                } ?: let {
                     log.debug(ctx) {
                         "Cache miss for key '$key'"
                     }
@@ -76,7 +86,6 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                     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()}'"
@@ -94,16 +103,26 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                 log.debug(ctx) {
                     "Added value for key '$key' to build cache"
                 }
-                cache.put(key, msg.content().retain()).thenRun {
+                val bodyBytes = msg.content().run {
+                    if (isDirect) {
+                        ByteArray(readableBytes()).also {
+                            readBytes(it)
+                        }
+                    } else {
+                        array()
+                    }
+                }
+                try {
+                    cache.put(key, bodyBytes)
+                } catch(ex : Throwable) {
+                    throw CacheException("Error accessing the cache backend", ex)
+                }
                 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()}'"

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

@@ -8,7 +8,7 @@ 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 bucketsByUser: Map<Configuration.User, Bucket> = HashMap(),
     private val bucketsByGroup: Map<Configuration.Group, Bucket> = HashMap(),
     loader: Function<InetSocketAddress, Bucket>?
 ) {
@@ -43,27 +43,22 @@ class BucketManager private constructor(
 
     companion object {
         fun from(cfg : Configuration) : BucketManager {
-            val bucketsByUser = cfg.users.values.asSequence().map { user ->
+            val bucketsByUser = cfg.users.values.asSequence().filter {
-                val buckets = (
+                it.quota != null
-                        user.quota
+            }.map { user ->
-                            ?.let { quota ->
+                val quota = user.quota
-                                sequenceOf(quota)
+                val bucket = Bucket.local(
-                            } ?: user.groups.asSequence()
-                                .mapNotNull(Configuration.Group::getUserQuota)
-                ).map { quota ->
-                    Bucket.local(
                     quota.maxAvailableCalls,
                     quota.calls,
                     quota.period,
                     quota.initialAvailableCalls
                 )
-                }.toList()
+                user to bucket
-                user to buckets
             }.toMap()
             val bucketsByGroup = cfg.groups.values.asSequence().filter {
-                it.groupQuota != null
+                it.quota != null
             }.map { group ->
-                val quota = group.groupQuota
+                val quota = group.quota
                 val bucket = Bucket.local(
                     quota.maxAvailableCalls,
                     quota.calls,

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

@@ -42,7 +42,7 @@ class ThrottlingHandler(cfg: Configuration) :
         val buckets = mutableListOf<Bucket>()
         val user = ctx.channel().attr(GradleBuildCacheServer.userAttribute).get()
         if (user != null) {
-            bucketManager.getBucketByUser(user)?.let(buckets::addAll)
+            bucketManager.getBucketByUser(user)?.let(buckets::add)
         }
         val groups = ctx.channel().attr(GradleBuildCacheServer.groupAttribute).get() ?: emptySet()
         if (groups.isNotEmpty()) {

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

@@ -34,8 +34,8 @@
     </xs:complexType>
 
     <xs:complexType name="connectionType">
-        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT10S"/>
-        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT10S"/>
         <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"/>
@@ -146,8 +146,7 @@
                 </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="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>
@@ -184,6 +183,7 @@
             <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" default="false"/>
     </xs:complexType>
 
     <xs:complexType name="keyStoreType">
@@ -197,7 +197,6 @@
         <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

@@ -24,8 +24,8 @@ 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), null, null)
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, null)
+    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null)
 
     abstract protected val users : List<Configuration.User>
 

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.api.Configuration
 import net.woggioni.gbcs.server.GradleBuildCacheServer
+import net.woggioni.gbcs.api.Configuration
 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

@@ -4,6 +4,7 @@ import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.api.Role
 import net.woggioni.gbcs.common.Xml
 import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
+import net.woggioni.gbcs.server.cache.InMemoryCacheConfiguration
 import net.woggioni.gbcs.server.configuration.Serializer
 import net.woggioni.gbcs.server.test.utils.CertificateUtils
 import net.woggioni.gbcs.server.test.utils.CertificateUtils.X509Credentials
@@ -45,8 +46,8 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
     private lateinit var trustStore: KeyStore
     protected lateinit var ca: X509Credentials
 
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, null)
+    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null)
     protected val random = Random(101325)
     protected val keyValuePair = newEntry(random)
     private val serverPath : String? = null
@@ -170,8 +171,9 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
             ),
             Configuration.Tls(
                 Configuration.KeyStore(this.serverKeyStoreFile, null, SERVER_CERTIFICATE_ENTRY, PASSWORD),
-                Configuration.TrustStore(this.trustStoreFile, null, false, false),
+                Configuration.TrustStore(this.trustStoreFile, null, false),
-            )
+                true
+            ),
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }

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

@@ -20,7 +20,6 @@ class ConfigurationTest {
             "classpath:net/woggioni/gbcs/server/test/valid/gbcs-default.xml",
             "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached.xml",
             "classpath:net/woggioni/gbcs/server/test/valid/gbcs-tls.xml",
-            "classpath:net/woggioni/gbcs/server/test/valid/gbcs-memcached-tls.xml",
         ]
     )
     @ParameterizedTest

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

@@ -3,6 +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

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

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

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

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

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

@@ -32,8 +32,7 @@
                 <roles>
                     <reader/>
                 </roles>
-                <user-quota calls="30" period="PT1M"/>
+                <quota calls="10" period="PT1S"/>
-                <group-quota calls="10" period="PT1S"/>
             </group>
             <group name="writers">
                 <users>
@@ -51,7 +50,7 @@
                     <reader/>
                     <writer/>
                 </roles>
-                <group-quota calls="1000" period="P1D"/>
+                <quota calls="1000" period="P1D"/>
             </group>
         </groups>
     </authorization>
@@ -61,8 +60,8 @@
             <user-extractor pattern="user-pattern" attribute-name="CN"/>
         </client-certificate>
     </authentication>
-    <tls>
+    <tls verify-clients="true">
         <keystore file="keystore.pfx" key-alias="key1" password="password" key-password="key-password"/>
-        <truststore file="truststore.pfx" password="password" check-certificate-status="true" require-client-certificate="true"/>
+        <truststore file="truststore.pfx" password="password" check-certificate-status="true" />
     </tls>
 </gbcs:server>

gradle.properties

@@ -2,9 +2,9 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true
 
-gbcs.version = 0.1.2
+gbcs.version = 0.0.11
 
-lys.version = 2025.01.31
+lys.version = 2025.01.24
 
 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
 docker.registry.url=gitea.woggioni.net

settings.gradle

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