implemented memcached client with Netty

.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 memcached Docker image
+        name: Build gbcs memcache 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:memcached
+            gitea.woggioni.net/woggioni/gbcs:memcache
-            gitea.woggioni.net/woggioni/gbcs:memcached-${{ steps.retrieve-version.outputs.VERSION }}
+            gitea.woggioni.net/woggioni/gbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-memcached
+          target: release-memcache
           cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
           cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       - name: Publish artifacts

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

docker/build.gradle

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

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

@@ -4,5 +4,4 @@ module net.woggioni.gbcs.api {
     requires io.netty.buffer;
     exports net.woggioni.gbcs.api;
     exports net.woggioni.gbcs.api.exception;
-    exports net.woggioni.gbcs.api.event;
 }

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

@@ -1,5 +1,6 @@
 package net.woggioni.gbcs.api;
 
+import io.netty.buffer.ByteBuf;
 import net.woggioni.gbcs.api.exception.ContentTooLargeException;
 
 import java.nio.channels.ReadableByteChannel;
@@ -7,6 +8,7 @@ import java.util.concurrent.CompletableFuture;
 
 
 public interface Cache extends AutoCloseable {
-    CompletableFuture<CallHandle<Void>> get(String key, ResponseEventListener responseEventListener);
+    CompletableFuture<ReadableByteChannel> get(String key);
-    CompletableFuture<CallHandle<Void>> put(String key) throws ContentTooLargeException;
+
+    CompletableFuture<Void> put(String key, ByteBuf content) throws ContentTooLargeException;
 }

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

@@ -1,10 +0,0 @@
-package net.woggioni.gbcs.api;
-
-import net.woggioni.gbcs.api.event.RequestEvent;
-
-import java.util.concurrent.CompletableFuture;
-
-public interface CallHandle<T> {
-    void postEvent(RequestEvent evt);
-    CompletableFuture<T> call();
-}

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

@@ -56,7 +56,8 @@ public class Configuration {
         @EqualsAndHashCode.Include
         String name;
         Set<Role> roles;
-        Quota quota;
+        Quota groupQuota;
+        Quota userQuota;
     }
 
     @Value

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

@@ -1,7 +0,0 @@
-package net.woggioni.gbcs.api;
-
-import net.woggioni.gbcs.api.event.ResponseEvent;
-
-public interface ResponseEventListener {
-    void listen(ResponseEvent evt);
-}

gbcs-api/src/main/java/net/woggioni/gbcs/api/event/RequestEvent.java

@@ -1,20 +0,0 @@
-package net.woggioni.gbcs.api.event;
-
-import io.netty.buffer.ByteBuf;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import net.woggioni.gbcs.api.CallHandle;
-
-sealed public abstract class RequestEvent {
-    @Getter
-    @RequiredArgsConstructor
-    public static final class ChunkSent extends RequestEvent {
-        private final ByteBuf chunk;
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    public static final class LastChunkSent extends RequestEvent {
-        private final ByteBuf chunk;
-    }
-}

gbcs-api/src/main/java/net/woggioni/gbcs/api/event/ResponseEvent.java

@@ -1,28 +0,0 @@
-package net.woggioni.gbcs.api.event;
-
-import io.netty.buffer.ByteBuf;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-
-sealed public abstract class ResponseEvent {
-    @Getter
-    @RequiredArgsConstructor
-    public final static class ChunkReceived extends ResponseEvent {
-        private final ByteBuf chunk;
-    }
-
-    public final static class NoContent extends ResponseEvent {
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    public final static class LastChunkReceived extends ResponseEvent {
-        private final ByteBuf chunk;
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    public final static class ExceptionCaught extends ResponseEvent {
-        private final Throwable cause;
-    }
-}

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

@@ -1,7 +1,5 @@
 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
@@ -10,10 +8,11 @@ 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

@@ -33,6 +33,13 @@ 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 ->
@@ -46,7 +53,7 @@ class BenchmarkCommand : GbcsCommand() {
             while (true) {
                 val key = JWO.bytesToHex(random.nextBytes(16))
                 val content = random.nextInt().toByte()
-                val value = ByteArray(0x1000, { _ -> content })
+                val value = ByteArray(size, { _ -> content })
                 yield(key to value)
             }
         }

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.cli.impl.GbcsCommand
+import net.woggioni.gbcs.server.GradleBuildCacheServer
+import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
 import net.woggioni.jwo.Application
 import net.woggioni.jwo.JWO
 import picocli.CommandLine

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

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

@@ -4,7 +4,6 @@ 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.Test
 import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments

gbcs-common/build.gradle

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

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

@@ -4,6 +4,7 @@ module net.woggioni.gbcs.common {
     requires org.slf4j;
     requires kotlin.stdlib;
     requires net.woggioni.jwo;
+    requires io.netty.buffer;
 
     provides java.net.spi.URLStreamHandlerProvider with net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory;
     exports net.woggioni.gbcs.common;

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

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

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

@@ -5,7 +5,6 @@ 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/build.gradle

@@ -6,10 +6,10 @@ plugins {
 
 configurations {
     bundle {
-        extendsFrom runtimeClasspath
         canBeResolved = true
         canBeConsumed = false
         visible = false
+        transitive = false
 
         resolutionStrategy {
             dependencies {
@@ -26,24 +26,23 @@ configurations {
         canBeResolved = true
         visible = true
     }
-
-    testImplementation {
-        extendsFrom compileOnly
-    }
 }
 
 dependencies {
-    compileOnly project(':gbcs-common')
+    implementation project(':gbcs-common')
-    compileOnly project(':gbcs-api')
+    implementation project(':gbcs-api')
-    compileOnly catalog.jwo
+    implementation catalog.jwo
-    compileOnly catalog.slf4j.api
+    implementation catalog.slf4j.api
-    implementation catalog.xmemcached
-    implementation catalog.netty.codec.memcache
     implementation catalog.netty.common
-    implementation group: 'io.netty', name: 'netty-handler', version: catalog.versions.netty.get()
+    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) {
@@ -52,11 +51,6 @@ Provider<Tar> bundleTask = tasks.register("bundle", Tar) {
     group = BasePlugin.BUILD_GROUP
 }
 
-tasks.named(JavaPlugin.TEST_TASK_NAME, Test) {
-    systemProperty("io.netty.leakDetectionLevel", "PARANOID")
-}
-
-
 tasks.named(BasePlugin.ASSEMBLE_TASK_NAME) {
     dependsOn(bundleTask)
 }

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

@@ -1,21 +1,19 @@
 import net.woggioni.gbcs.api.CacheProvider;
 
-module net.woggioni.gbcs.server.memcached {
+module net.woggioni.gbcs.server.memcache {
     requires net.woggioni.gbcs.common;
     requires net.woggioni.gbcs.api;
-    requires com.googlecode.xmemcached;
     requires net.woggioni.jwo;
     requires java.xml;
     requires kotlin.stdlib;
-    requires io.netty.common;
-    requires io.netty.handler;
-    requires io.netty.codec.memcache;
     requires io.netty.transport;
-    requires org.slf4j;
-    requires io.netty.buffer;
     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.memcached.MemcachedCacheProvider;
+    provides CacheProvider with net.woggioni.gbcs.server.memcache.MemcacheCacheProvider;
 
-    opens net.woggioni.gbcs.server.memcached.schema;
+    opens net.woggioni.gbcs.server.memcache.schema;
 }

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

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

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

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

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

@@ -1,15 +1,15 @@
-package net.woggioni.gbcs.server.memcached
+package net.woggioni.gbcs.server.memcache
 
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.common.HostAndPort
 import java.time.Duration
 
-data class MemcachedCacheConfiguration(
+data class MemcacheCacheConfiguration(
     val servers: List<Server>,
     val maxAge: Duration = Duration.ofDays(1),
     val maxSize: Int = 0x100000,
     val digestAlgorithm: String? = null,
-    val compressionMode: CompressionMode? = CompressionMode.DEFLATE,
+    val compressionMode: CompressionMode? = null,
 ) : Configuration.Cache {
 
     enum class CompressionMode {
@@ -24,23 +24,17 @@ data class MemcachedCacheConfiguration(
         DEFLATE
     }
 
-    class RetryPolicy(
-        val maxAttempts: Int,
-        val initialDelayMillis: Long,
-        val exp: Double
-    )
-
     data class Server(
         val endpoint : HostAndPort,
         val connectionTimeoutMillis : Int?,
-        val retryPolicy : RetryPolicy?,
         val maxConnections : Int
     )
 
 
-    override fun materialize() = MemcachedCache(this)
+    override fun materialize() = MemcacheCache(this)
 
-    override fun getNamespaceURI() = "urn:net.woggioni.gbcs.server.memcached"
+    override fun getNamespaceURI() = "urn:net.woggioni.gbcs.server.memcache"
 
-    override fun getTypeName() = "memcachedCacheType"
+    override fun getTypeName() = "memcacheCacheType"
 }
+

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

@@ -1,6 +1,5 @@
-package net.woggioni.gbcs.server.memcached
+package net.woggioni.gbcs.server.memcache
 
-import net.rubyeye.xmemcached.transcoders.CompressionMode
 import net.woggioni.gbcs.api.CacheProvider
 import net.woggioni.gbcs.api.exception.ConfigurationException
 import net.woggioni.gbcs.common.GBCS
@@ -11,19 +10,21 @@ import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 import java.time.Duration
+import java.time.temporal.ChronoUnit
 
-class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcached/net/woggioni/gbcs/server/memcached/schema/gbcs-memcached.xsd"
 
-    override fun getXmlType() = "memcachedCacheType"
+class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
+    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd"
 
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcached"
+    override fun getXmlType() = "memcacheCacheType"
+
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcache"
 
     val xmlNamespacePrefix : String
-        get() = "gbcs-memcached"
+        get() = "gbcs-memcache"
 
-    override fun deserialize(el: Element): MemcachedCacheConfiguration {
+    override fun deserialize(el: Element): MemcacheCacheConfiguration {
-        val servers = mutableListOf<HostAndPort>()
+        val servers = mutableListOf<MemcacheCacheConfiguration.Server>()
         val maxAge = el.renderAttribute("max-age")
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
@@ -33,25 +34,31 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
         val compressionMode = el.renderAttribute("compression-mode")
             ?.let {
                 when (it) {
-                    "gzip" -> CompressionMode.GZIP
+                    "gzip" -> MemcacheCacheConfiguration.CompressionMode.GZIP
-                    "zip" -> CompressionMode.ZIP
+                    "deflate" -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
-                    else -> CompressionMode.ZIP
+                    else -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
                 }
             }
-            ?: CompressionMode.ZIP
+            ?: MemcacheCacheConfiguration.CompressionMode.DEFLATE
         val digestAlgorithm = el.renderAttribute("digest")
         for (child in el.asIterable()) {
             when (child.nodeName) {
                 "server" -> {
                     val host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
                     val port = child.renderAttribute("port")?.toInt() ?: throw ConfigurationException("port attribute is required")
-                    servers.add(HostAndPort(host, port))
+                    val maxConnections = child.renderAttribute("max-connections")?.toInt() ?: 1
+                    val connectionTimeout = child.renderAttribute("connection-timeout")
+                        ?.let(Duration::parse)
+                        ?.let(Duration::toMillis)
+                        ?.let(Long::toInt)
+                        ?: 10000
+                    servers.add(MemcacheCacheConfiguration.Server(HostAndPort(host, port), connectionTimeout, maxConnections))
                 }
             }
         }
 
-        return MemcachedCacheConfiguration(
+        return MemcacheCacheConfiguration(
-            servers.map { MemcachedCacheConfiguration.Server(it, null, null, 1) },
+            servers,
             maxAge,
             maxSize,
             digestAlgorithm,
@@ -59,7 +66,7 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
         )
     }
 
-    override fun serialize(doc: Document, cache: MemcachedCacheConfiguration) = cache.run {
+    override fun serialize(doc: Document, cache: MemcacheCacheConfiguration) = cache.run {
         val result = doc.createElement("cache")
         Xml.of(doc, result) {
             attr("xmlns:${xmlNamespacePrefix}", xmlNamespace, namespaceURI = "http://www.w3.org/2000/xmlns/")
@@ -69,6 +76,10 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
                 node("server") {
                     attr("host", server.endpoint.host)
                     attr("port", server.endpoint.port.toString())
+                    server.connectionTimeoutMillis?.let { connectionTimeoutMillis ->
+                        attr("connection-timeout", Duration.of(connectionTimeoutMillis.toLong(), ChronoUnit.MILLIS).toString())
+                    }
+                    attr("max-connections", server.maxConnections.toString())
                 }
             }
             attr("max-age", maxAge.toString())
@@ -76,13 +87,15 @@ class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)
             }
+            compressionMode?.let { compressionMode ->
                 attr(
                     "compression-mode", when (compressionMode) {
-                    CompressionMode.GZIP -> "gzip"
+                        MemcacheCacheConfiguration.CompressionMode.GZIP -> "gzip"
-                    CompressionMode.ZIP -> "zip"
+                        MemcacheCacheConfiguration.CompressionMode.DEFLATE -> "deflate"
                     }
                 )
             }
+        }
         result
     }
 }

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

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

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

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

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

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

@@ -1,33 +0,0 @@
-package net.woggioni.gbcs.server.memcached
-
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.ByteBufAllocator
-import io.netty.channel.ChannelHandlerContext
-import io.netty.handler.stream.ChunkedInput
-import java.nio.channels.ReadableByteChannel
-
-class CustomChunkedInput(private val readableByteChannel: ReadableByteChannel) : ChunkedInput<ByteBuf> {
-    override fun isEndOfInput(): Boolean {
-        TODO("Not yet implemented")
-    }
-
-    override fun close() {
-        TODO("Not yet implemented")
-    }
-
-    override fun readChunk(ctx: ChannelHandlerContext): ByteBuf {
-        TODO("Not yet implemented")
-    }
-
-    override fun readChunk(allocator: ByteBufAllocator): ByteBuf {
-        TODO("Not yet implemented")
-    }
-
-    override fun length(): Long {
-        TODO("Not yet implemented")
-    }
-
-    override fun progress(): Long {
-        TODO("Not yet implemented")
-    }
-}

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

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

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

@@ -1,85 +0,0 @@
-package net.woggioni.gbcs.server.memcached
-
-import io.netty.buffer.Unpooled
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.api.CallHandle
-import net.woggioni.gbcs.api.ResponseEventListener
-import net.woggioni.gbcs.api.event.RequestEvent
-import net.woggioni.gbcs.api.event.ResponseEvent
-import net.woggioni.gbcs.server.memcached.client.MemcachedClient
-import net.woggioni.gbcs.server.memcached.client.ResponseEvent.ExceptionCaught
-import net.woggioni.gbcs.server.memcached.client.ResponseEvent.LastResponseContentChunkReceived
-import net.woggioni.gbcs.server.memcached.client.ResponseEvent.ResponseContentChunkReceived
-import net.woggioni.gbcs.server.memcached.client.ResponseEvent.ResponseReceived
-import net.woggioni.gbcs.server.memcached.client.ResponseListener
-import java.util.concurrent.CompletableFuture
-
-class MemcachedCache(
-    private val cfg : MemcachedCacheConfiguration
-) : Cache {
-    private val client = MemcachedClient(cfg)
-
-    override fun close() {
-        client.close()
-    }
-
-    override fun get(key: String, responseEventListener: ResponseEventListener): CompletableFuture<CallHandle<Void>> {
-        val listener = ResponseListener { evt ->
-            when(evt) {
-                is ResponseContentChunkReceived -> {
-                    responseEventListener.listen(ResponseEvent.ChunkReceived(Unpooled.wrappedBuffer(evt.chunk)))
-                }
-                is LastResponseContentChunkReceived -> {
-                    responseEventListener.listen(ResponseEvent.LastChunkReceived(Unpooled.wrappedBuffer(evt.chunk)))
-                }
-                is ExceptionCaught -> {
-                    responseEventListener.listen(ResponseEvent.ExceptionCaught(evt.cause))
-                }
-                is ResponseReceived -> {
-                    when(val status = evt.response.status) {
-                        BinaryMemcacheResponseStatus.SUCCESS -> {
-                        }
-                        BinaryMemcacheResponseStatus.KEY_ENOENT -> {
-                            responseEventListener.listen(ResponseEvent.NoContent())
-                        }
-                        else -> {
-                            responseEventListener.listen(ResponseEvent.ExceptionCaught(MemcachedException(status)))
-                        }
-                    }
-                }
-            }
-        }
-        return client.get(key, listener).thenApply { clientCallHandle ->
-            object : CallHandle<Void> {
-                override fun postEvent(evt: RequestEvent) {
-                    when(evt) {
-                        is RequestEvent.ChunkSent -> clientCallHandle.sendChunk(evt.chunk.nioBuffer())
-                        is RequestEvent.LastChunkSent -> clientCallHandle.sendChunk(evt.chunk.nioBuffer())
-                    }
-                }
-
-                override fun call(): CompletableFuture<Void> {
-                    return clientCallHandle.waitForResponse().thenApply { null }
-                }
-            }
-        }
-    }
-
-    override fun put(key: String): CompletableFuture<CallHandle<Void>> {
-        return client.put(key, cfg.maxAge).thenApply { clientCallHandle ->
-            object : CallHandle<Void> {
-                override fun postEvent(evt: RequestEvent) {
-                    when(evt) {
-                        is RequestEvent.ChunkSent -> clientCallHandle.sendChunk(evt.chunk.nioBuffer())
-                        is RequestEvent.LastChunkSent -> clientCallHandle.sendChunk(evt.chunk.nioBuffer())
-                    }
-                }
-
-                override fun call(): CompletableFuture<Void> {
-                    return clientCallHandle.waitForResponse().thenApply { null }
-                }
-            }
-        }
-    }
-}

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

@@ -1,9 +0,0 @@
-package net.woggioni.gbcs.server.memcached.client
-
-import java.nio.ByteBuffer
-import java.util.concurrent.CompletableFuture
-
-interface CallHandle {
-    fun sendChunk(requestBodyChunk : ByteBuffer)
-    fun waitForResponse() : CompletableFuture<Short>
-}

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

@@ -1,24 +0,0 @@
-package net.woggioni.gbcs.server.memcached.client
-
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
-import java.nio.ByteBuffer
-
-data class MemcacheResponse(
-    val status: Short,
-    val opcode: Byte,
-    val cas: Long?,
-    val opaque: Int?,
-    val key: ByteBuffer?,
-    val extra: ByteBuffer?
-) {
-    companion object {
-        fun of(response : BinaryMemcacheResponse) = MemcacheResponse(
-            response.status(),
-            response.opcode(),
-            response.cas(),
-            response.opaque(),
-            response.key()?.nioBuffer(),
-            response.extras()?.nioBuffer()
-        )
-    }
-}

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

@@ -1,241 +0,0 @@
-package net.woggioni.gbcs.server.memcached.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.DefaultLastMemcacheContent
-import io.netty.handler.codec.memcache.DefaultMemcacheContent
-import io.netty.handler.codec.memcache.LastMemcacheContent
-import io.netty.handler.codec.memcache.MemcacheContent
-import io.netty.handler.codec.memcache.MemcacheObject
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheClientCodec
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
-import io.netty.handler.codec.memcache.binary.DefaultBinaryMemcacheRequest
-import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.gbcs.common.GBCS.digest
-import net.woggioni.gbcs.common.HostAndPort
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.server.memcached.MemcachedCacheConfiguration
-import net.woggioni.gbcs.server.memcached.MemcachedException
-import java.net.InetSocketAddress
-import java.nio.ByteBuffer
-import java.security.MessageDigest
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.ConcurrentHashMap
-import io.netty.util.concurrent.Future as NettyFuture
-
-
-class MemcachedClient(private val cfg: MemcachedCacheConfiguration) : AutoCloseable {
-
-    private val log = contextLogger()
-    private val group: NioEventLoopGroup
-    private val connectionPool: MutableMap<HostAndPort, ChannelPool> = ConcurrentHashMap()
-
-    init {
-        group = NioEventLoopGroup()
-    }
-
-    private fun newConnectionPool(server : MemcachedCacheConfiguration.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())
-            }
-        }
-        return FixedChannelPool(bootstrap, channelPoolHandler, server.maxConnections)
-    }
-
-
-    private fun sendRequest(request: BinaryMemcacheRequest,
-                            responseListener: ResponseListener?
-    ): CompletableFuture<CallHandle> {
-
-        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 callHandleFuture = CompletableFuture<CallHandle>()
-        val result = CompletableFuture<Short>()
-        // 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<MemcacheObject>() {
-                        val response : MemcacheResponse? = null
-                        override fun channelRead0(
-                            ctx: ChannelHandlerContext,
-                            msg: MemcacheObject
-                        ) {
-                            if(msg is BinaryMemcacheResponse) {
-                                val resp = MemcacheResponse.of(msg)
-                                responseListener?.listen(ResponseEvent.ResponseReceived(resp))
-                                if(msg.totalBodyLength() == msg.keyLength() + msg.extrasLength()) {
-                                    result.complete(resp.status)
-                                }
-                            }
-                            if(responseListener != null) {
-                                when (msg) {
-                                    is LastMemcacheContent -> {
-                                        responseListener.listen(ResponseEvent.LastResponseContentChunkReceived(msg.content().nioBuffer()))
-                                        result.complete(response?.status)
-                                        pipeline.removeLast()
-                                        pool.release(channel)
-                                    }
-                                    is MemcacheContent ->  {
-                                        responseListener.listen(ResponseEvent.ResponseContentChunkReceived(msg.content().nioBuffer()))
-                                    }
-                                }
-                            }
-                        }
-
-                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                            val ex = when (cause) {
-                                is DecoderException -> cause.cause!!
-                                else -> cause
-                            }
-                            responseListener?.listen(ResponseEvent.ExceptionCaught(ex))
-                            result.completeExceptionally(ex)
-                            ctx.close()
-                            pipeline.removeLast()
-                            pool.release(channel)
-                        }
-                    })
-
-                    val chunks = mutableListOf <ByteBuffer>()
-                    fun sendRequest() {
-                        val valueLen = chunks.fold(0) { acc : Int, c2 : ByteBuffer ->
-                            acc + c2.remaining()
-                        }
-                        request.setTotalBodyLength(request.keyLength() + request.extrasLength() + valueLen)
-                        channel.write(request)
-                        for((i, chunk) in chunks.withIndex()) {
-                            if(i + 1 < chunks.size) {
-                                channel.write(DefaultMemcacheContent(Unpooled.wrappedBuffer(chunk)))
-                            } else {
-                                channel.write(DefaultLastMemcacheContent(Unpooled.wrappedBuffer(chunk)))
-                            }
-                        }
-                        channel.flush()
-                    }
-
-                    callHandleFuture.complete(object : CallHandle {
-                        override fun sendChunk(requestBodyChunk: ByteBuffer) {
-                                chunks.addLast(requestBodyChunk)
-                        }
-
-                        override fun waitForResponse(): CompletableFuture<Short> {
-                            sendRequest()
-                            return result
-                        }
-                    })
-                } else {
-                    callHandleFuture.completeExceptionally(channelFuture.cause())
-                }
-            }
-        })
-        return callHandleFuture
-    }
-
-    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, responseListener: ResponseListener) : CompletableFuture<CallHandle> {
-        val request = (cfg.digestAlgorithm
-            ?.let(MessageDigest::getInstance)
-            ?.let { md ->
-                digest(key.toByteArray(), md)
-            } ?: key.toByteArray(Charsets.UTF_8)).let { digest ->
-            DefaultBinaryMemcacheRequest().apply {
-                setKey(Unpooled.wrappedBuffer(digest))
-                setOpcode(BinaryMemcacheOpcodes.GET)
-            }
-        }
-        return sendRequest(request, responseListener)
-    }
-
-    fun put(key: String, expiry : Duration, cas : Long? = null): CompletableFuture<CallHandle> {
-        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))
-            DefaultBinaryMemcacheRequest().apply {
-                setExtras(extras)
-                setKey(Unpooled.wrappedBuffer(digest))
-                setOpcode(BinaryMemcacheOpcodes.SET)
-                cas?.let(this::setCas)
-            }
-        }
-        return sendRequest(request) { evt ->
-            when (evt) {
-                is ResponseEvent.ResponseReceived -> {
-                    if (evt.response.status != BinaryMemcacheResponseStatus.SUCCESS) {
-                        throw MemcachedException(evt.response.status)
-                    }
-                }
-                else -> {}
-            }
-        }
-    }
-
-
-
-    fun shutDown(): NettyFuture<*> {
-        return group.shutdownGracefully()
-    }
-
-    override fun close() {
-        shutDown().sync()
-    }
-}

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

@@ -1,10 +0,0 @@
-package net.woggioni.gbcs.server.memcached.client
-
-import java.nio.ByteBuffer
-
-sealed interface ResponseEvent {
-    class ResponseReceived(val response : MemcacheResponse) : ResponseEvent
-    class ResponseContentChunkReceived(val chunk: ByteBuffer) : ResponseEvent
-    class LastResponseContentChunkReceived(val chunk: ByteBuffer) : ResponseEvent
-    class ExceptionCaught(val cause : Throwable) : ResponseEvent
-}

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

@@ -1,5 +0,0 @@
-package net.woggioni.gbcs.server.memcached.client
-
-fun interface ResponseListener {
-    fun listen(evt : ResponseEvent)
-}

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

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

gbcs-server-memcached/src/test/kotlin/net/woggioni/gbcs/server/memcached/test/MemcachedClientTest.kt

@@ -1,80 +0,0 @@
-package net.woggioni.gbcs.server.memcached.test
-
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
-import net.woggioni.gbcs.api.event.ChunkReceived
-import net.woggioni.gbcs.common.HostAndPort
-
-import net.woggioni.gbcs.server.memcached.MemcachedCacheConfiguration
-import net.woggioni.gbcs.server.memcached.client.MemcacheResponse
-import net.woggioni.gbcs.server.memcached.client.MemcachedClient
-import net.woggioni.gbcs.server.memcached.client.ResponseEvent
-import net.woggioni.gbcs.server.memcached.client.ResponseListener
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Test
-import java.nio.ByteBuffer
-import java.security.SecureRandom
-import java.time.Duration
-import java.util.Objects
-import java.util.concurrent.TimeUnit
-import kotlin.random.Random
-
-class MemcachedClientTest {
-
-    @Test
-    fun test() {
-        val client = MemcachedClient(MemcachedCacheConfiguration(
-            servers = listOf(
-                MemcachedCacheConfiguration.Server(
-                    endpoint = HostAndPort("127.0.0.1", 11211),
-                    connectionTimeoutMillis = null,
-                    retryPolicy = null,
-                    maxConnections = 1
-                )
-            )
-        ))
-
-        val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
-        val key = "101325"
-        val value = random.nextBytes(0x1000)
-        val requestListener = client.put(key, Duration.ofDays(2), null)
-
-        val response = Unpooled.buffer(value.size)
-        requestListener.thenCompose { listener ->
-            listener.sendChunk(ByteBuffer.wrap(value))
-            listener.waitForResponse()
-        }.get(10, TimeUnit.SECONDS)
-
-        client.get(key, object: ResponseListener {
-            override fun listen(evt: ResponseEvent) {
-                when(evt) {
-                    is ResponseEvent.ResponseReceived -> {
-                        if(evt.response.status != BinaryMemcacheResponseStatus.SUCCESS) {
-                            Assertions.fail<String> {
-                                "Memcache status ${evt.response.status}"
-                            }
-                        }
-                    }
-                    is ResponseEvent.ResponseContentChunkReceived -> response.writeBytes(evt.chunk)
-                    else -> {}
-                }
-            }
-        }).thenCompose { it.waitForResponse() }.get(1, TimeUnit.SECONDS)
-        val retrievedResponse = response.array()
-        Assertions.assertArrayEquals(value, retrievedResponse)
-
-    }
-
-    @Test
-    fun test2() {
-        val a1 = ByteArray(10) {
-            it.toByte()
-        }
-        val a2 = ByteArray(10) {
-            it.toByte()
-        }
-        Assertions.assertTrue(Objects.equals(a1, a1))
-    }
-}

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

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

gbcs-server/build.gradle

@@ -19,7 +19,7 @@ dependencies {
     testImplementation catalog.bcprov.jdk18on
     testImplementation catalog.bcpkix.jdk18on
 
-    testRuntimeOnly project(":gbcs-server-memcached")
+    testRuntimeOnly project(":gbcs-server-memcache")
 }
 
 test {

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

@@ -400,9 +400,9 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
 
     fun run(): ServerHandle {
         // Create the multithreaded event loops for the server
-        val bossGroup = NioEventLoopGroup(0)
+        val bossGroup = NioEventLoopGroup(1)
         val serverSocketChannel = NioServerSocketChannel::class.java
-        val workerGroup = bossGroup
+        val workerGroup = NioEventLoopGroup(0)
         val eventExecutorGroup = run {
             val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
                 Thread.ofVirtual().factory()

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

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

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

@@ -1,13 +1,17 @@
 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.common.GBCS.digestString
-import java.io.ByteArrayInputStream
+import net.woggioni.jwo.JWO
 import java.io.ByteArrayOutputStream
 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.zip.Deflater
@@ -22,9 +26,9 @@ class InMemoryCache(
     val compressionLevel: Int
 ) : Cache {
 
-    private val map = ConcurrentHashMap<String, ByteArray>()
+    private val map = ConcurrentHashMap<String, ByteBuf>()
     
-    private class RemovalQueueElement(val key: String, val value : ByteArray, val expiry : Instant) : Comparable<RemovalQueueElement> {
+    private class RemovalQueueElement(val key: String, val value : ByteBuf, val expiry : Instant) : Comparable<RemovalQueueElement> {
         override fun compareTo(other: RemovalQueueElement) = expiry.compareTo(other.expiry)
     }
 
@@ -62,14 +66,16 @@ class InMemoryCache(
                     ?.let { value ->
                     if (compressionEnabled) {
                         val inflater = Inflater()
-                        Channels.newChannel(InflaterInputStream(ByteArrayInputStream(value), inflater))
+                        Channels.newChannel(InflaterInputStream(ByteBufInputStream(value), inflater))
                     } else {
-                        Channels.newChannel(ByteArrayInputStream(value))
+                        Channels.newChannel(ByteBufInputStream(value))
                     }
                 }
+            }.let {
+                CompletableFuture.completedFuture(it)
             }
 
-    override fun put(key: String, content: ByteArray) {
+    override fun put(key: String, content: ByteBuf) =
         (digestAlgorithm
             ?.let(MessageDigest::getInstance)
             ?.let { md ->
@@ -79,14 +85,15 @@ class InMemoryCache(
                 val deflater = Deflater(compressionLevel)
                 val baos = ByteArrayOutputStream()
                 DeflaterOutputStream(baos, deflater).use { stream ->
-                    stream.write(content)
+                    JWO.copy(ByteBufInputStream(content), stream)
                 }
-                baos.toByteArray()
+                Unpooled.wrappedBuffer(baos.toByteArray())
             } else {
                 content
             }
             map[digest] = value
             removalQueue.put(RemovalQueueElement(digest, value, Instant.now().plus(maxAge)))
-        }
+        }.let {
+            CompletableFuture.completedFuture<Void>(null)
         }
 }

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

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

@@ -265,7 +265,8 @@ object Parser {
         }.map { el ->
             val groupName = el.renderAttribute("name") ?: throw ConfigurationException("Group name is required")
             var roles = emptySet<Role>()
-            var quota: Configuration.Quota? = null
+            var userQuota: Configuration.Quota? = null
+            var groupQuota: Configuration.Quota? = null
             for (child in el.asIterable()) {
                 when (child.localName) {
                     "users" -> {
@@ -279,12 +280,15 @@ object Parser {
                     "roles" -> {
                         roles = parseRoles(child)
                     }
-                    "quota" -> {
+                    "group-quota" -> {
-                        quota = parseQuota(child)
+                        userQuota = parseQuota(child)
+                    }
+                    "user-quota" -> {
+                        groupQuota = parseQuota(child)
                     }
                 }
             }
-            groupName to Group(groupName, roles, quota)
+            groupName to Group(groupName, roles, userQuota, groupQuota)
         }.toMap()
         val users = knownUsersMap.map { (name, user) ->
             name to User(name, user.password, userGroups[name]?.mapNotNull { groups[it] }?.toSet() ?: emptySet(), user.quota)

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

@@ -8,8 +8,14 @@ import org.w3c.dom.Document
 
 object Serializer {
 
-    fun serialize(conf : Configuration) : Document {
+    private fun Xml.serializeQuota(quota : Configuration.Quota) {
+        attr("calls", quota.calls.toString())
+        attr("period", quota.period.toString())
+        attr("max-available-calls", quota.maxAvailableCalls.toString())
+        attr("initial-available-calls", quota.initialAvailableCalls.toString())
+    }
 
+    fun serialize(conf : Configuration) : Document {
         val schemaLocations = CacheSerializers.index.values.asSequence().map {
             it.xmlNamespace to it.xmlSchemaLocation
         }.toMap()
@@ -56,10 +62,7 @@ object Serializer {
                                 }
                                 user.quota?.let { quota ->
                                     node("quota") {
-                                        attr("calls", quota.calls.toString())
+                                        serializeQuota(quota)
-                                        attr("period", quota.period.toString())
-                                        attr("max-available-calls", quota.maxAvailableCalls.toString())
-                                        attr("initial-available-calls", quota.initialAvailableCalls.toString())
                                     }
                                 }
                             }
@@ -70,10 +73,7 @@ object Serializer {
                             anonymousUser.quota?.let { quota ->
                                 node("anonymous") {
                                     node("quota") {
-                                        attr("calls", quota.calls.toString())
+                                        serializeQuota(quota)
-                                        attr("period", quota.period.toString())
-                                        attr("max-available-calls", quota.maxAvailableCalls.toString())
-                                        attr("initial-available-calls", quota.initialAvailableCalls.toString())
                                     }
                                 }
                             }
@@ -113,12 +113,14 @@ object Serializer {
                                     }
                                 }
                             }
-                            group.quota?.let { quota ->
+                            group.userQuota?.let { quota ->
-                                node("quota") {
+                                node("user-quota") {
-                                    attr("calls", quota.calls.toString())
+                                    serializeQuota(quota)
-                                    attr("period", quota.period.toString())
+                                }
-                                    attr("max-available-calls", quota.maxAvailableCalls.toString())
+                            }
-                                    attr("initial-available-calls", quota.initialAvailableCalls.toString())
+                            group.groupQuota?.let { quota ->
+                                node("group-quota") {
+                                    serializeQuota(quota)
                                 }
                             }
                         }

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

@@ -1,83 +1,35 @@
 package net.woggioni.gbcs.server.handler
 
 import io.netty.buffer.Unpooled
+import io.netty.channel.ChannelFutureListener
+import io.netty.channel.ChannelHandler
 import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.DefaultFileRegion
 import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.DefaultHttpContent
 import io.netty.handler.codec.http.DefaultHttpResponse
-import io.netty.handler.codec.http.DefaultLastHttpContent
+import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.HttpContent
 import io.netty.handler.codec.http.HttpHeaderNames
 import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpMessage
 import io.netty.handler.codec.http.HttpMethod
-import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpUtil
 import io.netty.handler.codec.http.LastHttpContent
+import io.netty.handler.stream.ChunkedNioStream
 import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.api.CallHandle
-import net.woggioni.gbcs.api.ResponseEventListener
-import net.woggioni.gbcs.api.event.RequestEvent
-import net.woggioni.gbcs.api.event.ResponseEvent
 import net.woggioni.gbcs.common.contextLogger
 import net.woggioni.gbcs.server.debug
 import net.woggioni.gbcs.server.warn
+import java.nio.channels.FileChannel
 import java.nio.file.Path
-import java.util.concurrent.CompletableFuture
 
+@ChannelHandler.Sharable
 class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
-    SimpleChannelInboundHandler<HttpMessage>() {
+    SimpleChannelInboundHandler<FullHttpRequest>() {
 
-    companion object {
-        @JvmStatic
     private val log = contextLogger()
-    }
 
-    private data class TransientContext(
+    override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
-        var key: String?,
-        var callHandle: CompletableFuture<CallHandle<Void>>
-    )
-
-    private var transientContext: TransientContext? = null
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: HttpMessage) {
-        when (msg) {
-            is HttpRequest -> {
-                handleRequest(ctx, msg)
-            }
-
-            is LastHttpContent -> {
-                transientContext?.run {
-                    callHandle.thenCompose { callHandle ->
-                        callHandle.postEvent(RequestEvent.LastChunkSent(msg.content()))
-                        callHandle.call()
-                    }.thenApply {
-                        val response = DefaultFullHttpResponse(
-                            msg.protocolVersion(), HttpResponseStatus.CREATED,
-                            key?.let(String::toByteArray)
-                                ?.let(Unpooled::copiedBuffer)
-                        )
-//                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
-                        ctx.writeAndFlush(response)
-                    }
-                }
-            }
-
-            is HttpContent -> {
-                transientContext?.run {
-                    callHandle = callHandle.thenApply { it ->
-                        it.postEvent(RequestEvent.ChunkSent(msg.content()))
-                        it
-                    }
-                }
-            }
-        }
-
-    }
-
-    private fun handleRequest(ctx: ChannelHandlerContext, msg: HttpRequest) {
         val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
         val method = msg.method()
         if (method === HttpMethod.GET) {
@@ -90,61 +42,41 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                 return
             }
             if (serverPrefix == prefix) {
-                cache.get(key, object : ResponseEventListener {
+                cache.get(key).thenApply { channel ->
-                    var first = false
+                    if(channel != null) {
-                    override fun listen(evt: ResponseEvent) {
-                        when (evt) {
-                            is ResponseEvent.NoContent -> {
-                                log.debug(ctx) {
-                                    "Cache miss for key '$key'"
-                                }
-                                val response =
-                                    DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
-                                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                                ctx.writeAndFlush(response)
-                            }
-
-                            is ResponseEvent.ChunkReceived, is ResponseEvent.LastChunkReceived -> {
-                                if (first) {
-                                    first = false
                         log.debug(ctx) {
                             "Cache hit for key '$key'"
                         }
                         val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
-                                    response.headers()[HttpHeaderNames.CONTENT_TYPE] =
+                        response.headers()[HttpHeaderNames.CONTENT_TYPE] = HttpHeaderValues.APPLICATION_OCTET_STREAM
-                                        HttpHeaderValues.APPLICATION_OCTET_STREAM
                         if (!keepAlive) {
                             response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
-                                        response.headers()
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
-                                            .set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
                         } else {
-                                        response.headers()
+                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                                            .set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                                        response.headers()
-                                            .set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
                         }
                         ctx.write(response)
+                        val content : Any = when (channel) {
+                            is FileChannel -> DefaultFileRegion(channel, 0, channel.size())
+                            else -> ChunkedNioStream(channel)
                         }
-                                if (evt is ResponseEvent.LastChunkReceived)
+                        if (keepAlive) {
-                                    ctx.write(DefaultLastHttpContent(evt.chunk))
+                            ctx.write(content)
-                                else if (evt is ResponseEvent.ChunkReceived)
+                            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
-                                    ctx.write(DefaultHttpContent(evt.chunk))
+                        } else {
-                                ctx.flush()
+                            ctx.writeAndFlush(content)
+                                .addListener(ChannelFutureListener.CLOSE)
                         }
-
+                    } else {
-                            is ResponseEvent.ExceptionCaught -> {
+                        log.debug(ctx) {
-                                log.error(evt.cause.message, evt.cause)
+                            "Cache miss for key '$key'"
-                                val errorResponse = DefaultFullHttpResponse(
-                                    msg.protocolVersion(), HttpResponseStatus.INTERNAL_SERVER_ERROR,
-                                    evt.cause.message
-                                        ?.let(String::toByteArray)
-                                        ?.let(Unpooled::copiedBuffer)
-                                )
-                                ctx.write(errorResponse)
                         }
+                        val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
+                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
+                        ctx.writeAndFlush(response)
                     }
-                    }
+                }.whenComplete { _, ex -> ex?.let(ctx::fireExceptionCaught) }
-                }).thenCompose(CallHandle<Void>::call)
             } else {
                 log.warn(ctx) {
                     "Got request for unhandled path '${msg.uri()}'"
@@ -152,23 +84,26 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                 val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
                 response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
                 ctx.writeAndFlush(response)
-                ctx.channel().read()
             }
         } else if (method === HttpMethod.PUT) {
             val path = Path.of(msg.uri())
             val prefix = path.parent
             val key = path.fileName.toString()
+
             if (serverPrefix == prefix) {
                 log.debug(ctx) {
                     "Added value for key '$key' to build cache"
                 }
-                transientContext = TransientContext(key, cache.put(key))
+                cache.put(key, msg.content().retain()).thenRun {
                     val response = DefaultFullHttpResponse(
                         msg.protocolVersion(), HttpResponseStatus.CREATED,
                         Unpooled.copiedBuffer(key.toByteArray())
                     )
-//                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
+                    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()}'"
@@ -179,10 +114,7 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
             }
         } else if(method == HttpMethod.TRACE) {
             val replayedRequestHead = ctx.alloc().buffer()
-            replayedRequestHead.writeCharSequence(
+            replayedRequestHead.writeCharSequence("TRACE ${Path.of(msg.uri())} ${msg.protocolVersion().text()}\r\n", Charsets.US_ASCII)
-                "TRACE ${Path.of(msg.uri())} ${msg.protocolVersion().text()}\r\n",
-                Charsets.US_ASCII
-            )
             msg.headers().forEach { (key, value) ->
                 replayedRequestHead.apply {
                     writeCharSequence(key, Charsets.US_ASCII)
@@ -192,30 +124,18 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
                 }
             }
             replayedRequestHead.writeCharSequence("\r\n", Charsets.US_ASCII)
-            val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
+            val requestBody = msg.content()
+            requestBody.retain()
+            val responseBody = ctx.alloc().compositeBuffer(2).apply {
+                addComponents(true, replayedRequestHead)
+                addComponents(true, requestBody)
+            }
+            val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK, responseBody)
             response.headers().apply {
                 set(HttpHeaderNames.CONTENT_TYPE, "message/http")
+                set(HttpHeaderNames.CONTENT_LENGTH, responseBody.readableBytes())
             }
-            ctx.write(response)
+            ctx.writeAndFlush(response)
-            ctx.writeAndFlush(DefaultHttpContent(replayedRequestHead))
-            val callHandle = object : CallHandle<Void> {
-                override fun postEvent(evt: RequestEvent) {
-                    when (evt) {
-                        is RequestEvent.ChunkSent -> {
-                            ctx.writeAndFlush(DefaultHttpContent(evt.chunk))
-                        }
-
-                        is RequestEvent.LastChunkSent -> {
-                            ctx.writeAndFlush(DefaultLastHttpContent(evt.chunk))
-                        }
-                    }
-                }
-
-                override fun call(): CompletableFuture<Void> {
-                    return CompletableFuture.completedFuture(null)
-                }
-            }
-            transientContext = TransientContext(null, CompletableFuture.completedFuture(callHandle))
         } else {
             log.warn(ctx) {
                 "Got request with unhandled method '${msg.method().name()}'"
@@ -224,6 +144,5 @@ class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
             response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
             ctx.writeAndFlush(response)
         }
-
     }
 }

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

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

@@ -146,7 +146,8 @@
                 </xs:unique>
             </xs:element>
             <xs:element name="roles" type="gbcs:rolesType" maxOccurs="1" minOccurs="0"/>
-            <xs:element name="quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="user-quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="group-quota" type="gbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
         <xs:attribute name="name" type="xs:token"/>
     </xs:complexType>

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)
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null)
+    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, 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.server.GradleBuildCacheServer
 import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.server.GradleBuildCacheServer
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.MethodOrderer

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

@@ -4,7 +4,6 @@ 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
@@ -46,8 +45,8 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
     private lateinit var trustStore: KeyStore
     protected lateinit var ca: X509Credentials
 
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null)
+    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader), null, null)
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null)
+    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer), null, null)
     protected val random = Random(101325)
     protected val keyValuePair = newEntry(random)
     private val serverPath : String? = null

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

@@ -3,7 +3,6 @@ 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/kotlin/net/woggioni/gbcs/server/test/TlsServerTest.kt

@@ -7,7 +7,6 @@ import org.bouncycastle.asn1.x500.X500Name
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.params.provider.ArgumentsSource
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/valid/gbcs-memcached-tls.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-memcached="urn:net.woggioni.gbcs.server.memcached"
+             xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
-             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"
+             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
@@ -13,7 +13,7 @@
             read-timeout="PT5M"
             write-timeout="PT5M"/>
     <event-executor use-virtual-threads="true"/>
-    <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="16777216" compression-mode="zip">
+    <cache xs:type="gbcs-memcache:memcacheCacheType" max-age="P7D" max-size="16777216" compression-mode="deflate">
         <server host="memcached" port="11211"/>
     </cache>
     <authorization>

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-memcached="urn:net.woggioni.gbcs.server.memcached"
+             xmlns:gbcs-memcache="urn:net.woggioni.gbcs.server.memcache"
-             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">
+             xs:schemaLocation="urn:net.woggioni.gbcs.server.memcache jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
     <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="50"/>
     <connection
             write-timeout="PT25M"
@@ -12,8 +12,8 @@
             idle-timeout="PT30M"
             max-request-size="101325"/>
     <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="101325" digest="SHA-256">
+    <cache xs:type="gbcs-memcache:memcacheCacheType" max-age="P7D" max-size="101325" digest="SHA-256">
-        <server host="127.0.0.1" port="11211"/>
+        <server host="127.0.0.1" port="11211" max-connections="10" connection-timeout="PT20S"/>
     </cache>
     <authentication>
         <none/>

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

@@ -32,7 +32,8 @@
                 <roles>
                     <reader/>
                 </roles>
-                <quota calls="10" period="PT1S"/>
+                <user-quota calls="30" period="PT1M"/>
+                <group-quota calls="10" period="PT1S"/>
             </group>
             <group name="writers">
                 <users>
@@ -50,7 +51,7 @@
                     <reader/>
                     <writer/>
                 </roles>
-                <quota calls="1000" period="P1D"/>
+                <group-quota calls="1000" period="P1D"/>
             </group>
         </groups>
     </authorization>

gradle.properties

@@ -2,7 +2,7 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true
 
-gbcs.version = 0.1.1
+gbcs.version = 0.1.2
 
 lys.version = 2025.01.31
 

settings.gradle

@@ -27,7 +27,7 @@ rootProject.name = 'gbcs'
 
 include 'gbcs-api'
 include 'gbcs-common'
-include 'gbcs-server-memcached'
+include 'gbcs-server-memcache'
 include 'gbcs-cli'
 include 'docker'
 include 'gbcs-client'