temporary commit

README.md

@@ -4,25 +4,12 @@ and test outputs across the team. This speeds up local and CI builds since cycle
 re-building components that are unaffected by new code changes. RBCS supports both Gradle and
 Maven build tool environments.
 
-It comes with pluggable storage backends, the core application offers in-memory storage or disk-backed storage,
-in addition to this there is an official plugin to use memcached as the storage backend.
-
-It supports HTTP basic authentication or, alternatively, TLS certificate authentication, role-based access control (RBAC),
-and throttling.
-
-## Quickstart
+## Getting Started
 
 ### Downloading the jar file 
-You can download the latest version from [this link](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni:rbcs-cli/)
+You can download the latest version from [this link](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni-rbcs-cli/)
 
-Assuming you have Java 21 or later installed, you can launch the server directly with
-
-```bash
-java -jar rbcs-cli.jar server
-```
-
-By default it will start an HTTP server bound to localhost and listening on port 8080 with no authentication,
-writing data to the disk, that you can use for testing
+If you want to use memcache as a storage backend you'll also need to download [the memcache plugin](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni-rbcs-server-memcache/)
 
 ### Using the Docker image
 You can pull the latest Docker image with
@@ -30,107 +17,21 @@ You can pull the latest Docker image with
 docker pull gitea.woggioni.net/woggioni/rbcs:latest
 ```
 
-By default it will start an HTTP server bound to localhost and listening on port 8080 with no authentication,
-writing data to the disk, that you can use for testing
-
 ## Usage
-
-### Configuration
-The location of the `rbcs.xml` configuration file depends on the operating system, 
-Alternatively it can be changed setting the `RBCS_CONFIGURATION_DIR` environmental variable or `net.woggioni.rbcs.conf.dir` Java system property
-to the directory that contain the `rbcs.xml` file.
-
-The server configuration file follows the XML format and uses XML schema for validation
-(you can find the schema for the main configuration file [here](https://gitea.woggioni.net/woggioni/rbcs/src/branch/master/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd)).
-
-The configuration values are enclosed inside XML attribute and support system property / environmental variable interpolation.
-As an example, you can configure RBCS to read the server port number from the `RBCS_SERVER_PORT` environmental variable
-and the bind address from the `rbc.bind.address` JVM system property with.
-
-Full documentation for all tags and attributes is available [here](doc/server_configuration.md).
-
-### Plugins
-If you want to use memcache as a storage backend you'll also need to download [the memcache plugin](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni:rbcs-server-memcache/)
-
-Plugins need to be stored in a folder named `plugins` in the located server's working directory
-(the directory where the server process is started). They are shipped as TAR archives, so you need to extract
-the content of the archive into the `plugins` directory for the server to pick them up.
-
+## Configuration
 ### Using RBCS with Gradle 
 
-Add this to the `settings.gradle` file of your project
-
 ```groovy
 buildCache {
     remote(HttpBuildCache) {
         url = 'https://rbcs.example.com/'
-        push = true
-        allowInsecureProtocol = false
-        // The credentials block is only required if you enable 
-        // HTTP basic authentication on RBCS
-        credentials {
-            username = 'build-cache-user'
-            password = 'some-complicated-password'
-        }
     }
 }
 ```
 
-alternatively you can add this to `${GRADLE_HOME}/init.gradle` to configure the remote cache
-at the system level
-
-```groovy
-gradle.settingsEvaluated { settings ->
-    settings.buildCache {
-        remote(HttpBuildCache) {
-            url = 'https://rbcs.example.com/'
-            push = true
-            allowInsecureProtocol = false
-            // The credentials block is only required if you enable 
-            // HTTP basic authentication on RBCS
-            credentials {
-                username = 'build-cache-user'
-                password = 'some-complicated-password'
-            }
-        }
-    }
-}
-```
-
-add `org.gradle.caching=true` to your `<project>/gradle.properties` or run gradle with `--build-cache`.
-
-Read [Gradle documentation](https://docs.gradle.org/current/userguide/build_cache.html) for more detailed information.
-
 ### Using RBCS with Maven
 
-1. Create an `extensions.xml` in `<project>/.mvn/extensions.xml` with the following content
-  ```xml
-  <extensions xmlns="http://maven.apache.org/EXTENSIONS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-            xsi:schemaLocation="http://maven.apache.org/EXTENSIONS/1.1.0 https://maven.apache.org/xsd/core-extensions-1.0.0.xsd">
-      <extension>
-          <groupId>org.apache.maven.extensions</groupId>
-          <artifactId>maven-build-cache-extension</artifactId>
-          <version>1.2.0</version>
-      </extension>
-  </extensions>
-  ```
-2. Copy [maven-build-cache-config.xml](https://maven.apache.org/extensions/maven-build-cache-extension/maven-build-cache-config.xml) into `<project>/.mvn/` folder
-3. Edit the `cache/configuration/remote` element
-  ```xml
-    <remote enabled="true" id="rbcs">
-        <url>https://rbcs.example.com/</url>
-    </remote>
-  ```
-4. Run maven with
-  ```bash
-    mvn -Dmaven.build.cache.enabled=true -Dmaven.build.cache.debugOutput=true -Dmaven.build.cache.remote.save.enabled=true package
-  ```
-
-Alternatively you can set those properties in your `<project>/pom.xml`
-
-
 Read [here](https://maven.apache.org/extensions/maven-build-cache-extension/remote-cache.html)
-for more informations
 
 ## FAQ
 ### Why should I use a build cache?

build.gradle

@@ -14,7 +14,9 @@ allprojects { subproject ->
         if(project.currentTag.isPresent()) {
             version = project.currentTag.map { it[0] }.get()
         } else {
-            version = "${getProperty('rbcs.version')}-SNAPSHOT"
+            version = project.gitRevision.map { gitRevision ->
+                "${getProperty('rbcs.version')}.${gitRevision[0..10]}"
+            }.get()
         }
 
     repositories {
@@ -22,6 +24,7 @@ allprojects { subproject ->
             url = getProperty('gitea.maven.url')
             content {
                 includeModule 'net.woggioni', 'jwo'
+                includeModule 'net.woggioni', 'xmemcached'
                 includeGroup 'com.lys'
             }
         }

docker/Dockerfile

@@ -5,7 +5,7 @@ WORKDIR /home/luser
 
 FROM base-release AS release
 ADD rbcs-cli-envelope-*.jar rbcs.jar
-ENTRYPOINT ["java", "-XX:+UseSerialGC", "-XX:GCTimeRatio=24", "-jar", "/home/luser/rbcs.jar", "server"]
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/rbcs.jar", "server"]
 
 FROM base-release AS release-memcache
 ADD --chown=luser:luser rbcs-cli-envelope-*.jar rbcs.jar
@@ -13,5 +13,4 @@ RUN mkdir plugins
 WORKDIR /home/luser/plugins
 RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/rbcs-server-memcache*.tar
 WORKDIR /home/luser
-ADD logback.xml .
-ENTRYPOINT ["java", "-Dlogback.configurationFile=logback.xml", "-XX:+UseSerialGC", "-XX:GCTimeRatio=24", "-jar", "/home/luser/rbcs.jar", "server"]
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/rbcs.jar", "server"]

docker/build.gradle

@@ -30,9 +30,6 @@ Provider<Copy> prepareDockerBuild = tasks.register('prepareDockerBuild', Copy) {
     into project.layout.buildDirectory.file('docker')
     from(configurations.docker)
     from(file('Dockerfile'))
-    from(rootProject.file('conf')) {
-        include 'logback.xml'
-    }
 }
 
 Provider<DockerBuildImage> dockerBuild = tasks.register('dockerBuildImage', DockerBuildImage) {
@@ -66,3 +63,5 @@ Provider<DockerPushImage> dockerPush = tasks.register('dockerPushImage', DockerP
     }
     images = [dockerTag.flatMap{ it.tag }, dockerTagMemcache.flatMap{ it.tag }]
 }
+
+

gradle.properties

@@ -2,10 +2,11 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true
 
-rbcs.version = 0.2.0
+rbcs.version = 0.1.4
 
-lys.version = 2025.02.08
+lys.version = 2025.02.05
 
 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
 docker.registry.url=gitea.woggioni.net
 
+jpms-check.configurationName = runtimeClasspath

rbcs-api/build.gradle

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

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

@@ -2,10 +2,6 @@ module net.woggioni.rbcs.api {
     requires static lombok;
     requires java.xml;
     requires io.netty.buffer;
-    requires io.netty.handler;
-    requires io.netty.transport;
-    requires io.netty.common;
     exports net.woggioni.rbcs.api;
     exports net.woggioni.rbcs.api.exception;
-    exports net.woggioni.rbcs.api.message;
 }

rbcs-api/src/main/java/net/woggioni/rbcs/api/AsyncCloseable.java

@@ -1,13 +0,0 @@
-package net.woggioni.rbcs.api;
-
-import java.util.concurrent.CompletableFuture;
-
-public interface AsyncCloseable extends AutoCloseable {
-
-    CompletableFuture<Void> asyncClose();
-
-    @Override
-    default void close() throws Exception {
-        asyncClose().get();
-    }
-}

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

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

rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheHandlerFactory.java

@@ -1,15 +0,0 @@
-package net.woggioni.rbcs.api;
-
-import io.netty.channel.ChannelFactory;
-import io.netty.channel.ChannelHandler;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.socket.DatagramChannel;
-import io.netty.channel.socket.SocketChannel;
-
-public interface CacheHandlerFactory extends AsyncCloseable {
-    ChannelHandler newHandler(
-            EventLoopGroup eventLoopGroup,
-            ChannelFactory<SocketChannel> socketChannelFactory,
-            ChannelFactory<DatagramChannel> datagramChannelFactory
-    );
-}

rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheValueMetadata.java

@@ -1,14 +0,0 @@
-package net.woggioni.rbcs.api;
-
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-
-import java.io.Serializable;
-
-@Getter
-@RequiredArgsConstructor
-public class CacheValueMetadata implements Serializable {
-    private final String contentDisposition;
-    private final String mimeType;
-}
-

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

@@ -35,6 +35,8 @@ public class Configuration {
 
     @Value
     public static class Connection {
+        Duration readTimeout;
+        Duration writeTimeout;
         Duration idleTimeout;
         Duration readIdleTimeout;
         Duration writeIdleTimeout;
@@ -83,6 +85,17 @@ public class Configuration {
         Group extract(X509Certificate cert);
     }
 
+    @Value
+    public static class Throttling {
+        KeyStore keyStore;
+        TrustStore trustStore;
+        boolean verifyClients;
+    }
+
+    public enum ClientCertificate {
+        REQUIRED, OPTIONAL
+    }
+
     @Value
     public static class Tls {
         KeyStore keyStore;
@@ -122,7 +135,7 @@ public class Configuration {
     }
 
     public interface Cache {
-        CacheHandlerFactory materialize();
+        net.woggioni.rbcs.api.Cache materialize();
         String getNamespaceURI();
         String getTypeName();
     }

rbcs-api/src/main/java/net/woggioni/rbcs/api/message/CacheMessage.java

@@ -1,161 +0,0 @@
-package net.woggioni.rbcs.api.message;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufHolder;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import net.woggioni.rbcs.api.CacheValueMetadata;
-
-public sealed interface CacheMessage {
-
-    @Getter
-    @RequiredArgsConstructor
-    final class CacheGetRequest implements CacheMessage {
-        private final String key;
-    }
-
-    abstract sealed class CacheGetResponse implements CacheMessage {
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    final class CacheValueFoundResponse extends CacheGetResponse {
-        private final String key;
-        private final CacheValueMetadata metadata;
-    }
-
-    final class CacheValueNotFoundResponse extends CacheGetResponse {
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    final class CachePutRequest implements CacheMessage {
-        private final String key;
-        private final CacheValueMetadata metadata;
-    }
-
-    @Getter
-    @RequiredArgsConstructor
-    final class CachePutResponse implements CacheMessage {
-        private final String key;
-    }
-
-    @RequiredArgsConstructor
-    non-sealed class CacheContent implements CacheMessage, ByteBufHolder {
-        protected final ByteBuf chunk;
-
-        @Override
-        public ByteBuf content() {
-            return chunk;
-        }
-
-        @Override
-        public CacheContent copy() {
-            return replace(chunk.copy());
-        }
-
-        @Override
-        public CacheContent duplicate() {
-            return new CacheContent(chunk.duplicate());
-        }
-
-        @Override
-        public CacheContent retainedDuplicate() {
-            return new CacheContent(chunk.retainedDuplicate());
-        }
-
-        @Override
-        public CacheContent replace(ByteBuf content) {
-            return new CacheContent(content);
-        }
-
-        @Override
-        public CacheContent retain() {
-            chunk.retain();
-            return this;
-        }
-
-        @Override
-        public CacheContent retain(int increment) {
-            chunk.retain(increment);
-            return this;
-        }
-
-        @Override
-        public CacheContent touch() {
-            chunk.touch();
-            return this;
-        }
-
-        @Override
-        public CacheContent touch(Object hint) {
-            chunk.touch(hint);
-            return this;
-        }
-
-        @Override
-        public int refCnt() {
-            return chunk.refCnt();
-        }
-
-        @Override
-        public boolean release() {
-            return chunk.release();
-        }
-
-        @Override
-        public boolean release(int decrement) {
-            return chunk.release(decrement);
-        }
-    }
-
-    final class LastCacheContent extends CacheContent {
-        public LastCacheContent(ByteBuf chunk) {
-            super(chunk);
-        }
-
-        @Override
-        public LastCacheContent copy() {
-            return replace(chunk.copy());
-        }
-
-        @Override
-        public LastCacheContent duplicate() {
-            return new LastCacheContent(chunk.duplicate());
-        }
-
-        @Override
-        public LastCacheContent retainedDuplicate() {
-            return new LastCacheContent(chunk.retainedDuplicate());
-        }
-
-        @Override
-        public LastCacheContent replace(ByteBuf content) {
-            return new LastCacheContent(chunk);
-        }
-
-        @Override
-        public LastCacheContent retain() {
-            super.retain();
-            return this;
-        }
-
-        @Override
-        public LastCacheContent retain(int increment) {
-            super.retain(increment);
-            return this;
-        }
-
-        @Override
-        public LastCacheContent touch() {
-            super.touch();
-            return this;
-        }
-
-        @Override
-        public LastCacheContent touch(Object hint) {
-            super.touch(hint);
-            return this;
-        }
-    }
-}

rbcs-cli/build.gradle

@@ -9,7 +9,6 @@ plugins {
     id 'maven-publish'
 }
 
-import net.woggioni.gradle.envelope.EnvelopePlugin
 import net.woggioni.gradle.envelope.EnvelopeJarTask
 import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
 import net.woggioni.gradle.graalvm.NativeImagePlugin
@@ -17,29 +16,6 @@ import net.woggioni.gradle.graalvm.NativeImageTask
 import net.woggioni.gradle.graalvm.JlinkPlugin
 import net.woggioni.gradle.graalvm.JlinkTask
 
-configurations {
-    release {
-        transitive = false
-        canBeConsumed = true
-        canBeResolved = true
-        visible = true
-    }
-}
-
-dependencies {
-    implementation catalog.jwo
-    implementation catalog.slf4j.api
-    implementation catalog.picocli
-
-    implementation project(':rbcs-client')
-    implementation project(':rbcs-server')
-
-//    runtimeOnly catalog.slf4j.jdk14
-    runtimeOnly catalog.logback.classic
-//    runtimeOnly catalog.slf4j.simple
-}
-
-
 Property<String> mainModuleName = objects.property(String.class)
 mainModuleName.set('net.woggioni.rbcs.cli')
 Property<String> mainClassName = objects.property(String.class)
@@ -49,14 +25,48 @@ tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
     options.javaModuleMainClass = mainClassName
 }
 
-Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named(EnvelopePlugin.ENVELOPE_JAR_TASK_NAME, EnvelopeJarTask.class) {
+configurations {
+    release {
+        transitive = false
+        canBeConsumed = true
+        canBeResolved = true
+        visible = true
+    }
+}
+
+envelopeJar {
     mainModule = mainModuleName
     mainClass = mainClassName
 
     extraClasspath = ["plugins"]
+}
 
+dependencies {
+    implementation catalog.jwo
+    implementation catalog.slf4j.api
+    implementation catalog.netty.codec.http
+    implementation catalog.picocli
+
+    implementation project(':rbcs-client')
+    implementation project(':rbcs-server')
+
+//    runtimeOnly catalog.slf4j.jdk14
+    runtimeOnly catalog.logback.classic
+//    runtimeOnly catalog.slf4j.simple
+}
+
+Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named('envelopeJar', EnvelopeJarTask.class) {
+//    systemProperties['java.util.logging.config.class'] = 'net.woggioni.rbcs.LoggingConfig'
+//    systemProperties['log.config.source'] = 'net/woggioni/rbcs/cli/logging.properties'
+//    systemProperties['java.util.logging.config.file'] = 'classpath:net/woggioni/rbcs/cli/logging.properties'
     systemProperties['logback.configurationFile'] = 'classpath:net/woggioni/rbcs/cli/logback.xml'
     systemProperties['io.netty.leakDetectionLevel'] = 'DISABLED'
+
+//    systemProperties['org.slf4j.simpleLogger.showDateTime'] = 'true'
+//    systemProperties['org.slf4j.simpleLogger.defaultLogLevel'] = 'debug'
+//    systemProperties['org.slf4j.simpleLogger.log.com.google.code.yanf4j'] = 'warn'
+//    systemProperties['org.slf4j.simpleLogger.log.net.rubyeye.xmemcached'] = 'warn'
+//    systemProperties['org.slf4j.simpleLogger.dateTimeFormat'] = 'yyyy-MM-dd\'T\'HH:mm:ss.SSSZ'
 }
 
 tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask) {
@@ -76,14 +86,6 @@ tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
     mainModule = 'net.woggioni.rbcs.cli'
 }
 
-tasks.named(JavaPlugin.PROCESS_RESOURCES_TASK_NAME, ProcessResources) {
-    from(rootProject.file('conf')) {
-        into('net/woggioni/rbcs/cli')
-        include 'logback.xml'
-        include 'logging.properties'
-    }
-}
-
 artifacts {
     release(envelopeJarTaskProvider)
 }

rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/RemoteBuildCacheServerCli.kt

@@ -1,6 +1,5 @@
 package net.woggioni.rbcs.cli
 
-import net.woggioni.jwo.Application
 import net.woggioni.rbcs.cli.impl.AbstractVersionProvider
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.cli.impl.commands.BenchmarkCommand
@@ -12,6 +11,7 @@ import net.woggioni.rbcs.cli.impl.commands.PutCommand
 import net.woggioni.rbcs.cli.impl.commands.ServerCommand
 import net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory
 import net.woggioni.rbcs.common.contextLogger
+import net.woggioni.jwo.Application
 import picocli.CommandLine
 import picocli.CommandLine.Model.CommandSpec
 

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

@@ -1,20 +1,15 @@
 package net.woggioni.rbcs.cli.impl.commands
 
-import net.woggioni.jwo.JWO
-import net.woggioni.jwo.LongMath
-import net.woggioni.rbcs.api.CacheValueMetadata
 import net.woggioni.rbcs.cli.impl.RbcsCommand
-import net.woggioni.rbcs.cli.impl.converters.ByteSizeConverter
 import net.woggioni.rbcs.client.RemoteBuildCacheClient
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.common.error
 import net.woggioni.rbcs.common.info
+import net.woggioni.jwo.JWO
 import picocli.CommandLine
 import java.security.SecureRandom
 import java.time.Duration
 import java.time.Instant
-import java.time.temporal.ChronoUnit
 import java.util.concurrent.LinkedBlockingQueue
 import java.util.concurrent.Semaphore
 import java.util.concurrent.atomic.AtomicLong
@@ -26,9 +21,7 @@ import kotlin.random.Random
     showDefaultValues = true
 )
 class BenchmarkCommand : RbcsCommand() {
-    companion object{
-        private val log = createLogger<BenchmarkCommand>()
-    }
+    private val log = contextLogger()
 
     @CommandLine.Spec
     private lateinit var spec: CommandLine.Model.CommandSpec
@@ -43,36 +36,24 @@ class BenchmarkCommand : RbcsCommand() {
     @CommandLine.Option(
         names = ["-s", "--size"],
         description = ["Size of a cache value in bytes"],
-        paramLabel = "SIZE",
-        converter = [ByteSizeConverter::class]
+        paramLabel = "SIZE"
     )
     private var size = 0x1000
 
-    @CommandLine.Option(
-        names = ["-r", "--random"],
-        description = ["Insert completely random byte values"]
-    )
-    private var randomValues = false
-
     override fun run() {
         val clientCommand = spec.parent().userObject() as ClientCommand
         val profile = clientCommand.profileName.let { profileName ->
             clientCommand.configuration.profiles[profileName]
                 ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
         }
-        val progressThreshold = LongMath.ceilDiv(numberOfEntries.toLong(), 20)
         RemoteBuildCacheClient(profile).use { client ->
 
             val entryGenerator = sequence {
                 val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
                 while (true) {
                     val key = JWO.bytesToHex(random.nextBytes(16))
-                    val value = if(randomValues) {
-                        random.nextBytes(size)
-                    } else {
-                        val byteValue = random.nextInt().toByte()
-                        ByteArray(size) {_ -> byteValue}
-                    }
+                    val content = random.nextInt().toByte()
+                    val value = ByteArray(size, { _ -> content })
                     yield(key to value)
                 }
             }
@@ -84,13 +65,13 @@ class BenchmarkCommand : RbcsCommand() {
                 val completionCounter = AtomicLong(0)
                 val completionQueue = LinkedBlockingQueue<Pair<String, ByteArray>>(numberOfEntries)
                 val start = Instant.now()
-                val semaphore = Semaphore(profile.maxConnections * 5)
+                val semaphore = Semaphore(profile.maxConnections * 3)
                 val iterator = entryGenerator.take(numberOfEntries).iterator()
                 while (completionCounter.get() < numberOfEntries) {
                     if (iterator.hasNext()) {
                         val entry = iterator.next()
                         semaphore.acquire()
-                        val future = client.put(entry.first, entry.second, CacheValueMetadata(null, null)).thenApply { entry }
+                        val future = client.put(entry.first, entry.second).thenApply { entry }
                         future.whenComplete { result, ex ->
                             if (ex != null) {
                                 log.error(ex.message, ex)
@@ -98,15 +79,10 @@ class BenchmarkCommand : RbcsCommand() {
                                 completionQueue.put(result)
                             }
                             semaphore.release()
-                            val completed = completionCounter.incrementAndGet()
-                            if(completed.mod(progressThreshold) == 0L) {
-                                log.debug {
-                                    "Inserted $completed / $numberOfEntries"
-                                }
-                            }
+                            completionCounter.incrementAndGet()
                         }
                     } else {
-                        Thread.sleep(Duration.of(500, ChronoUnit.MILLIS))
+                        Thread.sleep(0)
                     }
                 }
 
@@ -127,13 +103,12 @@ class BenchmarkCommand : RbcsCommand() {
             }
             if (entries.isNotEmpty()) {
                 val completionCounter = AtomicLong(0)
-                val semaphore = Semaphore(profile.maxConnections * 5)
+                val semaphore = Semaphore(profile.maxConnections * 3)
                 val start = Instant.now()
                 val it = entries.iterator()
                 while (completionCounter.get() < entries.size) {
                     if (it.hasNext()) {
                         val entry = it.next()
-                        semaphore.acquire()
                         val future = client.get(entry.first).thenApply {
                             if (it == null) {
                                 log.error {
@@ -146,16 +121,11 @@ class BenchmarkCommand : RbcsCommand() {
                             }
                         }
                         future.whenComplete { _, _ ->
-                            val completed = completionCounter.incrementAndGet()
-                            if(completed.mod(progressThreshold) == 0L) {
-                                log.debug {
-                                    "Retrieved $completed / ${entries.size}"
-                                }
-                            }
+                            completionCounter.incrementAndGet()
                             semaphore.release()
                         }
                     } else {
-                        Thread.sleep(Duration.of(500, ChronoUnit.MILLIS))
+                        Thread.sleep(0)
                     }
                 }
                 val end = Instant.now()

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

@@ -1,8 +1,8 @@
 package net.woggioni.rbcs.cli.impl.commands
 
-import net.woggioni.jwo.Application
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.client.RemoteBuildCacheClient
+import net.woggioni.jwo.Application
 import picocli.CommandLine
 import java.nio.file.Path
 

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

@@ -2,7 +2,7 @@ package net.woggioni.rbcs.cli.impl.commands
 
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.client.RemoteBuildCacheClient
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import picocli.CommandLine
 import java.nio.file.Files
 import java.nio.file.Path
@@ -13,9 +13,7 @@ import java.nio.file.Path
     showDefaultValues = true
 )
 class GetCommand : RbcsCommand() {
-    companion object{
-        private val log = createLogger<GetCommand>()
-    }
+    private val log = contextLogger()
 
     @CommandLine.Spec
     private lateinit var spec: CommandLine.Model.CommandSpec

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

@@ -2,7 +2,7 @@ package net.woggioni.rbcs.cli.impl.commands
 
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.client.RemoteBuildCacheClient
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import picocli.CommandLine
 import java.security.SecureRandom
 import kotlin.random.Random
@@ -13,9 +13,7 @@ import kotlin.random.Random
     showDefaultValues = true
 )
 class HealthCheckCommand : RbcsCommand() {
-    companion object{
-        private val log = createLogger<HealthCheckCommand>()
-    }
+    private val log = contextLogger()
 
     @CommandLine.Spec
     private lateinit var spec: CommandLine.Model.CommandSpec
@@ -34,12 +32,11 @@ class HealthCheckCommand : RbcsCommand() {
                 if(value == null) {
                     throw IllegalStateException("Empty response from server")
                 }
-                val offset = value.size - nonce.size
                 for(i in 0 until nonce.size) {
-                    val a = nonce[i]
-                    val b = value[offset + i]
-                    if(a != b) {
-                        throw IllegalStateException("Server nonce does not match")
+                    for(j in value.size - nonce.size until nonce.size) {
+                        if(nonce[i] != value[j]) {
+                            throw IllegalStateException("Server nonce does not match")
+                        }
                     }
                 }
             }.get()

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

@@ -1,9 +1,9 @@
 package net.woggioni.rbcs.cli.impl.commands
 
-import net.woggioni.jwo.UncloseableOutputStream
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.cli.impl.converters.OutputStreamConverter
 import net.woggioni.rbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.jwo.UncloseableOutputStream
 import picocli.CommandLine
 import java.io.OutputStream
 import java.io.OutputStreamWriter

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

@@ -1,17 +1,11 @@
 package net.woggioni.rbcs.cli.impl.commands
 
-import net.woggioni.jwo.Hash
-import net.woggioni.jwo.JWO
-import net.woggioni.jwo.NullOutputStream
-import net.woggioni.rbcs.api.CacheValueMetadata
 import net.woggioni.rbcs.cli.impl.RbcsCommand
+import net.woggioni.rbcs.cli.impl.converters.InputStreamConverter
 import net.woggioni.rbcs.client.RemoteBuildCacheClient
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import picocli.CommandLine
 import java.io.InputStream
-import java.nio.file.Files
-import java.nio.file.Path
-import java.util.UUID
 
 @CommandLine.Command(
     name = "put",
@@ -19,41 +13,25 @@ import java.util.UUID
     showDefaultValues = true
 )
 class PutCommand : RbcsCommand() {
-    companion object{
-        private val log = createLogger<PutCommand>()
-    }
-
+    private val log = contextLogger()
 
     @CommandLine.Spec
     private lateinit var spec: CommandLine.Model.CommandSpec
 
     @CommandLine.Option(
         names = ["-k", "--key"],
-        description = ["The key for the new value, randomly generated if omitted"],
+        description = ["The key for the new value"],
         paramLabel = "KEY"
     )
-    private var key : String? = null
-
-    @CommandLine.Option(
-        names = ["-i", "--inline"],
-        description = ["File is to be displayed in the browser"],
-        paramLabel = "INLINE",
-    )
-    private var inline : Boolean = false
-
-    @CommandLine.Option(
-        names = ["-t", "--type"],
-        description = ["File mime type"],
-        paramLabel = "MIME_TYPE",
-    )
-    private var mimeType : String? = null
+    private var key : String = ""
 
     @CommandLine.Option(
         names = ["-v", "--value"],
         description = ["Path to a file containing the value to be added (defaults to stdin)"],
         paramLabel = "VALUE_FILE",
+        converter = [InputStreamConverter::class]
     )
-    private var value : Path? = null
+    private var value : InputStream = System.`in`
 
     override fun run() {
         val clientCommand = spec.parent().userObject() as ClientCommand
@@ -62,40 +40,9 @@ class PutCommand : RbcsCommand() {
                 ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
         }
         RemoteBuildCacheClient(profile).use { client ->
-            val inputStream : InputStream
-            val mimeType : String?
-            val contentDisposition : String?
-            val valuePath = value
-            val actualKey : String?
-            if(valuePath != null) {
-                inputStream = Files.newInputStream(valuePath)
-                mimeType = this.mimeType ?: Files.probeContentType(valuePath)
-                contentDisposition = if(inline) {
-                    "inline"
-                } else {
-                    "attachment; filename=\"${valuePath.fileName}\""
-                }
-                actualKey = key ?: let {
-                    val md = Hash.Algorithm.SHA512.newInputStream(Files.newInputStream(valuePath)).use {
-                        JWO.copy(it, NullOutputStream())
-                        it.messageDigest
-                    }
-                    UUID.nameUUIDFromBytes(md.digest()).toString()
-                }
-            } else {
-                inputStream = System.`in`
-                mimeType = this.mimeType
-                contentDisposition = if(inline) {
-                    "inline"
-                } else {
-                    null
-                }
-                actualKey = key ?: UUID.randomUUID().toString()
-            }
-            inputStream.use {
-                client.put(actualKey, it.readAllBytes(), CacheValueMetadata(contentDisposition, mimeType))
+            value.use {
+                client.put(key, it.readAllBytes())
             }.get()
-            println(profile.serverURI.resolve(actualKey))
         }
     }
 }

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

@@ -1,20 +1,19 @@
 package net.woggioni.rbcs.cli.impl.commands
 
-import net.woggioni.jwo.Application
-import net.woggioni.jwo.JWO
 import net.woggioni.rbcs.cli.impl.RbcsCommand
 import net.woggioni.rbcs.cli.impl.converters.DurationConverter
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.common.debug
 import net.woggioni.rbcs.common.info
 import net.woggioni.rbcs.server.RemoteBuildCacheServer
 import net.woggioni.rbcs.server.RemoteBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
+import net.woggioni.jwo.Application
+import net.woggioni.jwo.JWO
 import picocli.CommandLine
 import java.io.ByteArrayOutputStream
 import java.nio.file.Files
 import java.nio.file.Path
 import java.time.Duration
-import java.util.concurrent.TimeUnit
 
 @CommandLine.Command(
     name = "server",
@@ -22,9 +21,8 @@ import java.util.concurrent.TimeUnit
     showDefaultValues = true
 )
 class ServerCommand(app : Application) : RbcsCommand() {
-    companion object {
-        private val log = createLogger<ServerCommand>()
-    }
+
+    private val log = contextLogger()
 
     private fun createDefaultConfigurationFile(configurationFile: Path) {
         log.info {
@@ -59,9 +57,6 @@ class ServerCommand(app : Application) : RbcsCommand() {
             createDefaultConfigurationFile(configurationFile)
         }
 
-        log.debug {
-            "Using configuration file '$configurationFile'"
-        }
         val configuration = RemoteBuildCacheServer.loadConfiguration(configurationFile)
         log.debug {
             ByteArrayOutputStream().also {
@@ -71,20 +66,11 @@ class ServerCommand(app : Application) : RbcsCommand() {
             }
         }
         val server = RemoteBuildCacheServer(configuration)
-        val handle = server.run()
-        val shutdownHook = Thread.ofPlatform().unstarted {
-            handle.sendShutdownSignal()
-            try {
-                handle.get(60, TimeUnit.SECONDS)
-            } catch (ex : Throwable) {
-                log.warn(ex.message, ex)
+        server.run().use { server ->
+            timeout?.let {
+                Thread.sleep(it)
+                server.shutdown()
             }
         }
-        Runtime.getRuntime().addShutdownHook(shutdownHook)
-        if(timeout != null) {
-            Thread.sleep(timeout)
-            handle.sendShutdownSignal()
-        }
-        handle.get()
     }
 }

rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/converters/ByteSizeConverter.kt

@@ -1,10 +0,0 @@
-package net.woggioni.rbcs.cli.impl.converters
-
-import picocli.CommandLine
-
-
-class ByteSizeConverter : CommandLine.ITypeConverter<Int> {
-    override fun convert(value: String): Int {
-        return Integer.decode(value)
-    }
-}

rbcs-client/build.gradle

@@ -6,11 +6,9 @@ plugins {
 dependencies {
     implementation project(':rbcs-api')
     implementation project(':rbcs-common')
+    implementation catalog.picocli
     implementation catalog.slf4j.api
     implementation catalog.netty.buffer
-    implementation catalog.netty.handler
-    implementation catalog.netty.transport
-    implementation catalog.netty.common
     implementation catalog.netty.codec.http
 
     testRuntimeOnly catalog.logback.classic

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

@@ -4,9 +4,7 @@ import io.netty.bootstrap.Bootstrap
 import io.netty.buffer.ByteBuf
 import io.netty.buffer.Unpooled
 import io.netty.channel.Channel
-import io.netty.channel.ChannelHandler
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPipeline
 import io.netty.channel.SimpleChannelInboundHandler
@@ -30,18 +28,13 @@ import io.netty.handler.codec.http.HttpVersion
 import io.netty.handler.ssl.SslContext
 import io.netty.handler.ssl.SslContextBuilder
 import io.netty.handler.stream.ChunkedWriteHandler
-import io.netty.handler.timeout.IdleState
-import io.netty.handler.timeout.IdleStateEvent
-import io.netty.handler.timeout.IdleStateHandler
 import io.netty.util.concurrent.Future
 import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.rbcs.api.CacheValueMetadata
 import net.woggioni.rbcs.client.impl.Parser
 import net.woggioni.rbcs.common.Xml
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.common.debug
 import net.woggioni.rbcs.common.trace
-import java.io.IOException
 import java.net.InetSocketAddress
 import java.net.URI
 import java.nio.file.Files
@@ -51,19 +44,14 @@ import java.security.cert.X509Certificate
 import java.time.Duration
 import java.util.Base64
 import java.util.concurrent.CompletableFuture
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
 import java.util.concurrent.atomic.AtomicInteger
-import kotlin.random.Random
 import io.netty.util.concurrent.Future as NettyFuture
 
-class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
-    companion object{
-        private val log = createLogger<RemoteBuildCacheClient>()
-    }
 
+class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
     private val group: NioEventLoopGroup
     private var sslContext: SslContext
+    private val log = contextLogger()
     private val pool: ChannelPool
 
     data class Configuration(
@@ -84,21 +72,11 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
             val exp: Double
         )
 
-        class Connection(
-            val readTimeout: Duration,
-            val writeTimeout: Duration,
-            val idleTimeout: Duration,
-            val readIdleTimeout: Duration,
-            val writeIdleTimeout: Duration
-        )
-
         data class Profile(
             val serverURI: URI,
-            val connection: Connection?,
             val authentication: Authentication?,
             val connectionTimeout: Duration?,
             val maxConnections: Int,
-            val compressionEnabled: Boolean,
             val retryPolicy: RetryPolicy?,
         )
 
@@ -163,50 +141,18 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
             }
 
             override fun channelCreated(ch: Channel) {
-                val connectionId = connectionCount.incrementAndGet()
+                val connectionId = connectionCount.getAndIncrement()
                 log.debug {
-                    "Created connection ${ch.id().asShortText()}, total number of active connections: $connectionId"
+                    "Created connection $connectionId, total number of active connections: $connectionId"
                 }
                 ch.closeFuture().addListener {
                     val activeConnections = connectionCount.decrementAndGet()
                     log.debug {
-                        "Closed connection ${
-                            ch.id().asShortText()
-                        }, total number of active connections: $activeConnections"
+                        "Closed connection $connectionId, total number of active connections: $activeConnections"
                     }
                 }
                 val pipeline: ChannelPipeline = ch.pipeline()
 
-                profile.connection?.also { conn ->
-                    val readTimeout = conn.readTimeout.toMillis()
-                    val writeTimeout = conn.writeTimeout.toMillis()
-                    if (readTimeout > 0 || writeTimeout > 0) {
-                        pipeline.addLast(
-                            IdleStateHandler(
-                                false,
-                                readTimeout,
-                                writeTimeout,
-                                0,
-                                TimeUnit.MILLISECONDS
-                            )
-                        )
-                    }
-                    val readIdleTimeout = conn.readIdleTimeout.toMillis()
-                    val writeIdleTimeout = conn.writeIdleTimeout.toMillis()
-                    val idleTimeout = conn.idleTimeout.toMillis()
-                    if (readIdleTimeout > 0 || writeIdleTimeout > 0 || idleTimeout > 0) {
-                        pipeline.addLast(
-                            IdleStateHandler(
-                                true,
-                                readIdleTimeout,
-                                writeIdleTimeout,
-                                idleTimeout,
-                                TimeUnit.MILLISECONDS
-                            )
-                        )
-                    }
-                }
-
                 // Add SSL handler if needed
                 if ("https".equals(scheme, ignoreCase = true)) {
                     pipeline.addLast("ssl", sslContext.newHandler(ch.alloc(), host, port))
@@ -214,9 +160,7 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
 
                 // HTTP handlers
                 pipeline.addLast("codec", HttpClientCodec())
-                if(profile.compressionEnabled) {
-                    pipeline.addLast("decompressor", HttpContentDecompressor())
-                }
+                pipeline.addLast("decompressor", HttpContentDecompressor())
                 pipeline.addLast("aggregator", HttpObjectAggregator(134217728))
                 pipeline.addLast("chunked", ChunkedWriteHandler())
             }
@@ -262,7 +206,6 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                 retryPolicy.initialDelayMillis.toDouble(),
                 retryPolicy.exp,
                 outcomeHandler,
-                Random.Default,
                 operation
             )
         } else {
@@ -310,13 +253,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
         }
     }
 
-    fun put(key: String, content: ByteArray, metadata: CacheValueMetadata): CompletableFuture<Unit> {
+    fun put(key: String, content: ByteArray): CompletableFuture<Unit> {
         return executeWithRetry {
-            val extraHeaders = sequenceOf(
-                metadata.mimeType?.let { HttpHeaderNames.CONTENT_TYPE to it },
-                metadata.contentDisposition?.let { HttpHeaderNames.CONTENT_DISPOSITION to it }
-            ).filterNotNull()
-            sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content, extraHeaders.asIterable())
+            sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content)
         }.thenApply {
             val status = it.status()
             if (it.status() != HttpResponseStatus.CREATED && it.status() != HttpResponseStatus.OK) {
@@ -325,83 +264,35 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
         }
     }
 
-    private fun sendRequest(
-        uri: URI,
-        method: HttpMethod,
-        body: ByteArray?,
-        extraHeaders: Iterable<Pair<CharSequence, CharSequence>>? = null
-    ): CompletableFuture<FullHttpResponse> {
+    private fun sendRequest(uri: URI, method: HttpMethod, body: ByteArray?): CompletableFuture<FullHttpResponse> {
         val responseFuture = CompletableFuture<FullHttpResponse>()
         // Custom handler for processing responses
-
         pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
-            private val handlers = mutableListOf<ChannelHandler>()
-
-            fun cleanup(channel: Channel, pipeline: ChannelPipeline) {
-                handlers.forEach(pipeline::remove)
-                pool.release(channel)
-            }
-
             override fun operationComplete(channelFuture: Future<Channel>) {
                 if (channelFuture.isSuccess) {
                     val channel = channelFuture.now
                     val pipeline = channel.pipeline()
-                    val timeoutHandler = object : ChannelInboundHandlerAdapter() {
-                        override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
-                            if (evt is IdleStateEvent) {
-                                val te = when (evt.state()) {
-                                    IdleState.READER_IDLE -> TimeoutException(
-                                        "Read timeout",
-                                    )
-
-                                    IdleState.WRITER_IDLE -> TimeoutException("Write timeout")
-
-                                    IdleState.ALL_IDLE -> TimeoutException("Idle timeout")
-                                    null -> throw IllegalStateException("This should never happen")
-                                }
-                                responseFuture.completeExceptionally(te)
-                                ctx.close()
-                            }
-                        }
-                    }
-                    val closeListener = GenericFutureListener<Future<Void>> {
-                        responseFuture.completeExceptionally(IOException("The remote server closed the connection"))
-                        pool.release(channel)
-                    }
-
-                    val responseHandler = object : SimpleChannelInboundHandler<FullHttpResponse>() {
+                    channel.pipeline().addLast("handler", object : SimpleChannelInboundHandler<FullHttpResponse>() {
                         override fun channelRead0(
                             ctx: ChannelHandlerContext,
                             response: FullHttpResponse
                         ) {
-                            channel.closeFuture().removeListener(closeListener)
-                            cleanup(channel, pipeline)
+                            pipeline.removeLast()
+                            pool.release(channel)
                             responseFuture.complete(response)
                         }
 
                         override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                            ctx.newPromise()
                             val ex = when (cause) {
                                 is DecoderException -> cause.cause
                                 else -> cause
                             }
                             responseFuture.completeExceptionally(ex)
                             ctx.close()
-                        }
-
-                        override fun channelInactive(ctx: ChannelHandlerContext) {
+                            pipeline.removeLast()
                             pool.release(channel)
-                            responseFuture.completeExceptionally(IOException("The remote server closed the connection"))
-                            super.channelInactive(ctx)
                         }
-                    }
-                    for (handler in arrayOf(timeoutHandler, responseHandler)) {
-                        handlers.add(handler)
-                    }
-                    pipeline.addLast(timeoutHandler, responseHandler)
-                    channel.closeFuture().addListener(closeListener)
-
-
+                    })
                     // Prepare the HTTP request
                     val request: FullHttpRequest = let {
                         val content: ByteBuf? = body?.takeIf(ByteArray::isNotEmpty)?.let(Unpooled::wrappedBuffer)
@@ -413,19 +304,15 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                         ).apply {
                             headers().apply {
                                 if (content != null) {
+                                    set(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_OCTET_STREAM)
                                     set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes())
                                 }
                                 set(HttpHeaderNames.HOST, profile.serverURI.host)
                                 set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                                if(profile.compressionEnabled) {
-                                    set(
-                                        HttpHeaderNames.ACCEPT_ENCODING,
-                                        HttpHeaderValues.GZIP.toString() + "," + HttpHeaderValues.DEFLATE.toString()
-                                    )
-                                }
-                                extraHeaders?.forEach { (k, v) ->
-                                    add(k, v)
-                                }
+                                set(
+                                    HttpHeaderNames.ACCEPT_ENCODING,
+                                    HttpHeaderValues.GZIP.toString() + "," + HttpHeaderValues.DEFLATE.toString()
+                                )
                                 // Add basic auth if configured
                                 (profile.authentication as? Configuration.Authentication.BasicAuthenticationCredentials)?.let { credentials ->
                                     val auth = "${credentials.username}:${credentials.password}"

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

@@ -12,7 +12,6 @@ import java.security.KeyStore
 import java.security.PrivateKey
 import java.security.cert.X509Certificate
 import java.time.Duration
-import java.time.temporal.ChronoUnit
 
 object Parser {
 
@@ -30,7 +29,6 @@ object Parser {
                         ?: throw ConfigurationException("base-url attribute is required")
                     var authentication: RemoteBuildCacheClient.Configuration.Authentication? = null
                     var retryPolicy: RemoteBuildCacheClient.Configuration.RetryPolicy? = null
-                    var connection : RemoteBuildCacheClient.Configuration.Connection? = null
                     for (gchild in child.asIterable()) {
                         when (gchild.localName) {
                             "tls-client-auth" -> {
@@ -88,26 +86,6 @@ object Parser {
                                     exp.toDouble()
                                 )
                             }
-
-                            "connection" -> {
-                                val writeTimeout = gchild.renderAttribute("write-timeout")
-                                    ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
-                                val readTimeout = gchild.renderAttribute("read-timeout")
-                                    ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
-                                val idleTimeout = gchild.renderAttribute("idle-timeout")
-                                    ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS)
-                                val readIdleTimeout = gchild.renderAttribute("read-idle-timeout")
-                                    ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                                val writeIdleTimeout = gchild.renderAttribute("write-idle-timeout")
-                                    ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                                connection = RemoteBuildCacheClient.Configuration.Connection(
-                                    readTimeout,
-                                    writeTimeout,
-                                    idleTimeout,
-                                    readIdleTimeout,
-                                    writeIdleTimeout,
-                                )
-                            }
                         }
                     }
                     val maxConnections = child.renderAttribute("max-connections")
@@ -115,17 +93,11 @@ object Parser {
                         ?: 50
                     val connectionTimeout = child.renderAttribute("connection-timeout")
                         ?.let(Duration::parse)
-                    val compressionEnabled = child.renderAttribute("enable-compression")
-                        ?.let(String::toBoolean)
-                        ?: true
-
                     profiles[name] = RemoteBuildCacheClient.Configuration.Profile(
                         uri,
-                        connection,
                         authentication,
                         connectionTimeout,
                         maxConnections,
-                        compressionEnabled,
                         retryPolicy
                     )
                 }

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

@@ -3,8 +3,6 @@ package net.woggioni.rbcs.client
 import io.netty.util.concurrent.EventExecutorGroup
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.TimeUnit
-import kotlin.math.pow
-import kotlin.random.Random
 
 sealed class OperationOutcome<T> {
     class Success<T>(val result: T) : OperationOutcome<T>()
@@ -26,10 +24,8 @@ fun <T> executeWithRetry(
     initialDelay: Double,
     exp: Double,
     outcomeHandler: OutcomeHandler<T>,
-    randomizer : Random?,
     cb: () -> CompletableFuture<T>
 ): CompletableFuture<T> {
-
     val finalResult = cb()
     var future = finalResult
     var shortCircuit = false
@@ -50,7 +46,7 @@ fun <T> executeWithRetry(
                     is OutcomeHandlerResult.Retry -> {
                         val res = CompletableFuture<T>()
                         val delay = run {
-                            val scheduledDelay = (initialDelay * exp.pow(i.toDouble()) * (1.0 + (randomizer?.nextDouble(-0.5, 0.5) ?: 0.0))).toLong()
+                            val scheduledDelay = (initialDelay * Math.pow(exp, i.toDouble())).toLong()
                             outcomeHandlerResult.suggestedDelayMillis?.coerceAtMost(scheduledDelay) ?: scheduledDelay
                         }
                         eventExecutorGroup.schedule({

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

@@ -19,22 +19,12 @@
                 <xs:element name="basic-auth" type="rbcs-client:basicAuthType"/>
                 <xs:element name="tls-client-auth" type="rbcs-client:tlsClientAuthType"/>
             </xs:choice>
-            <xs:element name="connection" type="rbcs-client:connectionType" minOccurs="0" />
             <xs:element name="retry-policy" type="rbcs-client:retryType" minOccurs="0"/>
         </xs:sequence>
         <xs:attribute name="name" type="xs:token" use="required"/>
         <xs:attribute name="base-url" type="xs:anyURI" use="required"/>
         <xs:attribute name="max-connections" type="xs:positiveInteger" default="50"/>
         <xs:attribute name="connection-timeout" type="xs:duration"/>
-        <xs:attribute name="enable-compression" type="xs:boolean" default="true"/>
-    </xs:complexType>
-
-    <xs:complexType name="connectionType">
-        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT0S"/>
-        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT0S"/>
-        <xs:attribute name="idle-timeout" type="xs:duration" use="optional" default="PT30S"/>
-        <xs:attribute name="read-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
-        <xs:attribute name="write-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
     </xs:complexType>
 
     <xs:complexType name="noAuthType"/>

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

@@ -89,7 +89,7 @@ class RetryTest {
         val random = Random(testArgs.seed)
 
         val future =
-            executeWithRetry(executor, testArgs.maxAttempt, testArgs.initialDelay, testArgs.exp, outcomeHandler, null) {
+            executeWithRetry(executor, testArgs.maxAttempt, testArgs.initialDelay, testArgs.exp, outcomeHandler) {
                 val now = System.nanoTime()
                 val result = CompletableFuture<Int>()
                 executor.submit {
@@ -129,7 +129,7 @@ class RetryTest {
                     previousAttempt.first + testArgs.initialDelay * Math.pow(testArgs.exp, index.toDouble()) * 1e6
                 val actualTimestamp = timestamp
                 val err = Math.abs(expectedTimestamp - actualTimestamp) / expectedTimestamp
-                Assertions.assertTrue(err < 1e-2)
+                Assertions.assertTrue(err < 1e-3)
             }
             if (index == attempts.size - 1 && index < testArgs.maxAttempt - 1) {
                 /*

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

@@ -5,7 +5,6 @@ module net.woggioni.rbcs.common {
     requires kotlin.stdlib;
     requires net.woggioni.jwo;
     requires io.netty.buffer;
-    requires io.netty.transport;
 
     provides java.net.spi.URLStreamHandlerProvider with net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory;
     exports net.woggioni.rbcs.common;

rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/BB.kt

@@ -1,15 +0,0 @@
-package net.woggioni.rbcs.common
-
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.ByteBufAllocator
-import io.netty.buffer.CompositeByteBuf
-
-fun extractChunk(buf: CompositeByteBuf, alloc: ByteBufAllocator): ByteBuf {
-    val chunk = alloc.compositeBuffer()
-    for (component in buf.decompose(0, buf.readableBytes())) {
-        chunk.addComponent(true, component.retain())
-    }
-    buf.removeComponents(0, buf.numComponents())
-    buf.clear()
-    return chunk
-}

rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Logging.kt

@@ -1,173 +1,90 @@
 package net.woggioni.rbcs.common
 
-import io.netty.channel.Channel
-import io.netty.channel.ChannelHandlerContext
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import org.slf4j.MDC
 import org.slf4j.event.Level
-import org.slf4j.spi.LoggingEventBuilder
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.logging.LogManager
 
 inline fun <reified T> T.contextLogger() = LoggerFactory.getLogger(T::class.java)
-inline fun <reified T> createLogger() = LoggerFactory.getLogger(T::class.java)
 
-inline fun Logger.traceParam(messageBuilder: () -> Pair<String, Array<Any>>) {
-    if (isTraceEnabled) {
+inline fun Logger.traceParam(messageBuilder : () -> Pair<String, Array<Any>>) {
+    if(isTraceEnabled) {
         val (format, params) = messageBuilder()
         trace(format, params)
     }
 }
 
-inline fun Logger.debugParam(messageBuilder: () -> Pair<String, Array<Any>>) {
-    if (isDebugEnabled) {
+inline fun Logger.debugParam(messageBuilder : () -> Pair<String, Array<Any>>) {
+    if(isDebugEnabled) {
         val (format, params) = messageBuilder()
         info(format, params)
     }
 }
 
-inline fun Logger.infoParam(messageBuilder: () -> Pair<String, Array<Any>>) {
-    if (isInfoEnabled) {
+inline fun Logger.infoParam(messageBuilder : () -> Pair<String, Array<Any>>) {
+    if(isInfoEnabled) {
         val (format, params) = messageBuilder()
         info(format, params)
     }
 }
 
-inline fun Logger.warnParam(messageBuilder: () -> Pair<String, Array<Any>>) {
-    if (isWarnEnabled) {
+inline fun Logger.warnParam(messageBuilder : () -> Pair<String, Array<Any>>) {
+    if(isWarnEnabled) {
         val (format, params) = messageBuilder()
         warn(format, params)
     }
 }
 
-inline fun Logger.errorParam(messageBuilder: () -> Pair<String, Array<Any>>) {
-    if (isErrorEnabled) {
+inline fun Logger.errorParam(messageBuilder : () -> Pair<String, Array<Any>>) {
+    if(isErrorEnabled) {
         val (format, params) = messageBuilder()
         error(format, params)
     }
 }
 
 
-inline fun log(
-    log: Logger,
-    filter: Logger.() -> Boolean,
-    loggerMethod: Logger.(String) -> Unit, messageBuilder: () -> String
-) {
-    if (log.filter()) {
+inline fun log(log : Logger,
+               filter : Logger.() -> Boolean,
+               loggerMethod : Logger.(String) -> Unit, messageBuilder : () -> String) {
+    if(log.filter()) {
         log.loggerMethod(messageBuilder())
     }
 }
 
-fun withMDC(params: Array<Pair<String, String>>, cb: () -> Unit) {
-    object : AutoCloseable {
-        override fun close() {
-            for ((key, _) in params) MDC.remove(key)
-        }
-    }.use {
-        for ((key, value) in params) MDC.put(key, value)
-        cb()
-    }
-}
-
-inline fun Logger.log(level: Level, channel: Channel, crossinline messageBuilder: (LoggingEventBuilder) -> Unit ) {
-    if (isEnabledForLevel(level)) {
-        val params = arrayOf<Pair<String, String>>(
-            "channel-id-short" to channel.id().asShortText(),
-            "channel-id-long" to channel.id().asLongText(),
-            "remote-address" to channel.remoteAddress().toString(),
-            "local-address" to channel.localAddress().toString(),
-        )
-        withMDC(params) {
-            val builder = makeLoggingEventBuilder(level)
-//            for ((key, value) in params) {
-//                builder.addKeyValue(key, value)
-//            }
-            messageBuilder(builder)
-            builder.log()
-        }
-    }
-}
-inline fun Logger.log(level: Level, channel: Channel, crossinline messageBuilder: () -> String) {
-    log(level, channel) { builder ->
-        builder.setMessage(messageBuilder())
-    }
-}
-
-inline fun Logger.trace(ch: Channel, crossinline messageBuilder: () -> String) {
-    log(Level.TRACE, ch, messageBuilder)
-}
-
-inline fun Logger.debug(ch: Channel, crossinline messageBuilder: () -> String) {
-    log(Level.DEBUG, ch, messageBuilder)
-}
-
-inline fun Logger.info(ch: Channel, crossinline messageBuilder: () -> String) {
-    log(Level.INFO, ch, messageBuilder)
-}
-
-inline fun Logger.warn(ch: Channel, crossinline messageBuilder: () -> String) {
-    log(Level.WARN, ch, messageBuilder)
-}
-
-inline fun Logger.error(ch: Channel, crossinline messageBuilder: () -> String) {
-    log(Level.ERROR, ch, messageBuilder)
-}
-
-inline fun Logger.trace(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
-    log(Level.TRACE, ctx.channel(), messageBuilder)
-}
-
-inline fun Logger.debug(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
-    log(Level.DEBUG, ctx.channel(), messageBuilder)
-}
-
-inline fun Logger.info(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
-    log(Level.INFO, ctx.channel(), messageBuilder)
-}
-
-inline fun Logger.warn(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
-    log(Level.WARN, ctx.channel(), messageBuilder)
-}
-
-inline fun Logger.error(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
-    log(Level.ERROR, ctx.channel(), messageBuilder)
-}
-
-
-inline fun Logger.log(level: Level, messageBuilder: () -> String) {
-    if (isEnabledForLevel(level)) {
+inline fun Logger.log(level : Level, messageBuilder : () -> String) {
+    if(isEnabledForLevel(level)) {
         makeLoggingEventBuilder(level).log(messageBuilder())
     }
 }
 
-inline fun Logger.trace(messageBuilder: () -> String) {
-    if (isTraceEnabled) {
+inline fun Logger.trace(messageBuilder : () -> String) {
+    if(isTraceEnabled) {
         trace(messageBuilder())
     }
 }
 
-inline fun Logger.debug(messageBuilder: () -> String) {
-    if (isDebugEnabled) {
+inline fun Logger.debug(messageBuilder : () -> String) {
+    if(isDebugEnabled) {
         debug(messageBuilder())
     }
 }
 
-inline fun Logger.info(messageBuilder: () -> String) {
-    if (isInfoEnabled) {
+inline fun Logger.info(messageBuilder : () -> String) {
+    if(isInfoEnabled) {
         info(messageBuilder())
     }
 }
 
-inline fun Logger.warn(messageBuilder: () -> String) {
-    if (isWarnEnabled) {
+inline fun Logger.warn(messageBuilder : () -> String) {
+    if(isWarnEnabled) {
         warn(messageBuilder())
     }
 }
 
-inline fun Logger.error(messageBuilder: () -> String) {
-    if (isErrorEnabled) {
+inline fun Logger.error(messageBuilder : () -> String) {
+    if(isErrorEnabled) {
         error(messageBuilder())
     }
 }
@@ -177,9 +94,9 @@ class LoggingConfig {
 
     init {
         val logManager = LogManager.getLogManager()
-        System.getProperty("log.config.source")?.let withSource@{ source ->
+        System.getProperty("log.config.source")?.let withSource@ { source ->
             val urls = LoggingConfig::class.java.classLoader.getResources(source)
-            while (urls.hasMoreElements()) {
+            while(urls.hasMoreElements()) {
                 val url = urls.nextElement()
                 url.openStream().use { inputStream ->
                     logManager.readConfiguration(inputStream)

rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/PasswordSecurity.kt

@@ -7,18 +7,7 @@ import javax.crypto.SecretKeyFactory
 import javax.crypto.spec.PBEKeySpec
 
 object PasswordSecurity {
-
-    enum class Algorithm(
-        val codeName : String,
-        val keyLength : Int,
-        val iterations : Int) {
-        PBEWithHmacSHA512_224AndAES_256("PBEWithHmacSHA512/224AndAES_256", 64, 1),
-        PBEWithHmacSHA1AndAES_256("PBEWithHmacSHA1AndAES_256",64, 1),
-        PBEWithHmacSHA384AndAES_128("PBEWithHmacSHA384AndAES_128", 64,1),
-        PBEWithHmacSHA384AndAES_256("PBEWithHmacSHA384AndAES_256",64,1),
-        PBKDF2WithHmacSHA512("PBKDF2WithHmacSHA512",512, 1),
-        PBKDF2WithHmacSHA384("PBKDF2WithHmacSHA384",384, 1);
-    }
+    private const val KEY_LENGTH = 256
 
     private fun concat(arr1: ByteArray, arr2: ByteArray): ByteArray {
         val result = ByteArray(arr1.size + arr2.size)
@@ -34,22 +23,22 @@ object PasswordSecurity {
         return result
     }
 
-    fun hashPassword(password : String, salt : String? = null, algorithm : Algorithm = Algorithm.PBKDF2WithHmacSHA512) : String {
+    fun hashPassword(password : String, salt : String? = null) : String {
         val actualSalt = salt?.let(Base64.getDecoder()::decode) ?: SecureRandom().run {
             val result = ByteArray(16)
             nextBytes(result)
             result
         }
-        val spec: KeySpec = PBEKeySpec(password.toCharArray(), actualSalt, algorithm.iterations, algorithm.keyLength)
-        val factory = SecretKeyFactory.getInstance(algorithm.codeName)
+        val spec: KeySpec = PBEKeySpec(password.toCharArray(), actualSalt, 10, KEY_LENGTH)
+        val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1")
         val hash = factory.generateSecret(spec).encoded
         return String(Base64.getEncoder().encode(concat(hash, actualSalt)))
     }
 
-    fun decodePasswordHash(encodedPasswordHash : String, algorithm: Algorithm = Algorithm.PBKDF2WithHmacSHA512) : Pair<ByteArray, ByteArray> {
-        val decoded = Base64.getDecoder().decode(encodedPasswordHash)
-        val hash = ByteArray(algorithm.keyLength / 8)
-        val salt = ByteArray(decoded.size - algorithm.keyLength / 8)
+    fun decodePasswordHash(passwordHash : String) : Pair<ByteArray, ByteArray> {
+        val decoded = Base64.getDecoder().decode(passwordHash)
+        val hash = ByteArray(KEY_LENGTH / 8)
+        val salt = ByteArray(decoded.size - KEY_LENGTH / 8)
         System.arraycopy(decoded, 0, hash, 0, hash.size)
         System.arraycopy(decoded, hash.size, salt, 0, salt.size)
         return hash to salt

rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/RBCS.kt

@@ -12,27 +12,9 @@ object RBCS {
     const val RBCS_PREFIX: String = "rbcs"
     const val XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"
 
-    fun ByteArray.toInt(index : Int = 0) : Long {
-        if(index + 4 > size) throw IllegalArgumentException("Not enough bytes to decode a 32 bits integer")
-        var value : Long = 0
-        for (b in index until index + 4) {
-            value = (value shl 8) + (get(b).toInt() and 0xFF)
-        }
-        return value
-    }
-
-    fun ByteArray.toLong(index : Int = 0) : Long {
-        if(index + 8 > size) throw IllegalArgumentException("Not enough bytes to decode a 64 bits long integer")
-        var value : Long = 0
-        for (b in index until index + 8) {
-            value = (value shl 8) + (get(b).toInt() and 0xFF)
-        }
-        return value
-    }
-
     fun digest(
         data: ByteArray,
-        md: MessageDigest
+        md: MessageDigest = MessageDigest.getInstance("MD5")
     ): ByteArray {
         md.update(data)
         return md.digest()
@@ -40,22 +22,8 @@ object RBCS {
 
     fun digestString(
         data: ByteArray,
-        md: MessageDigest
+        md: MessageDigest = MessageDigest.getInstance("MD5")
     ): String {
         return JWO.bytesToHex(digest(data, md))
     }
-
-    fun processCacheKey(key: String, digestAlgorithm: String?) = digestAlgorithm
-        ?.let(MessageDigest::getInstance)
-        ?.let { md ->
-            digest(key.toByteArray(), md)
-        } ?: key.toByteArray(Charsets.UTF_8)
-
-    fun Long.toIntOrNull(): Int? {
-        return if (this >= Int.MIN_VALUE && this <= Int.MAX_VALUE) {
-            toInt()
-        } else {
-            null
-        }
-    }
 }

rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Xml.kt

@@ -1,6 +1,7 @@
 package net.woggioni.rbcs.common
 
 import net.woggioni.jwo.JWO
+import org.slf4j.LoggerFactory
 import org.slf4j.event.Level
 import org.w3c.dom.Document
 import org.w3c.dom.Element
@@ -78,7 +79,7 @@ class Xml(val doc: Document, val element: Element) {
     class ErrorHandler(private val fileURL: URL) : ErrHandler {
 
         companion object {
-            private val log = createLogger<ErrorHandler>()
+            private val log = LoggerFactory.getLogger(ErrorHandler::class.java)
         }
 
          override fun warning(ex: SAXParseException)= err(ex, Level.WARN)

rbcs-common/src/test/kotlin/net/woggioni/rbcs/common/PasswordHashingTest.kt

@@ -1,38 +0,0 @@
-package net.woggioni.rbcs.common
-
-import net.woggioni.rbcs.common.PasswordSecurity.decodePasswordHash
-import net.woggioni.rbcs.common.PasswordSecurity.hashPassword
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.EnumSource
-import java.security.Provider
-import java.security.Security
-import java.util.Base64
-
-
-class PasswordHashingTest {
-
-    @EnumSource(PasswordSecurity.Algorithm::class)
-    @ParameterizedTest
-    fun test(algo: PasswordSecurity.Algorithm) {
-        val password = "password"
-        val encoded = hashPassword(password, algorithm = algo)
-        val (_, salt) = decodePasswordHash(encoded, algo)
-        Assertions.assertEquals(encoded,
-            hashPassword(password, salt = salt.let(Base64.getEncoder()::encodeToString), algorithm = algo)
-        )
-    }
-
-    @Test
-    fun listAvailableAlgorithms() {
-        Security.getProviders().asSequence()
-            .flatMap { provider: Provider -> provider.services.asSequence() }
-            .filter { service: Provider.Service -> "SecretKeyFactory" == service.type }
-            .map(Provider.Service::getAlgorithm)
-            .forEach {
-                println(it)
-            }
-
-    }
-}

rbcs-server-memcache/README.md

@@ -1,46 +0,0 @@
-# RBCS Memcache plugins
-
-This plugins allows RBCs to store and retrieve data from a memcache cluster.
-The memcache server selection is simply based on the hash of the key, 
-deflate compression is also supported and performed by the RBCS server
-
-## Quickstart
-The plugin can be built with
-```bash
-./gradlew rbcs-server-memcache:bundle
-```
-which creates a `.tar` archive in the `build/distributions` folder. 
-The archive is supposed to be extracted inside the RBCS server's `plugins` directory.
-
-## Configuration
-
-The plugin can be enabled setting the `xs:type` attribute of the `cache` element
-to `memcacheCacheType`.
-
-The plugins currently supports the following configuration attributes:
-- `max-age`: the amount of time cache entries will be retained on memcache
-- `digest`: digest algorithm to use on the key before submission 
-  to memcache (optional, no digest is applied if omitted)
-- `compression`: compression algorithm to apply to cache values before, 
-  currently only `deflate` is supported (optionla, if omitted compression is disabled)
-- `compression-level`: compression level to use, deflate supports compression levels from 1 to 9, 
-  where 1 is for fast compression at the expense of speed (optional, 6 is used if omitted)
-```xml
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<rbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:rbcs="urn:net.woggioni.rbcs.server"
-             xmlns:rbcs-memcache="urn:net.woggioni.rbcs.server.memcache"
-             xs:schemaLocation="urn:net.woggioni.rbcs.server.memcache jpms://net.woggioni.rbcs.server.memcache/net/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd"
->
-    ...
-    <cache xs:type="rbcs-memcache:memcacheCacheType" 
-           max-age="P7D"
-           digest="SHA-256"
-           compression-mode="deflate"
-           compression-level="6"
-           chunk-size="0x10000">
-        <server host="127.0.0.1" port="11211" max-connections="256"/>
-        <server host="127.0.0.1" port="11212" max-connections="256"/>
-    </cache>
-    ...
-```

rbcs-server-memcache/build.gradle

@@ -34,7 +34,6 @@ dependencies {
     implementation catalog.jwo
     implementation catalog.slf4j.api
     implementation catalog.netty.common
-    implementation catalog.netty.handler
     implementation catalog.netty.codec.memcache
 
     bundle catalog.netty.codec.memcache

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

@@ -11,7 +11,6 @@ module net.woggioni.rbcs.server.memcache {
     requires io.netty.codec.memcache;
     requires io.netty.common;
     requires io.netty.buffer;
-    requires io.netty.handler;
     requires org.slf4j;
 
     provides CacheProvider with net.woggioni.rbcs.server.memcache.MemcacheCacheProvider;

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

@@ -0,0 +1,23 @@
+package net.woggioni.rbcs.server.memcache
+
+import io.netty.buffer.ByteBuf
+import net.woggioni.rbcs.api.Cache
+import net.woggioni.rbcs.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()
+    }
+}

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

@@ -1,31 +1,23 @@
 package net.woggioni.rbcs.server.memcache
 
-import io.netty.channel.ChannelFactory
-import io.netty.channel.ChannelHandler
-import io.netty.channel.EventLoopGroup
-import io.netty.channel.pool.FixedChannelPool
-import io.netty.channel.socket.DatagramChannel
-import io.netty.channel.socket.SocketChannel
-import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.common.HostAndPort
-import net.woggioni.rbcs.server.memcache.client.MemcacheClient
 import java.time.Duration
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.atomic.AtomicReference
 
 data class MemcacheCacheConfiguration(
     val servers: List<Server>,
     val maxAge: Duration = Duration.ofDays(1),
+    val maxSize: Int = 0x100000,
     val digestAlgorithm: String? = null,
     val compressionMode: CompressionMode? = null,
-    val compressionLevel: Int,
-    val chunkSize: Int
 ) : Configuration.Cache {
 
     enum class CompressionMode {
+        /**
+         * Gzip mode
+         */
+        GZIP,
+
         /**
          * Deflate mode
          */
@@ -33,59 +25,13 @@ data class MemcacheCacheConfiguration(
     }
 
     data class Server(
-        val endpoint: HostAndPort,
-        val connectionTimeoutMillis: Int?,
-        val maxConnections: Int
+        val endpoint : HostAndPort,
+        val connectionTimeoutMillis : Int?,
+        val maxConnections : Int
     )
 
-    override fun materialize() = object : CacheHandlerFactory {
 
-        private val connectionPoolMap = ConcurrentHashMap<HostAndPort, FixedChannelPool>()
-
-        override fun newHandler(
-            eventLoop: EventLoopGroup,
-            socketChannelFactory: ChannelFactory<SocketChannel>,
-            datagramChannelFactory: ChannelFactory<DatagramChannel>
-        ): ChannelHandler {
-            return MemcacheCacheHandler(
-                MemcacheClient(
-                    this@MemcacheCacheConfiguration.servers,
-                    chunkSize,
-                    eventLoop,
-                    socketChannelFactory,
-                    connectionPoolMap
-                ),
-                digestAlgorithm,
-                compressionMode != null,
-                compressionLevel,
-                chunkSize,
-                maxAge
-            )
-        }
-
-        override fun asyncClose() = object : CompletableFuture<Void>() {
-            init {
-                val failure = AtomicReference<Throwable>(null)
-                val pools = connectionPoolMap.values.toList()
-                val npools = pools.size
-                val finished = AtomicInteger(0)
-                pools.forEach { pool ->
-                    pool.closeAsync().addListener {
-                        if (!it.isSuccess) {
-                            failure.compareAndSet(null, it.cause())
-                        }
-                        if(finished.incrementAndGet() == npools) {
-                            when(val ex = failure.get()) {
-                                null -> complete(null)
-                                else -> completeExceptionally(ex)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-    }
+    override fun materialize() = MemcacheCache(this)
 
     override fun getNamespaceURI() = "urn:net.woggioni.rbcs.server.memcache"
 

rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheHandler.kt

@@ -1,409 +0,0 @@
-package net.woggioni.rbcs.server.memcache
-
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.ByteBufAllocator
-import io.netty.buffer.CompositeByteBuf
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
-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.binary.BinaryMemcacheOpcodes
-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 net.woggioni.rbcs.api.CacheValueMetadata
-import net.woggioni.rbcs.api.exception.ContentTooLargeException
-import net.woggioni.rbcs.api.message.CacheMessage
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-import net.woggioni.rbcs.common.ByteBufInputStream
-import net.woggioni.rbcs.common.ByteBufOutputStream
-import net.woggioni.rbcs.common.RBCS.processCacheKey
-import net.woggioni.rbcs.common.RBCS.toIntOrNull
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
-import net.woggioni.rbcs.common.extractChunk
-import net.woggioni.rbcs.common.trace
-import net.woggioni.rbcs.server.memcache.client.MemcacheClient
-import net.woggioni.rbcs.server.memcache.client.MemcacheRequestController
-import net.woggioni.rbcs.server.memcache.client.MemcacheResponseHandler
-import java.io.ByteArrayOutputStream
-import java.io.ObjectInputStream
-import java.io.ObjectOutputStream
-import java.nio.ByteBuffer
-import java.nio.channels.Channels
-import java.nio.channels.FileChannel
-import java.nio.channels.ReadableByteChannel
-import java.nio.file.Files
-import java.nio.file.StandardOpenOption
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.CompletableFuture
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.InflaterOutputStream
-import io.netty.channel.Channel as NettyChannel
-
-class MemcacheCacheHandler(
-    private val client: MemcacheClient,
-    private val digestAlgorithm: String?,
-    private val compressionEnabled: Boolean,
-    private val compressionLevel: Int,
-    private val chunkSize: Int,
-    private val maxAge: Duration
-) : SimpleChannelInboundHandler<CacheMessage>() {
-    companion object {
-        private val log = createLogger<MemcacheCacheHandler>()
-
-        private fun encodeExpiry(expiry: Duration): Int {
-            val expirySeconds = expiry.toSeconds()
-            return expirySeconds.toInt().takeIf { it.toLong() == expirySeconds }
-                ?: Instant.ofEpochSecond(expirySeconds).epochSecond.toInt()
-        }
-    }
-
-    private inner class InProgressGetRequest(
-        private val key: String,
-        private val ctx: ChannelHandlerContext
-    ) {
-        private val acc = ctx.alloc().compositeBuffer()
-        private val chunk = ctx.alloc().compositeBuffer()
-        private val outputStream = ByteBufOutputStream(chunk).let {
-            if (compressionEnabled) {
-                InflaterOutputStream(it)
-            } else {
-                it
-            }
-        }
-        private var responseSent = false
-        private var metadataSize: Int? = null
-
-        fun write(buf: ByteBuf) {
-            acc.addComponent(true, buf.retain())
-            if (metadataSize == null && acc.readableBytes() >= Int.SIZE_BYTES) {
-                metadataSize = acc.readInt()
-            }
-            metadataSize
-                ?.takeIf { !responseSent }
-                ?.takeIf { acc.readableBytes() >= it }
-                ?.let { mSize ->
-                    val metadata = ObjectInputStream(ByteBufInputStream(acc)).use {
-                        acc.retain()
-                        it.readObject() as CacheValueMetadata
-                    }
-                    ctx.writeAndFlush(CacheValueFoundResponse(key, metadata))
-                    responseSent = true
-                    acc.readerIndex(Int.SIZE_BYTES + mSize)
-                }
-            if (responseSent) {
-                acc.readBytes(outputStream, acc.readableBytes())
-                if(acc.readableBytes() >= chunkSize) {
-                    flush(false)
-                }
-            }
-        }
-
-        private fun flush(last : Boolean) {
-            val toSend = extractChunk(chunk, ctx.alloc())
-            val msg = if(last) {
-                log.trace(ctx) {
-                    "Sending last chunk to client on channel ${ctx.channel().id().asShortText()}"
-                }
-                LastCacheContent(toSend)
-            } else {
-                log.trace(ctx) {
-                    "Sending chunk to client on channel ${ctx.channel().id().asShortText()}"
-                }
-                CacheContent(toSend)
-            }
-            ctx.writeAndFlush(msg)
-        }
-
-        fun commit() {
-            acc.release()
-            chunk.retain()
-            outputStream.close()
-            flush(true)
-            chunk.release()
-        }
-
-        fun rollback() {
-            acc.release()
-            outputStream.close()
-        }
-    }
-
-    private inner class InProgressPutRequest(
-        private val ch : NettyChannel,
-        metadata : CacheValueMetadata,
-        val digest : ByteBuf,
-        val requestController: CompletableFuture<MemcacheRequestController>,
-        private val alloc: ByteBufAllocator
-    ) {
-        private var totalSize = 0
-        private var tmpFile : FileChannel? = null
-        private val accumulator = alloc.compositeBuffer()
-        private val stream = ByteBufOutputStream(accumulator).let {
-            if (compressionEnabled) {
-                DeflaterOutputStream(it, Deflater(compressionLevel))
-            } else {
-                it
-            }
-        }
-
-        init {
-            ByteArrayOutputStream().let { baos ->
-                ObjectOutputStream(baos).use {
-                    it.writeObject(metadata)
-                }
-                val serializedBytes = baos.toByteArray()
-                accumulator.writeInt(serializedBytes.size)
-                accumulator.writeBytes(serializedBytes)
-            }
-        }
-
-        fun write(buf: ByteBuf) {
-            totalSize += buf.readableBytes()
-            buf.readBytes(stream, buf.readableBytes())
-            tmpFile?.let {
-                flushToDisk(it, accumulator)
-            }
-            if(accumulator.readableBytes() > 0x100000) {
-                log.debug(ch) {
-                    "Entry is too big, buffering it into a file"
-                }
-                val opts = arrayOf(
-                    StandardOpenOption.DELETE_ON_CLOSE,
-                    StandardOpenOption.READ,
-                    StandardOpenOption.WRITE,
-                    StandardOpenOption.TRUNCATE_EXISTING
-                )
-                FileChannel.open(Files.createTempFile("rbcs-memcache", ".tmp"), *opts).let { fc ->
-                    tmpFile = fc
-                    flushToDisk(fc, accumulator)
-                }
-            }
-        }
-
-        private fun flushToDisk(fc : FileChannel, buf : CompositeByteBuf) {
-            val chunk = extractChunk(buf, alloc)
-            fc.write(chunk.nioBuffer())
-            chunk.release()
-        }
-
-        fun commit() : Pair<Int, ReadableByteChannel> {
-            digest.release()
-            accumulator.retain()
-            stream.close()
-            val fileChannel = tmpFile
-            return if(fileChannel != null) {
-                flushToDisk(fileChannel, accumulator)
-                accumulator.release()
-                fileChannel.position(0)
-                val fileSize = fileChannel.size().toIntOrNull() ?: let {
-                    fileChannel.close()
-                    throw ContentTooLargeException("Request body is too large", null)
-                }
-                fileSize to fileChannel
-            } else {
-                accumulator.readableBytes() to Channels.newChannel(ByteBufInputStream(accumulator))
-            }
-        }
-
-        fun rollback() {
-            stream.close()
-            digest.release()
-            tmpFile?.close()
-        }
-    }
-
-    private var inProgressPutRequest: InProgressPutRequest? = null
-    private var inProgressGetRequest: InProgressGetRequest? = null
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
-        when (msg) {
-            is CacheGetRequest -> handleGetRequest(ctx, msg)
-            is CachePutRequest -> handlePutRequest(ctx, msg)
-            is LastCacheContent -> handleLastCacheContent(ctx, msg)
-            is CacheContent -> handleCacheContent(ctx, msg)
-            else -> ctx.fireChannelRead(msg)
-        }
-    }
-
-    private fun handleGetRequest(ctx: ChannelHandlerContext, msg: CacheGetRequest) {
-        log.debug(ctx) {
-            "Fetching ${msg.key} from memcache"
-        }
-        val key = ctx.alloc().buffer().also {
-            it.writeBytes(processCacheKey(msg.key, digestAlgorithm))
-        }
-        val responseHandler = object : MemcacheResponseHandler {
-            override fun responseReceived(response: BinaryMemcacheResponse) {
-                val status = response.status()
-                when (status) {
-                    BinaryMemcacheResponseStatus.SUCCESS -> {
-                        log.debug(ctx) {
-                            "Cache hit for key ${msg.key} on memcache"
-                        }
-                        inProgressGetRequest = InProgressGetRequest(msg.key, ctx)
-                    }
-
-                    BinaryMemcacheResponseStatus.KEY_ENOENT -> {
-                        log.debug(ctx) {
-                            "Cache miss for key ${msg.key} on memcache"
-                        }
-                        ctx.writeAndFlush(CacheValueNotFoundResponse())
-                    }
-                }
-            }
-
-            override fun contentReceived(content: MemcacheContent) {
-                log.trace(ctx) {
-                    "${if(content is LastMemcacheContent) "Last chunk" else "Chunk"} of ${content.content().readableBytes()} bytes received from memcache for key ${msg.key}"
-                }
-                inProgressGetRequest?.write(content.content())
-                if (content is LastMemcacheContent) {
-                    inProgressGetRequest?.commit()
-                }
-            }
-
-            override fun exceptionCaught(ex: Throwable) {
-                inProgressGetRequest?.let {
-                    inProgressGetRequest = null
-                    it.rollback()
-                }
-                this@MemcacheCacheHandler.exceptionCaught(ctx, ex)
-            }
-        }
-        client.sendRequest(key.retainedDuplicate(), responseHandler).thenAccept { requestHandle ->
-            log.trace(ctx) {
-                "Sending GET request for key ${msg.key} to memcache"
-            }
-            val request = DefaultBinaryMemcacheRequest(key).apply {
-                setOpcode(BinaryMemcacheOpcodes.GET)
-            }
-            requestHandle.sendRequest(request)
-        }
-    }
-
-    private fun handlePutRequest(ctx: ChannelHandlerContext, msg: CachePutRequest) {
-        val key = ctx.alloc().buffer().also {
-            it.writeBytes(processCacheKey(msg.key, digestAlgorithm))
-        }
-        val responseHandler = object : MemcacheResponseHandler {
-            override fun responseReceived(response: BinaryMemcacheResponse) {
-                val status = response.status()
-                when (status) {
-                    BinaryMemcacheResponseStatus.SUCCESS -> {
-                        log.debug(ctx) {
-                            "Inserted key ${msg.key} into memcache"
-                        }
-                        ctx.writeAndFlush(CachePutResponse(msg.key))
-                    }
-                    else -> this@MemcacheCacheHandler.exceptionCaught(ctx, MemcacheException(status))
-                }
-            }
-
-            override fun contentReceived(content: MemcacheContent) {}
-
-            override fun exceptionCaught(ex: Throwable) {
-                this@MemcacheCacheHandler.exceptionCaught(ctx, ex)
-            }
-        }
-
-        val requestController = client.sendRequest(key.retainedDuplicate(), responseHandler).whenComplete { _, ex ->
-            ex?.let {
-                this@MemcacheCacheHandler.exceptionCaught(ctx, ex)
-            }
-        }
-        inProgressPutRequest = InProgressPutRequest(ctx.channel(), msg.metadata, key, requestController, ctx.alloc())
-    }
-
-    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest?.let { request ->
-            log.trace(ctx) {
-                "Received chunk of ${msg.content().readableBytes()} bytes for memcache"
-            }
-            request.write(msg.content())
-        }
-    }
-
-    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
-        inProgressPutRequest?.let { request ->
-            inProgressPutRequest = null
-            log.trace(ctx) {
-                "Received last chunk of ${msg.content().readableBytes()} bytes for memcache"
-            }
-            request.write(msg.content())
-            val key = request.digest.retainedDuplicate()
-            val (payloadSize, payloadSource) = request.commit()
-            val extras = ctx.alloc().buffer(8, 8)
-            extras.writeInt(0)
-            extras.writeInt(encodeExpiry(maxAge))
-            val totalBodyLength = request.digest.readableBytes() + extras.readableBytes() + payloadSize
-            request.requestController.whenComplete { requestController, ex ->
-                if(ex == null) {
-                    log.trace(ctx) {
-                        "Sending SET request to memcache"
-                    }
-                    requestController.sendRequest(DefaultBinaryMemcacheRequest().apply {
-                        setOpcode(BinaryMemcacheOpcodes.SET)
-                        setKey(key)
-                        setExtras(extras)
-                        setTotalBodyLength(totalBodyLength)
-                    })
-                    log.trace(ctx) {
-                        "Sending request payload to memcache"
-                    }
-                    payloadSource.use { source ->
-                        val bb = ByteBuffer.allocate(chunkSize)
-                        while (true) {
-                            val read = source.read(bb)
-                            bb.limit()
-                            if(read >= 0 && bb.position() < chunkSize && bb.hasRemaining()) {
-                                continue
-                            }
-                            val chunk = ctx.alloc().buffer(chunkSize)
-                            bb.flip()
-                            chunk.writeBytes(bb)
-                            bb.clear()
-                            log.trace(ctx) {
-                                "Sending ${chunk.readableBytes()} bytes chunk to memcache"
-                            }
-                            if(read < 0) {
-                                requestController.sendContent(DefaultLastMemcacheContent(chunk))
-                                break
-                            } else {
-                                requestController.sendContent(DefaultMemcacheContent(chunk))
-                            }
-                        }
-                    }
-                } else {
-                    payloadSource.close()
-                }
-            }
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressGetRequest?.let {
-            inProgressGetRequest = null
-            it.rollback()
-        }
-        inProgressPutRequest?.let {
-            inProgressPutRequest = null
-            it.requestController.thenAccept { controller ->
-                controller.exceptionCaught(cause)
-            }
-            it.rollback()
-        }
-        super.exceptionCaught(ctx, cause)
-    }
-}

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

@@ -2,8 +2,8 @@ package net.woggioni.rbcs.server.memcache
 
 import net.woggioni.rbcs.api.CacheProvider
 import net.woggioni.rbcs.api.exception.ConfigurationException
-import net.woggioni.rbcs.common.HostAndPort
 import net.woggioni.rbcs.common.RBCS
+import net.woggioni.rbcs.common.HostAndPort
 import net.woggioni.rbcs.common.Xml
 import net.woggioni.rbcs.common.Xml.Companion.asIterable
 import net.woggioni.rbcs.common.Xml.Companion.renderAttribute
@@ -28,19 +28,18 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
         val maxAge = el.renderAttribute("max-age")
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
-        val chunkSize = el.renderAttribute("chunk-size")
-            ?.let(Integer::decode)
-            ?: 0x10000
-        val compressionLevel = el.renderAttribute("compression-level")
-            ?.let(Integer::decode)
-            ?: -1
+        val maxSize = el.renderAttribute("max-size")
+            ?.let(String::toInt)
+            ?: 0x100000
         val compressionMode = el.renderAttribute("compression-mode")
             ?.let {
                 when (it) {
+                    "gzip" -> MemcacheCacheConfiguration.CompressionMode.GZIP
                     "deflate" -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
                     else -> MemcacheCacheConfiguration.CompressionMode.DEFLATE
                 }
             }
+            ?: MemcacheCacheConfiguration.CompressionMode.DEFLATE
         val digestAlgorithm = el.renderAttribute("digest")
         for (child in el.asIterable()) {
             when (child.nodeName) {
@@ -61,10 +60,9 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
         return MemcacheCacheConfiguration(
             servers,
             maxAge,
+            maxSize,
             digestAlgorithm,
             compressionMode,
-            compressionLevel,
-            chunkSize
         )
     }
 
@@ -72,6 +70,7 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
         val result = doc.createElement("cache")
         Xml.of(doc, result) {
             attr("xmlns:${xmlNamespacePrefix}", xmlNamespace, namespaceURI = "http://www.w3.org/2000/xmlns/")
+
             attr("xs:type", "${xmlNamespacePrefix}:$xmlType", RBCS.XML_SCHEMA_NAMESPACE_URI)
             for (server in servers) {
                 node("server") {
@@ -84,18 +83,18 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
                 }
             }
             attr("max-age", maxAge.toString())
-            attr("chunk-size", chunkSize.toString())
+            attr("max-size", maxSize.toString())
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)
             }
             compressionMode?.let { compressionMode ->
                 attr(
                     "compression-mode", when (compressionMode) {
+                        MemcacheCacheConfiguration.CompressionMode.GZIP -> "gzip"
                         MemcacheCacheConfiguration.CompressionMode.DEFLATE -> "deflate"
                     }
                 )
             }
-            attr("compression-level", compressionLevel.toString())
         }
         result
     }

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

@@ -3,53 +3,68 @@ package net.woggioni.rbcs.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.ChannelFactory
-import io.netty.channel.ChannelFutureListener
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPipeline
-import io.netty.channel.EventLoopGroup
 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.SocketChannel
-import io.netty.handler.codec.memcache.LastMemcacheContent
-import io.netty.handler.codec.memcache.MemcacheContent
-import io.netty.handler.codec.memcache.MemcacheObject
+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.BinaryMemcacheRequest
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
+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.rbcs.common.ByteBufInputStream
+import net.woggioni.rbcs.common.ByteBufOutputStream
+import net.woggioni.rbcs.common.RBCS.digest
 import net.woggioni.rbcs.common.HostAndPort
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.warn
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.server.memcache.MemcacheCacheConfiguration
-import net.woggioni.rbcs.server.memcache.MemcacheCacheHandler
-import java.io.IOException
+import net.woggioni.rbcs.server.memcache.MemcacheException
+import net.woggioni.jwo.JWO
 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 servers: List<MemcacheCacheConfiguration.Server>,
-    private val chunkSize : Int,
-    private val group: EventLoopGroup,
-    private val channelFactory: ChannelFactory<SocketChannel>,
-    private val connectionPool: ConcurrentHashMap<HostAndPort, FixedChannelPool>
-) : AutoCloseable {
+class MemcacheClient(private val cfg: MemcacheCacheConfiguration) : AutoCloseable {
 
     private companion object {
-        private val log = createLogger<MemcacheCacheHandler>()
+        @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)
-            channelFactory(channelFactory)
+            channel(NioSocketChannel::class.java)
             option(ChannelOption.SO_KEEPALIVE, true)
             remoteAddress(InetSocketAddress(server.endpoint.host, server.endpoint.port))
             server.connectionTimeoutMillis?.let {
@@ -60,33 +75,35 @@ class MemcacheClient(
 
             override fun channelCreated(ch: Channel) {
                 val pipeline: ChannelPipeline = ch.pipeline()
-                pipeline.addLast(BinaryMemcacheClientCodec(chunkSize, true))
+                pipeline.addLast(BinaryMemcacheClientCodec())
+                pipeline.addLast(BinaryMemcacheObjectAggregator(cfg.maxSize))
             }
         }
         return FixedChannelPool(bootstrap, channelPoolHandler, server.maxConnections)
     }
 
-    fun sendRequest(
-        key: ByteBuf,
-        responseHandler: MemcacheResponseHandler
-    ): CompletableFuture<MemcacheRequestController> {
-        val server = if (servers.size > 1) {
-            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()
-        }
-        key.release()
 
-        val response = CompletableFuture<MemcacheRequestController>()
+    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)
@@ -94,108 +111,33 @@ class MemcacheClient(
         pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
             override fun operationComplete(channelFuture: NettyFuture<Channel>) {
                 if (channelFuture.isSuccess) {
-
-                    var requestSent = false
-                    var requestBodySent = false
-                    var requestFinished = false
-                    var responseReceived = false
-                    var responseBodyReceived = false
-                    var responseFinished = false
-                    var requestBodySize = 0
-                    var requestBodyBytesSent = 0
-
-
-
                     val channel = channelFuture.now
-                    var connectionClosedByTheRemoteServer = true
-                    val closeCallback = {
-                        if (connectionClosedByTheRemoteServer) {
-                            val ex = IOException("The memcache server closed the connection")
-                            val completed = response.completeExceptionally(ex)
-                            if(!completed) responseHandler.exceptionCaught(ex)
-                            log.warn {
-                                "RequestSent: $requestSent, RequestBodySent: $requestBodySent, " +
-                                "RequestFinished: $requestFinished, ResponseReceived: $responseReceived, " +
-                                "ResponseBodyReceived: $responseBodyReceived, ResponseFinished: $responseFinished, " +
-                                "RequestBodySize: $requestBodySize, RequestBodyBytesSent: $requestBodyBytesSent"
-                            }
-                        }
-                        pool.release(channel)
-                    }
-                    val closeListener = ChannelFutureListener {
-                        closeCallback()
-                    }
-                    channel.closeFuture().addListener(closeListener)
                     val pipeline = channel.pipeline()
-                    val handler = object : SimpleChannelInboundHandler<MemcacheObject>() {
-
-                        override fun handlerAdded(ctx: ChannelHandlerContext) {
-                            channel.closeFuture().removeListener(closeListener)
-                        }
-
-                        override fun channelRead0(
-                            ctx: ChannelHandlerContext,
-                            msg: MemcacheObject
-                        ) {
-                            when (msg) {
-                                is BinaryMemcacheResponse -> {
-                                    responseHandler.responseReceived(msg)
-                                    responseReceived = true
-                                }
-
-                                is LastMemcacheContent -> {
-                                    responseFinished = true
-                                    responseHandler.contentReceived(msg)
-                                    pipeline.remove(this)
-                                    pool.release(channel)
-                                }
-
-                                is MemcacheContent -> {
-                                    responseBodyReceived = true
-                                    responseHandler.contentReceived(msg)
-                                }
-                            }
-                        }
-
-                        override fun channelInactive(ctx: ChannelHandlerContext) {
-                            closeCallback()
-                            ctx.fireChannelInactive()
-                        }
-
-                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                            connectionClosedByTheRemoteServer = false
-                            ctx.close()
-                            pool.release(channel)
-                            responseHandler.exceptionCaught(cause)
-                        }
-                    }
-
                     channel.pipeline()
-                        .addLast("client-handler", handler)
-                    response.complete(object : MemcacheRequestController {
-
-                        override fun sendRequest(request: BinaryMemcacheRequest) {
-                            requestBodySize = request.totalBodyLength() - request.keyLength() - request.extrasLength()
-                            channel.writeAndFlush(request)
-                            requestSent = true
-                        }
-
-                        override fun sendContent(content: MemcacheContent) {
-                            val size = content.content().readableBytes()
-                            channel.writeAndFlush(content).addListener {
-                                requestBodyBytesSent += size
-                                requestBodySent = true
-                                if(content is LastMemcacheContent) {
-                                    requestFinished = true
-                                }
+                        .addLast("client-handler", object : SimpleChannelInboundHandler<FullBinaryMemcacheResponse>() {
+                            override fun channelRead0(
+                                ctx: ChannelHandlerContext,
+                                msg: FullBinaryMemcacheResponse
+                            ) {
+                                pipeline.removeLast()
+                                pool.release(channel)
+                                msg.touch("The method's caller must remember to release this")
+                                response.complete(msg.retain())
                             }
-                        }
 
-                        override fun exceptionCaught(ex: Throwable) {
-                            connectionClosedByTheRemoteServer = false
-                            channel.close()
-                        }
-                    })
+                            override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
+                                val ex = when (cause) {
+                                    is DecoderException -> cause.cause!!
+                                    else -> cause
+                                }
+                                ctx.close()
+                                pipeline.removeLast()
+                                pool.release(channel)
+                                response.completeExceptionally(ex)
+                            }
+                        })
+                    request.touch()
+                    channel.writeAndFlush(request)
                 } else {
                     response.completeExceptionally(channelFuture.cause())
                 }
@@ -204,6 +146,107 @@ class MemcacheClient(
         return response
     }
 
+    private fun encodeExpiry(expiry: Duration): Int {
+        val expirySeconds = expiry.toSeconds()
+        return expirySeconds.toInt().takeIf { it.toLong() == expirySeconds }
+            ?: Instant.ofEpochSecond(expirySeconds).epochSecond.toInt()
+    }
+
+    fun get(key: String): CompletableFuture<ReadableByteChannel?> {
+        val request = (cfg.digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digest(key.toByteArray(), md)
+            } ?: key.toByteArray(Charsets.UTF_8)).let { digest ->
+            DefaultFullBinaryMemcacheRequest(Unpooled.wrappedBuffer(digest), null).apply {
+                setOpcode(BinaryMemcacheOpcodes.GET)
+            }
+        }
+        return sendRequest(request).thenApply { response ->
+            try {
+                when (val status = response.status()) {
+                    BinaryMemcacheResponseStatus.SUCCESS -> {
+                        val compressionMode = cfg.compressionMode
+                        val content = response.content().retain()
+                        content.touch()
+                        if (compressionMode != null) {
+                            when (compressionMode) {
+                                MemcacheCacheConfiguration.CompressionMode.GZIP -> {
+                                    GZIPInputStream(ByteBufInputStream(content))
+                                }
+
+                                MemcacheCacheConfiguration.CompressionMode.DEFLATE -> {
+                                    InflaterInputStream(ByteBufInputStream(content))
+                                }
+                            }
+                        } else {
+                            ByteBufInputStream(content)
+                        }.let(Channels::newChannel)
+                    }
+
+                    BinaryMemcacheResponseStatus.KEY_ENOENT -> {
+                        null
+                    }
+
+                    else -> throw MemcacheException(status)
+                }
+            } finally {
+                response.release()
+            }
+        }
+    }
+
+    fun put(key: String, content: ByteBuf, expiry: Duration, cas: Long? = null): CompletableFuture<Void> {
+        val request = (cfg.digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digest(key.toByteArray(), md)
+            } ?: key.toByteArray(Charsets.UTF_8)).let { digest ->
+            val extras = Unpooled.buffer(8, 8)
+            extras.writeInt(0)
+            extras.writeInt(encodeExpiry(expiry))
+            val compressionMode = cfg.compressionMode
+            content.retain()
+            val payload = if (compressionMode != null) {
+                val inputStream = ByteBufInputStream(content)
+                val buf = content.alloc().buffer()
+                buf.retain()
+                val outputStream = when (compressionMode) {
+                    MemcacheCacheConfiguration.CompressionMode.GZIP -> {
+                        GZIPOutputStream(ByteBufOutputStream(buf))
+                    }
+
+                    MemcacheCacheConfiguration.CompressionMode.DEFLATE -> {
+                        DeflaterOutputStream(ByteBufOutputStream(buf), Deflater(Deflater.DEFAULT_COMPRESSION, false))
+                    }
+                }
+                inputStream.use { i ->
+                    outputStream.use { o ->
+                        JWO.copy(i, o)
+                    }
+                }
+                buf
+            } else {
+                content
+            }
+            DefaultFullBinaryMemcacheRequest(Unpooled.wrappedBuffer(digest), extras, payload).apply {
+                setOpcode(BinaryMemcacheOpcodes.SET)
+                cas?.let(this::setCas)
+            }
+        }
+        return sendRequest(request).thenApply { response ->
+            try {
+                when (val status = response.status()) {
+                    BinaryMemcacheResponseStatus.SUCCESS -> null
+                    else -> throw MemcacheException(status)
+                }
+            } finally {
+                response.release()
+            }
+        }
+    }
+
+
     fun shutDown(): NettyFuture<*> {
         return group.shutdownGracefully()
     }

rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/client/MemcacheRequestController.kt

@@ -1,13 +0,0 @@
-package net.woggioni.rbcs.server.memcache.client
-
-import io.netty.handler.codec.memcache.MemcacheContent
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheRequest
-
-interface MemcacheRequestController {
-
-    fun sendRequest(request : BinaryMemcacheRequest)
-
-    fun sendContent(content : MemcacheContent)
-
-    fun exceptionCaught(ex : Throwable)
-}

rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/client/MemcacheResponseHandler.kt

@@ -1,14 +0,0 @@
-package net.woggioni.rbcs.server.memcache.client
-
-import io.netty.handler.codec.memcache.MemcacheContent
-import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
-
-interface MemcacheResponseHandler {
-
-
-    fun responseReceived(response : BinaryMemcacheResponse)
-
-    fun contentReceived(content : MemcacheContent)
-
-    fun exceptionCaught(ex : Throwable)
-}

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

@@ -20,10 +20,9 @@
                     <xs:element name="server" type="rbcs-memcache:memcacheServerType"/>
                 </xs:sequence>
                 <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
-                <xs:attribute name="chunk-size" type="rbcs:byteSizeType" default="0x10000"/>
-                <xs:attribute name="digest" type="xs:token"/>
+                <xs:attribute name="max-size" type="xs:unsignedInt" default="1048576"/>
+                <xs:attribute name="digest" type="xs:token" />
                 <xs:attribute name="compression-mode" type="rbcs-memcache:compressionType"/>
-                <xs:attribute name="compression-level" type="rbcs:compressionLevelType" default="-1"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>
@@ -31,6 +30,7 @@
     <xs:simpleType name="compressionType">
         <xs:restriction base="xs:token">
             <xs:enumeration value="deflate"/>
+            <xs:enumeration value="gzip"/>
         </xs:restriction>
     </xs:simpleType>
 

rbcs-server-memcache/src/test/kotlin/net/woggioni/rbcs/server/memcache/client/ByteBufferTest.kt

@@ -1,27 +0,0 @@
-package net.woggioni.rbcs.server.memcache.client
-
-import io.netty.buffer.ByteBufUtil
-import io.netty.buffer.Unpooled
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Test
-import java.io.ByteArrayInputStream
-import java.nio.ByteBuffer
-import java.nio.channels.Channels
-import kotlin.random.Random
-
-class ByteBufferTest {
-
-    @Test
-    fun test() {
-        val byteBuffer = ByteBuffer.allocate(0x100)
-        val originalBytes = Random(101325).nextBytes(0x100)
-        Channels.newChannel(ByteArrayInputStream(originalBytes)).use { source ->
-            source.read(byteBuffer)
-        }
-        byteBuffer.flip()
-        val buf = Unpooled.buffer()
-        buf.writeBytes(byteBuffer)
-        val finalBytes = ByteBufUtil.getBytes(buf)
-        Assertions.assertArrayEquals(originalBytes, finalBytes)
-    }
-}

rbcs-server/build.gradle

@@ -9,9 +9,6 @@ dependencies {
     implementation catalog.jwo
     implementation catalog.slf4j.api
     implementation catalog.netty.codec.http
-    implementation catalog.netty.handler
-    implementation catalog.netty.buffer
-    implementation catalog.netty.transport
 
     api project(':rbcs-common')
     api project(':rbcs-api')
@@ -39,4 +36,3 @@ publishing {
 }
 
 
-

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/Logging.kt

@@ -0,0 +1,30 @@
+package net.woggioni.rbcs.server
+
+import io.netty.channel.ChannelHandlerContext
+import org.slf4j.Logger
+import java.net.InetSocketAddress
+
+inline fun Logger.trace(ctx : ChannelHandlerContext, messageBuilder : () -> String) {
+    log(this, ctx, { isTraceEnabled }, { trace(it) } , messageBuilder)
+}
+inline fun Logger.debug(ctx : ChannelHandlerContext, messageBuilder : () -> String) {
+    log(this, ctx, { isDebugEnabled }, { debug(it) } , messageBuilder)
+}
+inline fun Logger.info(ctx : ChannelHandlerContext, messageBuilder : () -> String) {
+    log(this, ctx, { isInfoEnabled }, { info(it) } , messageBuilder)
+}
+inline fun Logger.warn(ctx : ChannelHandlerContext, messageBuilder : () -> String) {
+    log(this, ctx, { isWarnEnabled }, { warn(it) } , messageBuilder)
+}
+inline fun Logger.error(ctx : ChannelHandlerContext, messageBuilder : () -> String) {
+    log(this, ctx, { isErrorEnabled }, { error(it) } , messageBuilder)
+}
+
+inline fun log(log : Logger, ctx : ChannelHandlerContext,
+                        filter : Logger.() -> Boolean,
+                        loggerMethod : Logger.(String) -> Unit, messageBuilder : () -> String) {
+    if(log.filter()) {
+        val clientAddress = (ctx.channel().remoteAddress() as InetSocketAddress).address.hostAddress
+        log.loggerMethod(clientAddress + " - " + messageBuilder())
+    }
+}

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt

@@ -3,7 +3,6 @@ package net.woggioni.rbcs.server
 import io.netty.bootstrap.ServerBootstrap
 import io.netty.buffer.ByteBuf
 import io.netty.channel.Channel
-import io.netty.channel.ChannelFactory
 import io.netty.channel.ChannelFuture
 import io.netty.channel.ChannelHandler.Sharable
 import io.netty.channel.ChannelHandlerContext
@@ -12,16 +11,12 @@ import io.netty.channel.ChannelInitializer
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPromise
 import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.socket.DatagramChannel
-import io.netty.channel.socket.ServerSocketChannel
-import io.netty.channel.socket.SocketChannel
-import io.netty.channel.socket.nio.NioDatagramChannel
 import io.netty.channel.socket.nio.NioServerSocketChannel
-import io.netty.channel.socket.nio.NioSocketChannel
 import io.netty.handler.codec.compression.CompressionOptions
 import io.netty.handler.codec.http.DefaultHttpContent
 import io.netty.handler.codec.http.HttpContentCompressor
 import io.netty.handler.codec.http.HttpHeaderNames
+import io.netty.handler.codec.http.HttpObjectAggregator
 import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpServerCodec
 import io.netty.handler.ssl.ClientAuth
@@ -35,16 +30,13 @@ import io.netty.handler.timeout.IdleStateHandler
 import io.netty.util.AttributeKey
 import io.netty.util.concurrent.DefaultEventExecutorGroup
 import io.netty.util.concurrent.EventExecutorGroup
-import net.woggioni.jwo.JWO
-import net.woggioni.jwo.Tuple2
-import net.woggioni.rbcs.api.AsyncCloseable
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.api.exception.ConfigurationException
+import net.woggioni.rbcs.common.RBCS.toUrl
 import net.woggioni.rbcs.common.PasswordSecurity.decodePasswordHash
 import net.woggioni.rbcs.common.PasswordSecurity.hashPassword
-import net.woggioni.rbcs.common.RBCS.toUrl
 import net.woggioni.rbcs.common.Xml
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.common.debug
 import net.woggioni.rbcs.common.info
 import net.woggioni.rbcs.server.auth.AbstractNettyHttpAuthenticator
@@ -54,11 +46,10 @@ import net.woggioni.rbcs.server.auth.RoleAuthorizer
 import net.woggioni.rbcs.server.configuration.Parser
 import net.woggioni.rbcs.server.configuration.Serializer
 import net.woggioni.rbcs.server.exception.ExceptionHandler
-import net.woggioni.rbcs.server.handler.MaxRequestSizeHandler
 import net.woggioni.rbcs.server.handler.ServerHandler
-import net.woggioni.rbcs.server.handler.TraceHandler
-import net.woggioni.rbcs.server.throttling.BucketManager
 import net.woggioni.rbcs.server.throttling.ThrottlingHandler
+import net.woggioni.jwo.JWO
+import net.woggioni.jwo.Tuple2
 import java.io.OutputStream
 import java.net.InetSocketAddress
 import java.nio.file.Files
@@ -66,23 +57,18 @@ import java.nio.file.Path
 import java.security.KeyStore
 import java.security.PrivateKey
 import java.security.cert.X509Certificate
-import java.time.Duration
-import java.time.Instant
 import java.util.Arrays
 import java.util.Base64
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
 import java.util.regex.Matcher
 import java.util.regex.Pattern
 import javax.naming.ldap.LdapName
 import javax.net.ssl.SSLPeerUnverifiedException
 
 class RemoteBuildCacheServer(private val cfg: Configuration) {
+    private val log = contextLogger()
 
     companion object {
-        private val log = createLogger<RemoteBuildCacheServer>()
 
         val userAttribute: AttributeKey<Configuration.User> = AttributeKey.valueOf("user")
         val groupAttribute: AttributeKey<Set<Configuration.Group>> = AttributeKey.valueOf("group")
@@ -142,12 +128,11 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                     val clientCertificate = peerCertificates.first() as X509Certificate
                     val user = userExtractor?.extract(clientCertificate)
                     val group = groupExtractor?.extract(clientCertificate)
-                    val allGroups =
-                        ((user?.groups ?: emptySet()).asSequence() + sequenceOf(group).filterNotNull()).toSet()
+                    val allGroups = ((user?.groups ?: emptySet()).asSequence() + sequenceOf(group).filterNotNull()).toSet()
                     AuthenticationResult(user, allGroups)
-                } ?: anonymousUserGroups?.let { AuthenticationResult(null, it) }
+                } ?: anonymousUserGroups?.let{ AuthenticationResult(null, it) }
             } catch (es: SSLPeerUnverifiedException) {
-                anonymousUserGroups?.let { AuthenticationResult(null, it) }
+                anonymousUserGroups?.let{ AuthenticationResult(null, it) }
             }
         }
     }
@@ -156,9 +141,7 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
     private class NettyHttpBasicAuthenticator(
         private val users: Map<String, Configuration.User>, authorizer: Authorizer
     ) : AbstractNettyHttpAuthenticator(authorizer) {
-        companion object {
-            private val log = createLogger<NettyHttpBasicAuthenticator>()
-        }
+        private val log = contextLogger()
 
         override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): AuthenticationResult? {
             val authorizationHeader = req.headers()[HttpHeaderNames.AUTHORIZATION] ?: let {
@@ -207,10 +190,8 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
 
     private class ServerInitializer(
         private val cfg: Configuration,
-        private val channelFactory : ChannelFactory<SocketChannel>,
-        private val datagramChannelFactory : ChannelFactory<DatagramChannel>,
         private val eventExecutorGroup: EventExecutorGroup
-    ) : ChannelInitializer<Channel>(), AsyncCloseable {
+    ) : ChannelInitializer<Channel>() {
 
         companion object {
             private fun createSslCtx(tls: Configuration.Tls): SslContext {
@@ -232,7 +213,7 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                             trustManager(
                                 ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
                             )
-                            if (trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
+                            if(trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
                             else ClientAuth.OPTIONAL
                         } ?: ClientAuth.NONE
                         clientAuth(clientAuth)
@@ -260,13 +241,18 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                 }
                 return keystore
             }
-
-            private val log = createLogger<ServerInitializer>()
         }
 
-        private val cacheHandlerFactory = cfg.cache.materialize()
+        private val log = contextLogger()
 
-        private val bucketManager = BucketManager.from(cfg)
+        private val serverHandler = let {
+            val cacheImplementation = cfg.cache.materialize()
+            val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
+            ServerHandler(cacheImplementation, prefix)
+        }
+
+        private val exceptionHandler = ExceptionHandler()
+        private val throttlingHandler = ThrottlingHandler(cfg)
 
         private val authenticator = when (val auth = cfg.authentication) {
             is Configuration.BasicAuthentication -> NettyHttpBasicAuthenticator(cfg.users, RoleAuthorizer())
@@ -323,10 +309,23 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
             }
             val pipeline = ch.pipeline()
             cfg.connection.also { conn ->
+                val readTimeout = conn.readTimeout.toMillis()
+                val writeTimeout = conn.writeTimeout.toMillis()
+                if(readTimeout > 0 || writeTimeout > 0) {
+                    pipeline.addLast(
+                        IdleStateHandler(
+                            false,
+                            readTimeout,
+                            writeTimeout,
+                            0,
+                            TimeUnit.MILLISECONDS
+                        )
+                    )
+                }
                 val readIdleTimeout = conn.readIdleTimeout.toMillis()
                 val writeIdleTimeout = conn.writeIdleTimeout.toMillis()
                 val idleTimeout = conn.idleTimeout.toMillis()
-                if (readIdleTimeout > 0 || writeIdleTimeout > 0 || idleTimeout > 0) {
+                if(readIdleTimeout > 0 || writeIdleTimeout > 0 || idleTimeout > 0) {
                     pipeline.addLast(
                         IdleStateHandler(
                             true,
@@ -341,19 +340,16 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
             pipeline.addLast(object : ChannelInboundHandlerAdapter() {
                 override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
                     if (evt is IdleStateEvent) {
-                        when (evt.state()) {
+                        when(evt.state()) {
                             IdleState.READER_IDLE -> log.debug {
                                 "Read timeout reached on channel ${ch.id().asShortText()}, closing the connection"
                             }
-
                             IdleState.WRITER_IDLE -> log.debug {
                                 "Write timeout reached on channel ${ch.id().asShortText()}, closing the connection"
                             }
-
                             IdleState.ALL_IDLE -> log.debug {
                                 "Idle timeout reached on channel ${ch.id().asShortText()}, closing the connection"
                             }
-
                             null -> throw IllegalStateException("This should never happen")
                         }
                         ctx.close()
@@ -364,111 +360,48 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                 pipeline.addLast(SSL_HANDLER_NAME, it)
             }
             pipeline.addLast(HttpServerCodec())
-            pipeline.addLast(MaxRequestSizeHandler.NAME, MaxRequestSizeHandler(cfg.connection.maxRequestSize))
             pipeline.addLast(HttpChunkContentCompressor(1024))
             pipeline.addLast(ChunkedWriteHandler())
+            pipeline.addLast(HttpObjectAggregator(cfg.connection.maxRequestSize))
             authenticator?.let {
                 pipeline.addLast(it)
             }
-            pipeline.addLast(ThrottlingHandler(bucketManager, cfg.connection))
-
-            val serverHandler = let {
-                val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
-                ServerHandler(prefix)
-            }
-            pipeline.addLast(eventExecutorGroup, ServerHandler.NAME, serverHandler)
-
-            pipeline.addLast(cacheHandlerFactory.newHandler(ch.eventLoop(), channelFactory, datagramChannelFactory))
-            pipeline.addLast(TraceHandler)
-            pipeline.addLast(ExceptionHandler)
+            pipeline.addLast(throttlingHandler)
+            pipeline.addLast(eventExecutorGroup, serverHandler)
+            pipeline.addLast(exceptionHandler)
         }
-
-        override fun asyncClose() = cacheHandlerFactory.asyncClose()
     }
 
     class ServerHandle(
-        closeFuture: ChannelFuture,
-        private val bossGroup: EventExecutorGroup,
-        private val executorGroups: Iterable<EventExecutorGroup>,
-        private val serverInitializer: AsyncCloseable,
-    ) : Future<Void> by from(closeFuture, executorGroups, serverInitializer) {
+        httpChannelFuture: ChannelFuture,
+        private val executorGroups: Iterable<EventExecutorGroup>
+    ) : AutoCloseable {
+        private val httpChannel: Channel = httpChannelFuture.channel()
+        private val closeFuture: ChannelFuture = httpChannel.closeFuture()
+        private val log = contextLogger()
 
-        companion object {
-            private val log = createLogger<ServerHandle>()
-
-            private fun from(
-                closeFuture: ChannelFuture,
-                executorGroups: Iterable<EventExecutorGroup>,
-                serverInitializer: AsyncCloseable
-            ): CompletableFuture<Void> {
-                val result = CompletableFuture<Void>()
-                closeFuture.addListener {
-                    val errors = mutableListOf<Throwable>()
-                    val deadline = Instant.now().plusSeconds(20)
-                    try {
-                        serverInitializer.close()
-                    } catch (ex: Throwable) {
-                        log.error(ex.message, ex)
-                        errors.addLast(ex)
-                    }
-
-                    serverInitializer.asyncClose().whenComplete { _, ex ->
-                        if(ex != null) {
-                            log.error(ex.message, ex)
-                            errors.addLast(ex)
-                        }
-
-                        executorGroups.map {
-                            it.shutdownGracefully()
-                        }
-
-                        for (executorGroup in executorGroups) {
-                            val future = executorGroup.terminationFuture()
-                            try {
-                                val now = Instant.now()
-                                if (now > deadline) {
-                                    future.get(0, TimeUnit.SECONDS)
-                                } else {
-                                    future.get(Duration.between(now, deadline).toMillis(), TimeUnit.MILLISECONDS)
-                                }
-                            }
-                            catch (te: TimeoutException) {
-                                errors.addLast(te)
-                                log.warn("Timeout while waiting for shutdown of $executorGroup", te)
-                            } catch (ex: Throwable) {
-                                log.warn(ex.message, ex)
-                                errors.addLast(ex)
-                            }
-                        }
-
-                        if(errors.isEmpty()) {
-                            result.complete(null)
-                        } else {
-                            result.completeExceptionally(errors.first())
-                        }
-                    }
-                }
-
-                return result.thenAccept {
-                    log.info {
-                        "RemoteBuildCacheServer has been gracefully shut down"
-                    }
-                }
-            }
+        fun shutdown(): ChannelFuture {
+            return httpChannel.close()
         }
 
-
-        fun sendShutdownSignal() {
-            bossGroup.shutdownGracefully()
+        override fun close() {
+            try {
+                closeFuture.sync()
+            } finally {
+                executorGroups.forEach {
+                    it.shutdownGracefully().sync()
+                }
+            }
+            log.info {
+                "RemoteBuildCacheServer has been gracefully shut down"
+            }
         }
     }
 
     fun run(): ServerHandle {
         // Create the multithreaded event loops for the server
         val bossGroup = NioEventLoopGroup(1)
-        val channelFactory = ChannelFactory<SocketChannel> { NioSocketChannel() }
-        val datagramChannelFactory = ChannelFactory<DatagramChannel> { NioDatagramChannel() }
-        val serverChannelFactory = ChannelFactory<ServerSocketChannel> { NioServerSocketChannel() }
+        val serverSocketChannel = NioServerSocketChannel::class.java
         val workerGroup = NioEventLoopGroup(0)
         val eventExecutorGroup = run {
             val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
@@ -478,12 +411,11 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
             }
             DefaultEventExecutorGroup(Runtime.getRuntime().availableProcessors(), threadFactory)
         }
-        val serverInitializer = ServerInitializer(cfg, channelFactory, datagramChannelFactory, workerGroup)
         val bootstrap = ServerBootstrap().apply {
             // Configure the server
             group(bossGroup, workerGroup)
-            channelFactory(serverChannelFactory)
-            childHandler(serverInitializer)
+            channel(serverSocketChannel)
+            childHandler(ServerInitializer(cfg, eventExecutorGroup))
             option(ChannelOption.SO_BACKLOG, cfg.incomingConnectionsBacklogSize)
             childOption(ChannelOption.SO_KEEPALIVE, true)
         }
@@ -491,16 +423,10 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
 
         // Bind and start to accept incoming connections.
         val bindAddress = InetSocketAddress(cfg.host, cfg.port)
-        val httpChannel = bootstrap.bind(bindAddress).sync().channel()
+        val httpChannel = bootstrap.bind(bindAddress).sync()
         log.info {
             "RemoteBuildCacheServer is listening on ${cfg.host}:${cfg.port}"
         }
-
-        return ServerHandle(
-            httpChannel.closeFuture(),
-            bossGroup,
-            setOf(workerGroup, eventExecutorGroup),
-            serverInitializer
-        )
+        return ServerHandle(httpChannel, setOf(bossGroup, workerGroup, eventExecutorGroup))
     }
 }

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

@@ -6,7 +6,6 @@ import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.handler.codec.http.DefaultFullHttpResponse
 import io.netty.handler.codec.http.FullHttpResponse
-import io.netty.handler.codec.http.HttpContent
 import io.netty.handler.codec.http.HttpHeaderNames
 import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpResponseStatus
@@ -58,8 +57,6 @@ abstract class AbstractNettyHttpAuthenticator(private val authorizer: Authorizer
             } else {
                 authorizationFailure(ctx, msg)
             }
-        } else if(msg is HttpContent) {
-            ctx.fireChannelRead(msg)
         }
     }
 

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

@@ -1,15 +1,12 @@
 package net.woggioni.rbcs.server.cache
 
+import io.netty.buffer.ByteBuf
+import net.woggioni.rbcs.api.Cache
+import net.woggioni.rbcs.common.ByteBufInputStream
+import net.woggioni.rbcs.common.RBCS.digestString
+import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.jwo.JWO
-import net.woggioni.rbcs.api.AsyncCloseable
-import net.woggioni.rbcs.api.CacheValueMetadata
-import net.woggioni.rbcs.common.createLogger
-import java.io.ByteArrayOutputStream
-import java.io.InputStream
-import java.io.ObjectInputStream
-import java.io.ObjectOutputStream
-import java.io.Serializable
-import java.nio.ByteBuffer
+import net.woggioni.jwo.LockFile
 import java.nio.channels.Channels
 import java.nio.channels.FileChannel
 import java.nio.file.Files
@@ -17,153 +14,117 @@ import java.nio.file.Path
 import java.nio.file.StandardCopyOption
 import java.nio.file.StandardOpenOption
 import java.nio.file.attribute.BasicFileAttributes
+import java.security.MessageDigest
 import java.time.Duration
 import java.time.Instant
 import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicReference
+import java.util.zip.Deflater
+import java.util.zip.DeflaterOutputStream
+import java.util.zip.Inflater
+import java.util.zip.InflaterInputStream
 
 class FileSystemCache(
     val root: Path,
-    val maxAge: Duration
-) : AsyncCloseable {
-
-    class EntryValue(val metadata: CacheValueMetadata, val channel : FileChannel, val offset : Long, val size : Long) : Serializable
+    val maxAge: Duration,
+    val digestAlgorithm: String?,
+    val compressionEnabled: Boolean,
+    val compressionLevel: Int
+) : Cache {
 
     private companion object {
-        private val log = createLogger<FileSystemCache>()
+        @JvmStatic
+        private val log = contextLogger()
     }
 
     init {
         Files.createDirectories(root)
     }
 
-    @Volatile
-    private var running = true
+    private var nextGc = AtomicReference(Instant.now().plus(maxAge))
 
-    private var nextGc = Instant.now()
-
-    fun get(key: String): EntryValue? =
-        root.resolve(key).takeIf(Files::exists)
+    override fun get(key: String) = (digestAlgorithm
+        ?.let(MessageDigest::getInstance)
+        ?.let { md ->
+            digestString(key.toByteArray(), md)
+        } ?: key).let { digest ->
+        root.resolve(digest).takeIf(Files::exists)
             ?.let { file ->
-                val size = Files.size(file)
-                val channel = FileChannel.open(file, StandardOpenOption.READ)
-                val source = Channels.newInputStream(channel)
-                val tmp = ByteArray(Integer.BYTES)
-                val buffer = ByteBuffer.wrap(tmp)
-                source.read(tmp)
-                buffer.rewind()
-                val offset = (Integer.BYTES + buffer.getInt()).toLong()
-                var count = 0
-                val wrapper = object : InputStream() {
-                    override fun read(): Int {
-                        return source.read().also {
-                            if (it > 0) count += it
-                        }
-                    }
-
-                    override fun read(b: ByteArray, off: Int, len: Int): Int {
-                        return source.read(b, off, len).also {
-                            if (it > 0) count += it
-                        }
-                    }
-
-                    override fun close() {
+                file.takeIf(Files::exists)?.let { file ->
+                    if (compressionEnabled) {
+                        val inflater = Inflater()
+                        Channels.newChannel(
+                            InflaterInputStream(
+                                Channels.newInputStream(
+                                    FileChannel.open(
+                                        file,
+                                        StandardOpenOption.READ
+                                    )
+                                ), inflater
+                            )
+                        )
+                    } else {
+                        FileChannel.open(file, StandardOpenOption.READ)
                     }
                 }
-                val metadata = ObjectInputStream(wrapper).use { ois ->
-                    ois.readObject() as CacheValueMetadata
-                }
-                EntryValue(metadata, channel, offset, size)
+            }.also {
+                gc()
+            }.let {
+                CompletableFuture.completedFuture(it)
             }
-
-    class FileSink(metadata: CacheValueMetadata, private val path: Path, private val tmpFile: Path) {
-        val channel: FileChannel
-
-        init {
-            val baos = ByteArrayOutputStream()
-            ObjectOutputStream(baos).use {
-                it.writeObject(metadata)
-            }
-            Files.newOutputStream(tmpFile).use {
-                val bytes = baos.toByteArray()
-                val buffer = ByteBuffer.allocate(Integer.BYTES)
-                buffer.putInt(bytes.size)
-                buffer.rewind()
-                it.write(buffer.array())
-                it.write(bytes)
-            }
-            channel = FileChannel.open(tmpFile, StandardOpenOption.APPEND)
-        }
-
-        fun commit() {
-            channel.close()
-            Files.move(tmpFile, path, StandardCopyOption.ATOMIC_MOVE)
-        }
-
-        fun rollback() {
-            channel.close()
-            Files.delete(path)
-        }
     }
 
-    fun put(
-        key: String,
-        metadata: CacheValueMetadata,
-    ): FileSink {
-        val file = root.resolve(key)
-        val tmpFile = Files.createTempFile(root, null, ".tmp")
-        return FileSink(metadata, file, tmpFile)
-    }
-
-    private val closeFuture = object : CompletableFuture<Void>() {
-        init {
-            Thread.ofVirtual().name("file-system-cache-gc").start {
-                try {
-                    while (running) {
-                        gc()
+    override fun put(key: String, content: ByteBuf): CompletableFuture<Void> {
+        (digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digestString(key.toByteArray(), md)
+            } ?: key).let { digest ->
+            val file = root.resolve(digest)
+            val tmpFile = Files.createTempFile(root, null, ".tmp")
+            try {
+                Files.newOutputStream(tmpFile).let {
+                    if (compressionEnabled) {
+                        val deflater = Deflater(compressionLevel)
+                        DeflaterOutputStream(it, deflater)
+                    } else {
+                        it
                     }
-                    complete(null)
-                } catch (ex : Throwable) {
-                    completeExceptionally(ex)
+                }.use {
+                    JWO.copy(ByteBufInputStream(content), it)
                 }
+                Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
+            } catch (t: Throwable) {
+                Files.delete(tmpFile)
+                throw t
             }
+        }.also {
+            gc()
         }
+        return CompletableFuture.completedFuture(null)
     }
 
     private fun gc() {
         val now = Instant.now()
-        if (nextGc < now) {
-            val oldestEntry = actualGc(now)
-            nextGc = (oldestEntry ?: now).plus(maxAge)
+        val oldValue = nextGc.getAndSet(now.plus(maxAge))
+        if (oldValue < now) {
+            actualGc(now)
         }
-        Thread.sleep(minOf(Duration.between(now, nextGc), Duration.ofSeconds(1)))
     }
 
-    /**
-     * Returns the creation timestamp of the oldest cache entry (if any)
-     */
-    private fun actualGc(now: Instant): Instant? {
-        var result: Instant? = null
-        Files.list(root)
-            .filter { path ->
-                JWO.splitExtension(path)
-                    .map { it._2 }
-                    .map { it != ".tmp" }
-                    .orElse(true)
+    @Synchronized
+    private fun actualGc(now: Instant) {
+        Files.list(root).filter {
+            val creationTimeStamp = Files.readAttributes(it, BasicFileAttributes::class.java)
+                .creationTime()
+                .toInstant()
+            now > creationTimeStamp.plus(maxAge)
+        }.forEach { file ->
+            LockFile.acquire(file, false).use {
+                Files.delete(file)
             }
-            .filter {
-                val creationTimeStamp = Files.readAttributes(it, BasicFileAttributes::class.java)
-                    .creationTime()
-                    .toInstant()
-                if (result == null || creationTimeStamp < result) {
-                    result = creationTimeStamp
-                }
-                now > creationTimeStamp.plus(maxAge)
-            }.forEach(Files::delete)
-        return result
+        }
     }
 
-    override fun asyncClose() : CompletableFuture<Void> {
-        running = false
-        return closeFuture
-    }
+    override fun close() {}
 }

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/FileSystemCacheConfiguration.kt

@@ -1,13 +1,8 @@
 package net.woggioni.rbcs.server.cache
 
-import io.netty.channel.ChannelFactory
-import io.netty.channel.EventLoopGroup
-import io.netty.channel.socket.DatagramChannel
-import io.netty.channel.socket.SocketChannel
-import net.woggioni.jwo.Application
-import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.common.RBCS
+import net.woggioni.jwo.Application
 import java.nio.file.Path
 import java.time.Duration
 
@@ -17,20 +12,14 @@ data class FileSystemCacheConfiguration(
     val digestAlgorithm : String?,
     val compressionEnabled: Boolean,
     val compressionLevel: Int,
-    val chunkSize: Int,
 ) : Configuration.Cache {
-
-    override fun materialize() = object : CacheHandlerFactory {
-        private val cache = FileSystemCache(root ?: Application.builder("rbcs").build().computeCacheDirectory(), maxAge)
-
-        override fun asyncClose() = cache.asyncClose()
-
-        override fun newHandler(
-            eventLoop: EventLoopGroup,
-            socketChannelFactory: ChannelFactory<SocketChannel>,
-            datagramChannelFactory: ChannelFactory<DatagramChannel>
-        ) = FileSystemCacheHandler(cache, digestAlgorithm, compressionEnabled, compressionLevel, chunkSize)
-    }
+    override fun materialize() = FileSystemCache(
+        root ?: Application.builder("rbcs").build().computeCacheDirectory(),
+        maxAge,
+        digestAlgorithm,
+        compressionEnabled,
+        compressionLevel
+    )
 
     override fun getNamespaceURI() = RBCS.RBCS_NAMESPACE_URI
 

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/FileSystemCacheHandler.kt

@@ -1,122 +0,0 @@
-package net.woggioni.rbcs.server.cache
-
-import io.netty.buffer.ByteBuf
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.handler.codec.http.LastHttpContent
-import io.netty.handler.stream.ChunkedNioFile
-import net.woggioni.rbcs.api.message.CacheMessage
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-import net.woggioni.rbcs.common.RBCS.processCacheKey
-import java.nio.channels.Channels
-import java.util.Base64
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.InflaterInputStream
-
-class FileSystemCacheHandler(
-    private val cache: FileSystemCache,
-    private val digestAlgorithm: String?,
-    private val compressionEnabled: Boolean,
-    private val compressionLevel: Int,
-    private val chunkSize: Int
-) : SimpleChannelInboundHandler<CacheMessage>() {
-
-    private inner class InProgressPutRequest(
-        val key : String,
-        private val fileSink : FileSystemCache.FileSink
-    ) {
-
-        private val stream = Channels.newOutputStream(fileSink.channel).let {
-            if (compressionEnabled) {
-                DeflaterOutputStream(it, Deflater(compressionLevel))
-            } else {
-                it
-            }
-        }
-
-        fun write(buf: ByteBuf) {
-            buf.readBytes(stream, buf.readableBytes())
-        }
-
-        fun commit() {
-            stream.close()
-            fileSink.commit()
-        }
-
-        fun rollback() {
-            fileSink.rollback()
-        }
-    }
-
-    private var inProgressPutRequest: InProgressPutRequest? = null
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
-        when (msg) {
-            is CacheGetRequest -> handleGetRequest(ctx, msg)
-            is CachePutRequest -> handlePutRequest(ctx, msg)
-            is LastCacheContent -> handleLastCacheContent(ctx, msg)
-            is CacheContent -> handleCacheContent(ctx, msg)
-            else -> ctx.fireChannelRead(msg)
-        }
-    }
-
-    private fun handleGetRequest(ctx: ChannelHandlerContext, msg: CacheGetRequest) {
-        val key = String(Base64.getUrlEncoder().encode(processCacheKey(msg.key, digestAlgorithm)))
-        cache.get(key)?.also { entryValue ->
-            ctx.writeAndFlush(CacheValueFoundResponse(msg.key, entryValue.metadata))
-            entryValue.channel.let { channel ->
-                if(compressionEnabled) {
-                    InflaterInputStream(Channels.newInputStream(channel)).use { stream ->
-
-                        outerLoop@
-                        while (true) {
-                            val buf = ctx.alloc().heapBuffer(chunkSize)
-                            while(buf.readableBytes() < chunkSize) {
-                                val read = buf.writeBytes(stream, chunkSize)
-                                if(read < 0) {
-                                    ctx.writeAndFlush(LastCacheContent(buf))
-                                    break@outerLoop
-                                }
-                            }
-                            ctx.writeAndFlush(CacheContent(buf))
-                        }
-                    }
-                } else {
-                    ctx.writeAndFlush(ChunkedNioFile(channel, entryValue.offset, entryValue.size - entryValue.offset, chunkSize))
-                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                }
-            }
-        } ?: ctx.writeAndFlush(CacheValueNotFoundResponse())
-    }
-
-    private fun handlePutRequest(ctx: ChannelHandlerContext, msg: CachePutRequest) {
-        val key = String(Base64.getUrlEncoder().encode(processCacheKey(msg.key, digestAlgorithm)))
-        val sink = cache.put(key, msg.metadata)
-        inProgressPutRequest = InProgressPutRequest(msg.key, sink)
-    }
-
-    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest!!.write(msg.content())
-    }
-
-    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
-        inProgressPutRequest?.let { request ->
-            inProgressPutRequest = null
-            request.write(msg.content())
-            request.commit()
-            ctx.writeAndFlush(CachePutResponse(request.key))
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressPutRequest?.rollback()
-        super.exceptionCaught(ctx, cause)
-    }
-}

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/FileSystemCacheProvider.kt

@@ -30,18 +30,14 @@ class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
         val compressionLevel = el.renderAttribute("compression-level")
             ?.let(String::toInt)
             ?: Deflater.DEFAULT_COMPRESSION
-        val digestAlgorithm = el.renderAttribute("digest")
-        val chunkSize = el.renderAttribute("chunk-size")
-            ?.let(Integer::decode)
-            ?: 0x10000
+        val digestAlgorithm = el.renderAttribute("digest") ?: "MD5"
 
         return FileSystemCacheConfiguration(
             path,
             maxAge,
             digestAlgorithm,
             enableCompression,
-            compressionLevel,
-            chunkSize
+            compressionLevel
         )
     }
 
@@ -50,9 +46,7 @@ class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
         Xml.of(doc, result) {
             val prefix = doc.lookupPrefix(RBCS.RBCS_NAMESPACE_URI)
             attr("xs:type", "${prefix}:fileSystemCacheType", RBCS.XML_SCHEMA_NAMESPACE_URI)
-            root?.let {
-                attr("path", it.toString())
-            }
+            attr("path", root.toString())
             attr("max-age", maxAge.toString())
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)
@@ -63,7 +57,6 @@ class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
             }?.let {
                 attr("compression-level", it.toString())
             }
-            attr("chunk-size", chunkSize.toString())
         }
         result
     }

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

@@ -1,126 +1,150 @@
 package net.woggioni.rbcs.server.cache
 
 import io.netty.buffer.ByteBuf
-import net.woggioni.rbcs.api.AsyncCloseable
-import net.woggioni.rbcs.api.CacheValueMetadata
-import net.woggioni.rbcs.common.createLogger
+import net.woggioni.rbcs.api.Cache
+import net.woggioni.rbcs.common.ByteBufInputStream
+import net.woggioni.rbcs.common.ByteBufOutputStream
+import net.woggioni.rbcs.common.RBCS.digestString
+import net.woggioni.rbcs.common.contextLogger
+import net.woggioni.jwo.JWO
+import java.nio.channels.Channels
+import java.security.MessageDigest
 import java.time.Duration
 import java.time.Instant
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.PriorityBlockingQueue
-import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicLong
-
-private class CacheKey(private val value: ByteArray) {
-    override fun equals(other: Any?) = if (other is CacheKey) {
-        value.contentEquals(other.value)
-    } else false
-
-    override fun hashCode() = value.contentHashCode()
-}
-
-class CacheEntry(
-    val metadata: CacheValueMetadata,
-    val content: ByteBuf
-)
+import java.util.zip.Deflater
+import java.util.zip.DeflaterOutputStream
+import java.util.zip.Inflater
+import java.util.zip.InflaterInputStream
 
 class InMemoryCache(
-    private val maxAge: Duration,
-    private val maxSize: Long
-) : AsyncCloseable {
+    val maxAge: Duration,
+    val maxSize: Long,
+    val digestAlgorithm: String?,
+    val compressionEnabled: Boolean,
+    val compressionLevel: Int
+) : Cache {
 
     companion object {
-        private val log = createLogger<InMemoryCache>()
+        @JvmStatic
+        private val log = contextLogger()
     }
 
     private val size = AtomicLong()
-    private val map = ConcurrentHashMap<CacheKey, CacheEntry>()
-
-    private class RemovalQueueElement(val key: CacheKey, val value: CacheEntry, val expiry: Instant) :
-        Comparable<RemovalQueueElement> {
+    private val map = ConcurrentHashMap<String, ByteBuf>()
+    
+    private class RemovalQueueElement(val key: String, val value : ByteBuf, val expiry : Instant) : Comparable<RemovalQueueElement> {
         override fun compareTo(other: RemovalQueueElement) = expiry.compareTo(other.expiry)
     }
 
     private val removalQueue = PriorityBlockingQueue<RemovalQueueElement>()
 
-    @Volatile
     private var running = true
-
-    private val closeFuture = object : CompletableFuture<Void>() {
-        init {
-            Thread.ofVirtual().name("in-memory-cache-gc").start {
-                try {
-                    while (running) {
-                        val el = removalQueue.poll(1, TimeUnit.SECONDS) ?: continue
-                        val value = el.value
-                        val now = Instant.now()
-                        if (now > el.expiry) {
-                            val removed = map.remove(el.key, value)
-                            if (removed) {
-                                updateSizeAfterRemoval(value.content)
-                                //Decrease the reference count for map
-                                value.content.release()
-                            }
-                        } else {
-                            removalQueue.put(el)
-                            Thread.sleep(minOf(Duration.between(now, el.expiry), Duration.ofSeconds(1)))
-                        }
-                    }
-                    complete(null)
-                } catch (ex: Throwable) {
-                    completeExceptionally(ex)
+    private val garbageCollector = Thread {
+        while(true) {
+            val el = removalQueue.take()
+            val buf = el.value
+            val now = Instant.now()
+            if(now > el.expiry) {
+                val removed = map.remove(el.key, buf)
+                if(removed) {
+                    updateSizeAfterRemoval(buf)
+                    //Decrease the reference count for map
+                    buf.release()
                 }
+                //Decrease the reference count for removalQueue
+                buf.release()
+            } else {
+                removalQueue.put(el)
+                Thread.sleep(minOf(Duration.between(now, el.expiry), Duration.ofSeconds(1)))
             }
         }
+    }.apply {
+        start()
     }
 
-    fun removeEldest(): Long {
-        while (true) {
+    private fun removeEldest() : Long {
+        while(true) {
             val el = removalQueue.take()
-            val value = el.value
-            val removed = map.remove(el.key, value)
-            if (removed) {
-                val newSize = updateSizeAfterRemoval(value.content)
+            val buf = el.value
+            val removed = map.remove(el.key, buf)
+            //Decrease the reference count for removalQueue
+            buf.release()
+            if(removed) {
+                val newSize = updateSizeAfterRemoval(buf)
                 //Decrease the reference count for map
-                value.content.release()
+                buf.release()
                 return newSize
             }
         }
     }
 
-    private fun updateSizeAfterRemoval(removed: ByteBuf): Long {
-        return size.updateAndGet { currentSize: Long ->
+    private fun updateSizeAfterRemoval(removed: ByteBuf) : Long {
+        return size.updateAndGet { currentSize : Long ->
             currentSize - removed.readableBytes()
         }
     }
 
-    override fun asyncClose() : CompletableFuture<Void> {
+    override fun close() {
         running = false
-        return closeFuture
+        garbageCollector.join()
     }
 
-    fun get(key: ByteArray) = map[CacheKey(key)]?.run {
-        CacheEntry(metadata, content.retainedDuplicate())
-    }
+    override fun get(key: String) =
+        (digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digestString(key.toByteArray(), md)
+            } ?: key
+                ).let { digest ->
+                map[digest]
+                    ?.let { value ->
+                    val copy = value.retainedDuplicate()
+                    copy.touch("This has to be released by the caller of the cache")
+                    if (compressionEnabled) {
+                        val inflater = Inflater()
+                        Channels.newChannel(InflaterInputStream(ByteBufInputStream(copy), inflater))
+                    } else {
+                        Channels.newChannel(ByteBufInputStream(copy))
+                    }
+                }
+            }.let {
+                CompletableFuture.completedFuture(it)
+            }
 
-    fun put(
-        key: ByteArray,
-        value: CacheEntry,
-    ) {
-        val cacheKey = CacheKey(key)
-        val oldSize = map.put(cacheKey, value)?.let { old ->
-            val result = old.content.readableBytes()
-            old.content.release()
-            result
-        } ?: 0
-        val delta = value.content.readableBytes() - oldSize
-        var newSize = size.updateAndGet { currentSize: Long ->
-            currentSize + delta
+    override fun put(key: String, content: ByteBuf) =
+        (digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digestString(key.toByteArray(), md)
+            } ?: key).let { digest ->
+            content.retain()
+            val value = if (compressionEnabled) {
+                val deflater = Deflater(compressionLevel)
+                val buf = content.alloc().buffer()
+                buf.retain()
+                DeflaterOutputStream(ByteBufOutputStream(buf), deflater).use { outputStream ->
+                    ByteBufInputStream(content).use { inputStream ->
+                        JWO.copy(inputStream, outputStream)
+                    }
+                }
+                buf
+            } else {
+                content
+            }
+            val old = map.put(digest, value)
+            val delta = value.readableBytes() - (old?.readableBytes() ?: 0)
+            var newSize = size.updateAndGet { currentSize : Long ->
+                currentSize + delta
+            }
+            removalQueue.put(RemovalQueueElement(digest, value.retain(), Instant.now().plus(maxAge)))
+            while(newSize > maxSize) {
+                newSize = removeEldest()
+            }
+        }.let {
+            CompletableFuture.completedFuture<Void>(null)
         }
-        removalQueue.put(RemovalQueueElement(cacheKey, value, Instant.now().plus(maxAge)))
-        while (newSize > maxSize) {
-            newSize = removeEldest()
-        }
-    }
 }

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

@@ -1,11 +1,5 @@
 package net.woggioni.rbcs.server.cache
 
-import io.netty.channel.ChannelFactory
-import io.netty.channel.EventLoopGroup
-import io.netty.channel.socket.DatagramChannel
-import io.netty.channel.socket.SocketChannel
-import io.netty.util.concurrent.Future
-import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.common.RBCS
 import java.time.Duration
@@ -16,19 +10,14 @@ data class InMemoryCacheConfiguration(
     val digestAlgorithm : String?,
     val compressionEnabled: Boolean,
     val compressionLevel: Int,
-    val chunkSize : Int
 ) : Configuration.Cache {
-    override fun materialize() = object : CacheHandlerFactory {
-        private val cache = InMemoryCache(maxAge, maxSize)
-
-        override fun asyncClose() = cache.asyncClose()
-
-        override fun newHandler(
-            eventLoop: EventLoopGroup,
-            socketChannelFactory: ChannelFactory<SocketChannel>,
-            datagramChannelFactory: ChannelFactory<DatagramChannel>
-        ) = InMemoryCacheHandler(cache, digestAlgorithm, compressionEnabled, compressionLevel)
-    }
+    override fun materialize() = InMemoryCache(
+        maxAge,
+        maxSize,
+        digestAlgorithm,
+        compressionEnabled,
+        compressionLevel
+    )
 
     override fun getNamespaceURI() = RBCS.RBCS_NAMESPACE_URI
 

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCacheHandler.kt

@@ -1,136 +0,0 @@
-package net.woggioni.rbcs.server.cache
-
-import io.netty.buffer.ByteBuf
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
-import net.woggioni.rbcs.api.message.CacheMessage
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-import net.woggioni.rbcs.common.ByteBufOutputStream
-import net.woggioni.rbcs.common.RBCS.processCacheKey
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-import java.util.zip.InflaterOutputStream
-
-class InMemoryCacheHandler(
-    private val cache: InMemoryCache,
-    private val digestAlgorithm: String?,
-    private val compressionEnabled: Boolean,
-    private val compressionLevel: Int
-) : SimpleChannelInboundHandler<CacheMessage>() {
-
-    private interface InProgressPutRequest : AutoCloseable {
-        val request: CachePutRequest
-        val buf: ByteBuf
-
-        fun append(buf: ByteBuf)
-    }
-
-    private inner class InProgressPlainPutRequest(ctx: ChannelHandlerContext, override val request: CachePutRequest) :
-        InProgressPutRequest {
-        override val buf = ctx.alloc().compositeBuffer()
-
-        private val stream = ByteBufOutputStream(buf).let {
-            if (compressionEnabled) {
-                DeflaterOutputStream(it, Deflater(compressionLevel))
-            } else {
-                it
-            }
-        }
-
-        override fun append(buf: ByteBuf) {
-            this.buf.addComponent(true, buf.retain())
-        }
-
-        override fun close() {
-            buf.release()
-        }
-    }
-
-    private inner class InProgressCompressedPutRequest(
-        ctx: ChannelHandlerContext,
-        override val request: CachePutRequest
-    ) : InProgressPutRequest {
-
-        override val buf = ctx.alloc().heapBuffer()
-
-        private val stream = ByteBufOutputStream(buf).let {
-            DeflaterOutputStream(it, Deflater(compressionLevel))
-        }
-
-        override fun append(buf: ByteBuf) {
-            buf.readBytes(stream, buf.readableBytes())
-        }
-
-        override fun close() {
-            stream.close()
-        }
-    }
-
-    private var inProgressPutRequest: InProgressPutRequest? = null
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
-        when (msg) {
-            is CacheGetRequest -> handleGetRequest(ctx, msg)
-            is CachePutRequest -> handlePutRequest(ctx, msg)
-            is LastCacheContent -> handleLastCacheContent(ctx, msg)
-            is CacheContent -> handleCacheContent(ctx, msg)
-            else -> ctx.fireChannelRead(msg)
-        }
-    }
-
-    private fun handleGetRequest(ctx: ChannelHandlerContext, msg: CacheGetRequest) {
-        cache.get(processCacheKey(msg.key, digestAlgorithm))?.let { value ->
-            ctx.writeAndFlush(CacheValueFoundResponse(msg.key, value.metadata))
-            if (compressionEnabled) {
-                val buf = ctx.alloc().heapBuffer()
-                InflaterOutputStream(ByteBufOutputStream(buf)).use {
-                    value.content.readBytes(it, value.content.readableBytes())
-                    value.content.release()
-                    buf.retain()
-                }
-                ctx.writeAndFlush(LastCacheContent(buf))
-            } else {
-                ctx.writeAndFlush(LastCacheContent(value.content))
-            }
-        } ?: ctx.writeAndFlush(CacheValueNotFoundResponse())
-    }
-
-    private fun handlePutRequest(ctx: ChannelHandlerContext, msg: CachePutRequest) {
-        inProgressPutRequest = if(compressionEnabled) {
-            InProgressCompressedPutRequest(ctx, msg)
-        } else {
-            InProgressPlainPutRequest(ctx, msg)
-        }
-    }
-
-    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest?.append(msg.content())
-    }
-
-    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
-        handleCacheContent(ctx, msg)
-        inProgressPutRequest?.let { inProgressRequest ->
-            inProgressPutRequest = null
-            val buf = inProgressRequest.buf
-            buf.retain()
-            inProgressRequest.close()
-            val cacheKey = processCacheKey(inProgressRequest.request.key, digestAlgorithm)
-            cache.put(cacheKey, CacheEntry(inProgressRequest.request.metadata, buf))
-            ctx.writeAndFlush(CachePutResponse(inProgressRequest.request.key))
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressPutRequest?.let { req ->
-            req.buf.release()
-            inProgressPutRequest = null
-        }
-        super.exceptionCaught(ctx, cause)
-    }
-}

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

@@ -30,17 +30,14 @@ class InMemoryCacheProvider : CacheProvider<InMemoryCacheConfiguration> {
         val compressionLevel = el.renderAttribute("compression-level")
             ?.let(String::toInt)
             ?: Deflater.DEFAULT_COMPRESSION
-        val digestAlgorithm = el.renderAttribute("digest")
-        val chunkSize = el.renderAttribute("chunk-size")
-            ?.let(Integer::decode)
-            ?: 0x10000
+        val digestAlgorithm = el.renderAttribute("digest") ?: "MD5"
+
         return InMemoryCacheConfiguration(
             maxAge,
             maxSize,
             digestAlgorithm,
             enableCompression,
-            compressionLevel,
-            chunkSize
+            compressionLevel
         )
     }
 
@@ -60,7 +57,6 @@ class InMemoryCacheProvider : CacheProvider<InMemoryCacheConfiguration> {
             }?.let {
                 attr("compression-level", it.toString())
             }
-            attr("chunk-size", chunkSize.toString())
         }
         result
     }

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

@@ -27,6 +27,8 @@ object Parser {
         val root = document.documentElement
         val anonymousUser = User("", null, emptySet(), null)
         var connection: Configuration.Connection = Configuration.Connection(
+            Duration.of(10, ChronoUnit.SECONDS),
+            Duration.of(10, ChronoUnit.SECONDS),
             Duration.of(60, ChronoUnit.SECONDS),
             Duration.of(30, ChronoUnit.SECONDS),
             Duration.of(30, ChronoUnit.SECONDS),
@@ -111,6 +113,10 @@ object Parser {
                 }
 
                 "connection" -> {
+                    val writeTimeout = child.renderAttribute("write-timeout")
+                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
+                    val readTimeout = child.renderAttribute("read-timeout")
+                        ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS)
                     val idleTimeout = child.renderAttribute("idle-timeout")
                         ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS)
                     val readIdleTimeout = child.renderAttribute("read-idle-timeout")
@@ -118,8 +124,10 @@ object Parser {
                     val writeIdleTimeout = child.renderAttribute("write-idle-timeout")
                         ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
                     val maxRequestSize = child.renderAttribute("max-request-size")
-                        ?.let(Integer::decode) ?: 0x4000000
+                        ?.let(String::toInt) ?: 67108864
                     connection = Configuration.Connection(
+                        readTimeout,
+                        writeTimeout,
                         idleTimeout,
                         readIdleTimeout,
                         writeIdleTimeout,

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

@@ -36,6 +36,8 @@ object Serializer {
             }
             node("connection") {
                 conf.connection.let { connection ->
+                    attr("read-timeout", connection.readTimeout.toString())
+                    attr("write-timeout", connection.writeTimeout.toString())
                     attr("idle-timeout", connection.idleTimeout.toString())
                     attr("read-idle-timeout", connection.readIdleTimeout.toString())
                     attr("write-idle-timeout", connection.writeIdleTimeout.toString())

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

@@ -3,7 +3,7 @@ package net.woggioni.rbcs.server.exception
 import io.netty.buffer.Unpooled
 import io.netty.channel.ChannelDuplexHandler
 import io.netty.channel.ChannelFutureListener
-import io.netty.channel.ChannelHandler.Sharable
+import io.netty.channel.ChannelHandler
 import io.netty.channel.ChannelHandlerContext
 import io.netty.handler.codec.DecoderException
 import io.netty.handler.codec.http.DefaultFullHttpResponse
@@ -17,16 +17,10 @@ import net.woggioni.rbcs.api.exception.CacheException
 import net.woggioni.rbcs.api.exception.ContentTooLargeException
 import net.woggioni.rbcs.common.contextLogger
 import net.woggioni.rbcs.common.debug
-import net.woggioni.rbcs.common.log
-import org.slf4j.event.Level
-import org.slf4j.spi.LoggingEventBuilder
-import java.net.ConnectException
-import java.net.SocketException
-import javax.net.ssl.SSLException
 import javax.net.ssl.SSLPeerUnverifiedException
 
-@Sharable
-object ExceptionHandler : ChannelDuplexHandler() {
+@ChannelHandler.Sharable
+class ExceptionHandler : ChannelDuplexHandler() {
     private val log = contextLogger()
 
     private val NOT_AUTHORIZED: FullHttpResponse = DefaultFullHttpResponse(
@@ -35,6 +29,12 @@ object ExceptionHandler : ChannelDuplexHandler() {
         headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
     }
 
+    private val TOO_BIG: FullHttpResponse = DefaultFullHttpResponse(
+        HttpVersion.HTTP_1_1, HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE, Unpooled.EMPTY_BUFFER
+    ).apply {
+        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
+    }
+
     private val NOT_AVAILABLE: FullHttpResponse = DefaultFullHttpResponse(
         HttpVersion.HTTP_1_1, HttpResponseStatus.SERVICE_UNAVAILABLE, Unpooled.EMPTY_BUFFER
     ).apply {
@@ -47,26 +47,10 @@ object ExceptionHandler : ChannelDuplexHandler() {
         headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
     }
 
-    private val TOO_BIG: FullHttpResponse = DefaultFullHttpResponse(
-        HttpVersion.HTTP_1_1, HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE, Unpooled.EMPTY_BUFFER
-    ).apply {
-        headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-    }
-
     override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
         when (cause) {
             is DecoderException -> {
-                log.debug(cause.message, cause)
-                ctx.close()
-            }
-
-            is ConnectException -> {
                 log.error(cause.message, cause)
-                ctx.writeAndFlush(SERVER_ERROR.retainedDuplicate())
-            }
-
-            is SocketException -> {
-                log.debug(cause.message, cause)
                 ctx.close()
             }
 
@@ -75,19 +59,10 @@ object ExceptionHandler : ChannelDuplexHandler() {
                     .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
             }
 
-            is SSLException -> {
-                log.debug(cause.message, cause)
-                ctx.close()
-            }
-
             is ContentTooLargeException -> {
-                log.log(Level.DEBUG, ctx.channel()) { builder : LoggingEventBuilder ->
-                    builder.setMessage("Request body is too large")
-                }
                 ctx.writeAndFlush(TOO_BIG.retainedDuplicate())
                     .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
             }
-
             is ReadTimeoutException -> {
                 log.debug {
                     val channelId = ctx.channel().id().asShortText()
@@ -95,7 +70,6 @@ object ExceptionHandler : ChannelDuplexHandler() {
                 }
                 ctx.close()
             }
-
             is WriteTimeoutException -> {
                 log.debug {
                     val channelId = ctx.channel().id().asShortText()
@@ -103,13 +77,11 @@ object ExceptionHandler : ChannelDuplexHandler() {
                 }
                 ctx.close()
             }
-
             is CacheException -> {
                 log.error(cause.message, cause)
                 ctx.writeAndFlush(NOT_AVAILABLE.retainedDuplicate())
                     .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
             }
-
             else -> {
                 log.error(cause.message, cause)
                 ctx.writeAndFlush(SERVER_ERROR.retainedDuplicate())

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/CacheContentHandler.kt

@@ -1,28 +0,0 @@
-package net.woggioni.rbcs.server.handler
-
-import io.netty.channel.ChannelHandler.Sharable
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.handler.codec.http.HttpContent
-import io.netty.handler.codec.http.LastHttpContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-
-@Sharable
-object CacheContentHandler : SimpleChannelInboundHandler<HttpContent>() {
-    val NAME = this::class.java.name
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: HttpContent) {
-        when(msg) {
-            is LastHttpContent -> {
-                ctx.fireChannelRead(LastCacheContent(msg.content().retain()))
-                ctx.pipeline().remove(this)
-            }
-            else -> ctx.fireChannelRead(CacheContent(msg.content().retain()))
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) {
-        super.exceptionCaught(ctx, cause)
-    }
-}

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/MaxRequestSizeHandler.kt

@@ -1,40 +0,0 @@
-package net.woggioni.rbcs.server.handler
-
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.handler.codec.http.HttpContent
-import io.netty.handler.codec.http.HttpRequest
-import net.woggioni.rbcs.api.exception.ContentTooLargeException
-
-
-class MaxRequestSizeHandler(private val maxRequestSize : Int) : ChannelInboundHandlerAdapter() {
-    companion object {
-        val NAME = MaxRequestSizeHandler::class.java.name
-    }
-
-    private var cumulativeSize = 0
-
-    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        when(msg) {
-            is HttpRequest -> {
-                cumulativeSize = 0
-                ctx.fireChannelRead(msg)
-            }
-            is HttpContent -> {
-                val exceeded = cumulativeSize > maxRequestSize
-                if(!exceeded) {
-                    cumulativeSize += msg.content().readableBytes()
-                }
-                if(cumulativeSize > maxRequestSize) {
-                    msg.release()
-                    if(!exceeded) {
-                        ctx.fireExceptionCaught(ContentTooLargeException("Request body is too large", null))
-                    }
-                } else {
-                    ctx.fireChannelRead(msg)
-                }
-            }
-            else -> ctx.fireChannelRead(msg)
-        }
-    }
-}

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

@@ -1,148 +1,95 @@
 package net.woggioni.rbcs.server.handler
 
-import io.netty.channel.ChannelDuplexHandler
+import io.netty.buffer.Unpooled
+import io.netty.channel.ChannelFutureListener
+import io.netty.channel.ChannelHandler
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelPromise
+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.HttpHeaderNames
 import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpHeaders
 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.HttpVersion
-import net.woggioni.rbcs.api.CacheValueMetadata
-import net.woggioni.rbcs.api.message.CacheMessage
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
-import net.woggioni.rbcs.common.warn
+import io.netty.handler.codec.http.LastHttpContent
+import io.netty.handler.stream.ChunkedNioStream
+import net.woggioni.rbcs.api.Cache
+import net.woggioni.rbcs.common.contextLogger
+import net.woggioni.rbcs.server.debug
+import net.woggioni.rbcs.server.warn
+import java.nio.channels.FileChannel
 import java.nio.file.Path
-import java.util.Locale
 
-class ServerHandler(private val serverPrefix: Path) :
-    ChannelDuplexHandler() {
+@ChannelHandler.Sharable
+class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
+    SimpleChannelInboundHandler<FullHttpRequest>() {
 
-    companion object {
-        private val log = createLogger<ServerHandler>()
-        val NAME = this::class.java.name
-    }
+    private val log = contextLogger()
 
-    private var httpVersion = HttpVersion.HTTP_1_1
-    private var keepAlive = true
-
-    private fun resetRequestMetadata() {
-        httpVersion = HttpVersion.HTTP_1_1
-        keepAlive = true
-    }
-
-    private fun setRequestMetadata(req: HttpRequest) {
-        httpVersion = req.protocolVersion()
-        keepAlive = HttpUtil.isKeepAlive(req)
-    }
-
-    private fun setKeepAliveHeader(headers: HttpHeaders) {
-        if (!keepAlive) {
-            headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
-        } else {
-            headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-        }
-    }
-
-
-    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        when (msg) {
-            is HttpRequest -> handleRequest(ctx, msg)
-            else -> super.channelRead(ctx, msg)
-        }
-    }
-
-
-    override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise?) {
-        if (msg is CacheMessage) {
-            try {
-                when (msg) {
-                    is CachePutResponse -> {
-                        val response = DefaultFullHttpResponse(httpVersion, HttpResponseStatus.CREATED)
-                        val keyBytes = msg.key.toByteArray(Charsets.UTF_8)
-                        response.headers().apply {
-                            set(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.TEXT_PLAIN)
-                            set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                        }
-                        setKeepAliveHeader(response.headers())
-                        ctx.write(response)
-                        val buf = ctx.alloc().buffer(keyBytes.size).apply {
-                            writeBytes(keyBytes)
-                        }
-                        ctx.writeAndFlush(DefaultLastHttpContent(buf))
-                    }
-
-                    is CacheValueNotFoundResponse -> {
-                        val response = DefaultFullHttpResponse(httpVersion, HttpResponseStatus.NOT_FOUND)
-                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                        setKeepAliveHeader(response.headers())
-                        ctx.writeAndFlush(response)
-                    }
-
-                    is CacheValueFoundResponse -> {
-                        val response = DefaultHttpResponse(httpVersion, HttpResponseStatus.OK)
-                        response.headers().apply {
-                            set(HttpHeaderNames.CONTENT_TYPE, msg.metadata.mimeType ?: HttpHeaderValues.APPLICATION_OCTET_STREAM)
-                            msg.metadata.contentDisposition?.let { contentDisposition ->
-                                set(HttpHeaderNames.CONTENT_DISPOSITION, contentDisposition)
-                            }
-                        }
-                        setKeepAliveHeader(response.headers())
-                        response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                        ctx.writeAndFlush(response)
-                    }
-
-                    is LastCacheContent -> {
-                        ctx.writeAndFlush(DefaultLastHttpContent(msg.content()))
-                    }
-
-                    is CacheContent -> {
-                        ctx.writeAndFlush(DefaultHttpContent(msg.content()))
-                    }
-
-                    else -> throw UnsupportedOperationException("This should never happen")
-                }.let { channelFuture ->
-                    if (promise != null) {
-                        channelFuture.addListener {
-                            if (it.isSuccess) promise.setSuccess()
-                            else promise.setFailure(it.cause())
-                        }
-                    }
-                }
-            } finally {
-                resetRequestMetadata()
-            }
-        } else super.write(ctx, msg, promise)
-    }
-
-
-    private fun handleRequest(ctx: ChannelHandlerContext, msg: HttpRequest) {
-        setRequestMetadata(msg)
+    override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
+        val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
         val method = msg.method()
         if (method === HttpMethod.GET) {
-            val path = Path.of(msg.uri()).normalize()
-            if (path.startsWith(serverPrefix)) {
-                val relativePath = serverPrefix.relativize(path)
-                val key = relativePath.toString()
-                ctx.pipeline().addAfter(NAME, CacheContentHandler.NAME, CacheContentHandler)
-                key.let(::CacheGetRequest)
-                    .let(ctx::fireChannelRead)
-                    ?: ctx.channel().write(CacheValueNotFoundResponse())
+            val path = Path.of(msg.uri())
+            val prefix = path.parent
+            val key = path.fileName?.toString() ?: let {
+                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
+                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
+                ctx.writeAndFlush(response)
+                return
+            }
+            if (serverPrefix == prefix) {
+                cache.get(key).thenApply { channel ->
+                    if(channel != null) {
+                        log.debug(ctx) {
+                            "Cache hit for key '$key'"
+                        }
+                        val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
+                        response.headers()[HttpHeaderNames.CONTENT_TYPE] = HttpHeaderValues.APPLICATION_OCTET_STREAM
+                        if (!keepAlive) {
+                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
+                        } else {
+                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
+                        }
+                        ctx.write(response)
+                        when (channel) {
+                            is FileChannel -> {
+                                val content = DefaultFileRegion(channel, 0, channel.size())
+                                if (keepAlive) {
+                                    ctx.write(content)
+                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
+                                } else {
+                                    ctx.writeAndFlush(content)
+                                        .addListener(ChannelFutureListener.CLOSE)
+                                }
+                            }
+                            else -> {
+                                val content = ChunkedNioStream(channel)
+                                if (keepAlive) {
+                                    ctx.write(content).addListener {
+                                        content.close()
+                                    }
+                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT.retainedDuplicate())
+                                } else {
+                                    ctx.writeAndFlush(content)
+                                        .addListener(ChannelFutureListener.CLOSE)
+                                }
+                            }
+                        }
+                    } else {
+                        log.debug(ctx) {
+                            "Cache miss for key '$key'"
+                        }
+                        val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
+                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
+                        ctx.writeAndFlush(response)
+                    }
+                }.whenComplete { _, ex -> ex?.let(ctx::fireExceptionCaught) }
             } else {
                 log.warn(ctx) {
                     "Got request for unhandled path '${msg.uri()}'"
@@ -152,21 +99,24 @@ class ServerHandler(private val serverPrefix: Path) :
                 ctx.writeAndFlush(response)
             }
         } else if (method === HttpMethod.PUT) {
-            val path = Path.of(msg.uri()).normalize()
-            if (path.startsWith(serverPrefix)) {
-                val relativePath = serverPrefix.relativize(path)
-                val key = relativePath.toString()
+            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"
                 }
-                ctx.pipeline().addAfter(NAME, CacheContentHandler.NAME, CacheContentHandler)
-                path.fileName?.toString()
-                    ?.let {
-                        val mimeType = HttpUtil.getMimeType(msg)?.toString()
-                        CachePutRequest(key, CacheValueMetadata(msg.headers().get(HttpHeaderNames.CONTENT_DISPOSITION), mimeType))
-                    }
-                    ?.let(ctx::fireChannelRead)
-                    ?: ctx.channel().write(CacheValueNotFoundResponse())
+                cache.put(key, msg.content()).thenRun {
+                    val response = DefaultFullHttpResponse(
+                        msg.protocolVersion(), HttpResponseStatus.CREATED,
+                        Unpooled.copiedBuffer(key.toByteArray())
+                    )
+                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
+                    ctx.writeAndFlush(response)
+                }.whenComplete { _, ex ->
+                    ctx.fireExceptionCaught(ex)
+                }
             } else {
                 log.warn(ctx) {
                     "Got request for unhandled path '${msg.uri()}'"
@@ -175,8 +125,30 @@ class ServerHandler(private val serverPrefix: Path) :
                 response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
                 ctx.writeAndFlush(response)
             }
-        } else if (method == HttpMethod.TRACE) {
-            super.channelRead(ctx, msg)
+        } else if(method == HttpMethod.TRACE) {
+            val replayedRequestHead = ctx.alloc().buffer()
+            replayedRequestHead.writeCharSequence("TRACE ${Path.of(msg.uri())} ${msg.protocolVersion().text()}\r\n", Charsets.US_ASCII)
+            msg.headers().forEach { (key, value) ->
+                replayedRequestHead.apply {
+                    writeCharSequence(key, Charsets.US_ASCII)
+                    writeCharSequence(": ", Charsets.US_ASCII)
+                    writeCharSequence(value, Charsets.UTF_8)
+                    writeCharSequence("\r\n", Charsets.US_ASCII)
+                }
+            }
+            replayedRequestHead.writeCharSequence("\r\n", Charsets.US_ASCII)
+            val requestBody = msg.content()
+            requestBody.retain()
+            val responseBody = ctx.alloc().compositeBuffer(2).apply {
+                addComponents(true, replayedRequestHead)
+                addComponents(true, requestBody)
+            }
+            val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK, responseBody)
+            response.headers().apply {
+                set(HttpHeaderNames.CONTENT_TYPE, "message/http")
+                set(HttpHeaderNames.CONTENT_LENGTH, responseBody.readableBytes())
+            }
+            ctx.writeAndFlush(response)
         } else {
             log.warn(ctx) {
                 "Got request with unhandled method '${msg.method().name()}'"
@@ -186,44 +158,4 @@ class ServerHandler(private val serverPrefix: Path) :
             ctx.writeAndFlush(response)
         }
     }
-
-
-    data class ContentDisposition(val type: Type?, val fileName: String?) {
-        enum class Type {
-            attachment, `inline`;
-
-            companion object {
-                @JvmStatic
-                fun parse(maybeString: String?) = maybeString.let { s ->
-                    try {
-                        java.lang.Enum.valueOf(Type::class.java, s)
-                    } catch (ex: IllegalArgumentException) {
-                        null
-                    }
-                }
-            }
-        }
-
-        companion object {
-            @JvmStatic
-            fun parse(contentDisposition: String) : ContentDisposition {
-                val parts = contentDisposition.split(";").dropLastWhile { it.isEmpty() }.toTypedArray()
-                val dispositionType = parts[0].trim { it <= ' ' }.let(Type::parse)  // Get the type (e.g., attachment)
-
-                var filename: String? = null
-                for (i in 1..<parts.size) {
-                    val part = parts[i].trim { it <= ' ' }
-                    if (part.lowercase(Locale.getDefault()).startsWith("filename=")) {
-                        filename = part.substring("filename=".length).trim { it <= ' ' }.replace("\"", "")
-                        break
-                    }
-                }
-                return ContentDisposition(dispositionType, filename)
-            }
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        super.exceptionCaught(ctx, cause)
-    }
 }

rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/TraceHandler.kt

@@ -1,54 +0,0 @@
-package net.woggioni.rbcs.server.handler
-
-import io.netty.channel.ChannelHandler.Sharable
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.handler.codec.http.DefaultHttpResponse
-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.HttpRequest
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.LastHttpContent
-import java.nio.file.Path
-
-@Sharable
-object TraceHandler : ChannelInboundHandlerAdapter() {
-    val NAME = this::class.java.name
-    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        when(msg) {
-            is HttpRequest -> {
-                val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
-                response.headers().apply {
-                    set(HttpHeaderNames.CONTENT_TYPE, "message/http")
-                    set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                }
-                ctx.write(response)
-                val replayedRequestHead = ctx.alloc().buffer()
-                replayedRequestHead.writeCharSequence(
-                    "TRACE ${Path.of(msg.uri())} ${msg.protocolVersion().text()}\r\n",
-                    Charsets.US_ASCII
-                )
-                msg.headers().forEach { (key, value) ->
-                    replayedRequestHead.apply {
-                        writeCharSequence(key, Charsets.US_ASCII)
-                        writeCharSequence(": ", Charsets.US_ASCII)
-                        writeCharSequence(value, Charsets.UTF_8)
-                        writeCharSequence("\r\n", Charsets.US_ASCII)
-                    }
-                }
-                replayedRequestHead.writeCharSequence("\r\n", Charsets.US_ASCII)
-                ctx.writeAndFlush(replayedRequestHead)
-            }
-            is LastHttpContent -> {
-                ctx.writeAndFlush(msg)
-            }
-            is HttpContent -> ctx.writeAndFlush(msg)
-            else -> super.channelRead(ctx, msg)
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) {
-        super.exceptionCaught(ctx, cause)
-    }
-}

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

@@ -1,7 +1,7 @@
 package net.woggioni.rbcs.server.throttling
 
-import net.woggioni.jwo.Bucket
 import net.woggioni.rbcs.api.Configuration
+import net.woggioni.jwo.Bucket
 import java.net.InetSocketAddress
 import java.util.Arrays
 import java.util.concurrent.ConcurrentHashMap

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

@@ -1,32 +1,31 @@
 package net.woggioni.rbcs.server.throttling
 
+import io.netty.channel.ChannelHandler.Sharable
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.HttpContent
 import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpVersion
+import net.woggioni.rbcs.api.Configuration
+import net.woggioni.rbcs.common.contextLogger
+import net.woggioni.rbcs.server.RemoteBuildCacheServer
 import net.woggioni.jwo.Bucket
 import net.woggioni.jwo.LongMath
-import net.woggioni.rbcs.api.Configuration
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.server.RemoteBuildCacheServer
 import java.net.InetSocketAddress
 import java.time.Duration
 import java.time.temporal.ChronoUnit
 import java.util.concurrent.TimeUnit
 
 
-class ThrottlingHandler(private val bucketManager : BucketManager,
-                        private val connectionConfiguration : Configuration.Connection) : ChannelInboundHandlerAdapter() {
+@Sharable
+class ThrottlingHandler(cfg: Configuration) :
+    ChannelInboundHandlerAdapter() {
 
-    private companion object {
-        private val log = createLogger<ThrottlingHandler>()
-    }
+    private val log = contextLogger()
+    private val bucketManager = BucketManager.from(cfg)
 
-    private var queuedContent : MutableList<HttpContent>? = null
+    private val connectionConfiguration = cfg.connection
 
     /**
      * If the suggested waiting time from the bucket is lower than this
@@ -39,38 +38,29 @@ class ThrottlingHandler(private val bucketManager : BucketManager,
         connectionConfiguration.writeIdleTimeout
     ).dividedBy(2)
 
-
-
     override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
-        if(msg is HttpRequest) {
-            val buckets = mutableListOf<Bucket>()
-            val user = ctx.channel().attr(RemoteBuildCacheServer.userAttribute).get()
-            if (user != null) {
-                bucketManager.getBucketByUser(user)?.let(buckets::addAll)
+        val buckets = mutableListOf<Bucket>()
+        val user = ctx.channel().attr(RemoteBuildCacheServer.userAttribute).get()
+        if (user != null) {
+            bucketManager.getBucketByUser(user)?.let(buckets::addAll)
+        }
+        val groups = ctx.channel().attr(RemoteBuildCacheServer.groupAttribute).get() ?: emptySet()
+        if (groups.isNotEmpty()) {
+            groups.forEach { group ->
+                bucketManager.getBucketByGroup(group)?.let(buckets::add)
             }
-            val groups = ctx.channel().attr(RemoteBuildCacheServer.groupAttribute).get() ?: emptySet()
-            if (groups.isNotEmpty()) {
-                groups.forEach { group ->
-                    bucketManager.getBucketByGroup(group)?.let(buckets::add)
-                }
-            }
-            if (user == null && groups.isEmpty()) {
-                bucketManager.getBucketByAddress(ctx.channel().remoteAddress() as InetSocketAddress)?.let(buckets::add)
-            }
-            if (buckets.isEmpty()) {
-                super.channelRead(ctx, msg)
-            } else {
-                handleBuckets(buckets, ctx, msg, true)
-            }
-            ctx.channel().id()
-        } else if(msg is HttpContent) {
-            queuedContent?.add(msg) ?: super.channelRead(ctx, msg)
+        }
+        if (user == null && groups.isEmpty()) {
+            bucketManager.getBucketByAddress(ctx.channel().remoteAddress() as InetSocketAddress)?.let(buckets::add)
+        }
+        if (buckets.isEmpty()) {
+            return super.channelRead(ctx, msg)
         } else {
-            super.channelRead(ctx, msg)
+            handleBuckets(buckets, ctx, msg, true)
         }
     }
 
-    private fun handleBuckets(buckets: List<Bucket>, ctx: ChannelHandlerContext, msg: Any, delayResponse: Boolean) {
+    private fun handleBuckets(buckets : List<Bucket>, ctx : ChannelHandlerContext, msg : Any, delayResponse : Boolean) {
         var nextAttempt = -1L
         for (bucket in buckets) {
             val bucketNextAttempt = bucket.removeTokensWithEstimate(1)
@@ -78,25 +68,17 @@ class ThrottlingHandler(private val bucketManager : BucketManager,
                 nextAttempt = bucketNextAttempt
             }
         }
-        if (nextAttempt < 0) {
+        if(nextAttempt < 0) {
             super.channelRead(ctx, msg)
-            queuedContent?.let {
-                for(content in it) {
-                    super.channelRead(ctx, content)
-                }
-                queuedContent = null
-            }
+            return
+        }
+        val waitDuration = Duration.of(LongMath.ceilDiv(nextAttempt, 100_000_000L) * 100L, ChronoUnit.MILLIS)
+        if (delayResponse && waitDuration < waitThreshold) {
+            ctx.executor().schedule({
+                handleBuckets(buckets, ctx, msg, false)
+            }, waitDuration.toMillis(), TimeUnit.MILLISECONDS)
         } else {
-            val waitDuration = Duration.of(LongMath.ceilDiv(nextAttempt, 100_000_000L) * 100L, ChronoUnit.MILLIS)
-            if (delayResponse && waitDuration < waitThreshold) {
-                this.queuedContent = mutableListOf()
-                ctx.executor().schedule({
-                    handleBuckets(buckets, ctx, msg, false)
-                }, waitDuration.toMillis(), TimeUnit.MILLISECONDS)
-            } else {
-                this.queuedContent = null
-                sendThrottledResponse(ctx, waitDuration)
-            }
+            sendThrottledResponse(ctx, waitDuration)
         }
     }
 

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

@@ -4,5 +4,16 @@
              xmlns:rbcs="urn:net.woggioni.rbcs.server"
              xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd">
     <bind host="127.0.0.1" port="8080" incoming-connections-backlog-size="1024"/>
-    <cache xs:type="rbcs:fileSystemCacheType" path="${sys:java.io.tmpdir}/rbcs" max-age="P7D"/>
+    <connection
+            max-request-size="67108864"
+            idle-timeout="PT30S"
+            read-timeout="PT10S"
+            write-timeout="PT10S"
+            read-idle-timeout="PT60S"
+            write-idle-timeout="PT60S"/>
+    <event-executor use-virtual-threads="true"/>
+    <cache xs:type="rbcs:fileSystemCacheType" path="/tmp/rbcs" max-age="P7D"/>
+    <authentication>
+        <none/>
+    </authentication>
 </rbcs:server>

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

@@ -3,27 +3,14 @@
            xmlns:xs="http://www.w3.org/2001/XMLSchema"
            xmlns:rbcs="urn:net.woggioni.rbcs.server"
            elementFormDefault="unqualified">
-    <xs:element name="server" type="rbcs:serverType">
-        <xs:annotation>
-            <xs:documentation>
-                Root element containing the server configuration
-            </xs:documentation>
-        </xs:annotation>
-    </xs:element>
+    <xs:element name="server" type="rbcs:serverType"/>
 
     <xs:complexType name="serverType">
         <xs:sequence minOccurs="0">
             <xs:element name="bind" type="rbcs:bindType" maxOccurs="1"/>
             <xs:element name="connection" type="rbcs:connectionType" minOccurs="0" maxOccurs="1"/>
             <xs:element name="event-executor" type="rbcs:eventExecutorType" minOccurs="0" maxOccurs="1"/>
-            <xs:element name="cache" type="rbcs:cacheType" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        Cache storage backend implementation to use, more implementations can be added through
-                        the use of plugins
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="cache" type="rbcs:cacheType" maxOccurs="1"/>
             <xs:element name="authorization" type="rbcs:authorizationType" minOccurs="0">
                 <xs:key name="userId">
                     <xs:selector xpath="users/user"/>
@@ -34,279 +21,73 @@
                     <xs:field xpath="@ref"/>
                 </xs:keyref>
             </xs:element>
-            <xs:element name="authentication" type="rbcs:authenticationType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        Mechanism to use to assign a username to a specific client
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="tls" type="rbcs:tlsType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        Use TLS to encrypt all the communications
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="authentication" type="rbcs:authenticationType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="tls" type="rbcs:tlsType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
-        <xs:attribute name="path" type="xs:string" use="optional">
-            <xs:annotation>
-                <xs:documentation>
-                    URI path prefix, if your rbcs is hosted at "http://www.example.com"
-                    and this parameter is set to "cache", then all the requests will need to be sent at
-                    "http://www.example.com/cache/KEY", where "KEY" is the cache entry KEY
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="path" type="xs:string" use="optional"/>
     </xs:complexType>
 
     <xs:complexType name="bindType">
-        <xs:attribute name="host" type="xs:token" use="required">
-            <xs:annotation>
-                <xs:documentation>Server bind address</xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="port" type="xs:unsignedShort" use="required">
-            <xs:annotation>
-                <xs:documentation>Server port number</xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="incoming-connections-backlog-size" type="xs:unsignedInt" use="optional" default="1024">
-            <xs:annotation>
-                <xs:documentation>
-                    The maximum queue length for incoming connection indications (a request to connect) is set to
-                    the backlog parameter. If a connection indication arrives when the queue is full,
-                    the connection is refused.
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="host" type="xs:token" use="required"/>
+        <xs:attribute name="port" type="xs:unsignedShort" use="required"/>
+        <xs:attribute name="incoming-connections-backlog-size" type="xs:unsignedInt" use="optional" default="1024"/>
     </xs:complexType>
 
     <xs:complexType name="connectionType">
-        <xs:attribute name="idle-timeout" type="xs:duration" use="optional" default="PT30S">
-            <xs:annotation>
-                <xs:documentation>
-                    The server will close the connection with the client
-                    when neither a read nor a write was performed for the specified period of time.
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="read-idle-timeout" type="xs:duration" use="optional" default="PT60S">
-            <xs:annotation>
-                <xs:documentation>
-                    The server will close the connection with the client
-                    when no read was performed for the specified period of time.
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="write-idle-timeout" type="xs:duration" use="optional" default="PT60S">
-            <xs:annotation>
-                <xs:documentation>
-                    The server will close the connection with the client
-                    when no write was performed for the specified period of time.
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="max-request-size" type="rbcs:byteSizeType" use="optional" default="0x4000000">
-            <xs:annotation>
-                <xs:documentation>
-                    The maximum request body size the server will accept from a client
-                    (if exceeded the server returns 413 HTTP status code)
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT0S"/>
+        <xs:attribute name="idle-timeout" type="xs:duration" use="optional" default="PT30S"/>
+        <xs:attribute name="read-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
+        <xs:attribute name="write-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
+        <xs:attribute name="max-request-size" type="xs:unsignedInt" use="optional" default="67108864"/>
     </xs:complexType>
 
     <xs:complexType name="eventExecutorType">
-        <xs:attribute name="use-virtual-threads" type="xs:boolean" use="optional" default="true">
-            <xs:annotation>
-                <xs:documentation>
-                    Whether or not to use virtual threads for the execution of the core server handler
-                    (not for the I/O operations)
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="use-virtual-threads" type="xs:boolean" use="optional" default="true"/>
     </xs:complexType>
 
     <xs:complexType name="cacheType" abstract="true"/>
 
     <xs:complexType name="inMemoryCacheType">
-        <xs:annotation>
-            <xs:documentation>
-                A simple cache implementation that uses a java.util.ConcurrentHashMap as a storage backend
-            </xs:documentation>
-        </xs:annotation>
         <xs:complexContent>
             <xs:extension base="rbcs:cacheType">
-                <xs:attribute name="max-age" type="xs:duration" default="P1D">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Values will be removed from the cache after this amount of time
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="max-size" type="rbcs:byteSizeType" default="0x1000000">
-                    <xs:annotation>
-                        <xs:documentation>
-                            The maximum allowed total size of the cache in bytes, old values will be purged from the cache
-                            when the insertion of a new value causes this limit to be exceeded
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="digest" type="xs:token">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Hashing algorithm to apply to the key. If omitted, no hashing is performed.
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="enable-compression" type="xs:boolean" default="true">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Enable deflate compression for stored cache elements
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="compression-level" type="rbcs:compressionLevelType" default="-1">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Deflate compression level to use for cache compression,
-                            use -1 to use the default compression level of java.util.zip.Deflater
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="chunk-size" type="rbcs:byteSizeType" default="0x10000">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Maximum byte size of socket write calls
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
+                <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
+                <xs:attribute name="max-size" type="xs:token" default="0x1000000"/>
+                <xs:attribute name="digest" type="xs:token" default="MD5"/>
+                <xs:attribute name="enable-compression" type="xs:boolean" default="true"/>
+                <xs:attribute name="compression-level" type="xs:byte" default="-1"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>
 
     <xs:complexType name="fileSystemCacheType">
-        <xs:annotation>
-            <xs:documentation>
-                A simple cache implementation that stores data in a folder on the filesystem
-            </xs:documentation>
-        </xs:annotation>
         <xs:complexContent>
             <xs:extension base="rbcs:cacheType">
-                <xs:attribute name="path" type="xs:string" use="optional">
-                    <xs:annotation>
-                        <xs:documentation>
-                            File system path that will be used to store the cache data files
-                            (it will be created if it doesn't already exist)
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="max-age" type="xs:duration" default="P1D">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Values will be removed from the cache after this amount of time
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="digest" type="xs:token" default="SHA3-224">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Hashing algorithm to apply to the key. If omitted, no hashing is performed.
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="enable-compression" type="xs:boolean" default="true">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Enable deflate compression for stored cache elements
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="compression-level" type="rbcs:compressionLevelType" default="-1">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Deflate compression level to use for cache compression,
-                            use -1 to use the default compression level of java.util.zip.Deflater
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
-                <xs:attribute name="chunk-size" type="rbcs:byteSizeType" default="0x10000">
-                    <xs:annotation>
-                        <xs:documentation>
-                            Maximum byte size of a cache value that will be stored in memory
-                            (reduce it to reduce memory consumption, increase it for increased throughput)
-                        </xs:documentation>
-                    </xs:annotation>
-                </xs:attribute>
+                <xs:attribute name="path" type="xs:string" use="required"/>
+                <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
+                <xs:attribute name="digest" type="xs:token" default="MD5"/>
+                <xs:attribute name="enable-compression" type="xs:boolean" default="true"/>
+                <xs:attribute name="compression-level" type="xs:byte" default="-1"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>
 
     <xs:complexType name="tlsCertificateAuthorizationType">
         <xs:sequence>
-            <xs:element name="group-extractor" type="rbcs:X500NameExtractorType" minOccurs="0">
-                <xs:annotation>
-                    <xs:documentation>
-                        A regex based extractor that will be used to determine which group the client belongs to,
-                        based on the X.500 name of the subject field in the client's TLS certificate.
-                        When this is set RBAC works even if the user isn't listed in the &lt;users/&gt; section as
-                        the client will be assigned role solely based on the group he is found to belong to.
-                        Note that this does not allow for a client to be part of multiple groups.
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="user-extractor" type="rbcs:X500NameExtractorType" minOccurs="0">
-                <xs:annotation>
-                    <xs:documentation>
-                        A regex based extractor that will be used to assign a user to a connected client,
-                        based on the X.500 name of the subject field in the client's TLS certificate.
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="group-extractor" type="rbcs:X500NameExtractorType" minOccurs="0"/>
+            <xs:element name="user-extractor" type="rbcs:X500NameExtractorType" minOccurs="0"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="X500NameExtractorType">
-        <xs:annotation>
-            <xs:documentation>
-                Extract informations from a client TLS certificates using
-                regular expressions applied to the X.500 name "Subject" field
-            </xs:documentation>
-        </xs:annotation>
-        <xs:attribute name="attribute-name" type="xs:token">
-            <xs:annotation>
-                <xs:documentation>
-                    X.500 name attribute to apply the regex
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="pattern" type="xs:token">
-            <xs:annotation>
-                <xs:documentation>
-                    Regex that wil be applied to the attribute value,
-                    use regex groups to extract relevant data
-                    (note that only the first group that appears in the regex is used)
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="attribute-name" type="xs:token"/>
+        <xs:attribute name="pattern" type="xs:token"/>
     </xs:complexType>
 
     <xs:complexType name="authorizationType">
         <xs:all>
-            <xs:element name="users" type="rbcs:usersType">
-                <xs:annotation>
-                    <xs:documentation>
-                        List of users registered in the application
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="users" type="rbcs:usersType"/>
             <xs:element name="groups" type="rbcs:groupsType">
-                <xs:annotation>
-                    <xs:documentation>
-                        List of user groups registered in the application
-                    </xs:documentation>
-                </xs:annotation>
                 <xs:unique name="groupKey">
                     <xs:selector xpath="group"/>
                     <xs:field xpath="@name"/>
@@ -316,150 +97,48 @@
     </xs:complexType>
 
     <xs:complexType name="authenticationType">
-        <xs:annotation>
-            <xs:documentation>
-                Authentication mechanism to assign usernames and groups to clients
-            </xs:documentation>
-        </xs:annotation>
         <xs:choice>
-            <xs:element name="basic">
-                <xs:annotation>
-                    <xs:documentation>
-                        Enable HTTP basic authentication
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="client-certificate" type="rbcs:tlsCertificateAuthorizationType">
-                <xs:annotation>
-                    <xs:documentation>
-                        Enable TLS certificate authentication
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="none">
-                <xs:annotation>
-                    <xs:documentation>
-                        Disable authentication altogether
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="basic"/>
+            <xs:element name="client-certificate" type="rbcs:tlsCertificateAuthorizationType"/>
+            <xs:element name="none"/>
         </xs:choice>
     </xs:complexType>
 
     <xs:complexType name="quotaType">
-        <xs:annotation>
-            <xs:documentation>
-                Defines a quota for a user or a group
-            </xs:documentation>
-        </xs:annotation>
-        <xs:attribute name="calls" type="xs:positiveInteger" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    Maximum number of allowed calls in a given period
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="period" type="xs:duration" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    The period length
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="max-available-calls" type="xs:positiveInteger" use="optional">
-            <xs:annotation>
-                <xs:documentation>
-                    Maximum number of available calls that can be accumulated
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="initial-available-calls" type="xs:unsignedInt" use="optional">
-            <xs:annotation>
-                <xs:documentation>
-                    Number of available calls for users at their first call
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="calls" type="xs:positiveInteger" use="required"/>
+        <xs:attribute name="period" type="xs:duration" use="required"/>
+        <xs:attribute name="max-available-calls" type="xs:positiveInteger" use="optional"/>
+        <xs:attribute name="initial-available-calls" type="xs:unsignedInt" use="optional"/>
     </xs:complexType>
 
     <xs:complexType name="anonymousUserType">
-        <xs:annotation>
-            <xs:documentation>
-                Placeholder for a client that is not authenticated
-            </xs:documentation>
-        </xs:annotation>
         <xs:sequence>
-            <xs:element name="quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        Calls quota for the user
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="userType">
-        <xs:annotation>
-            <xs:documentation>
-                An authenticated user
-            </xs:documentation>
-        </xs:annotation>
         <xs:sequence>
-            <xs:element name="quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        Calls quota for the user
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
-        <xs:attribute name="name" type="xs:token" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    User's name
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="password" type="xs:string" use="optional">
-            <xs:annotation>
-                <xs:documentation>
-                    User's password used in HTTP basic authentication
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="name" type="xs:token" use="required"/>
+        <xs:attribute name="password" type="xs:string" use="optional"/>
     </xs:complexType>
 
     <xs:complexType name="usersType">
-        <xs:annotation>
-            <xs:documentation>
-                List of registered users, add an &lt;anonymous&gt; tag to enable authenticated user access
-                when authentication is enabled
-            </xs:documentation>
-        </xs:annotation>
-    <xs:sequence>
+        <xs:sequence>
             <xs:element name="user" type="rbcs:userType" minOccurs="0" maxOccurs="unbounded"/>
             <xs:element name="anonymous" type="rbcs:anonymousUserType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="groupsType">
-        <xs:annotation>
-            <xs:documentation>
-                List of registered user groups
-            </xs:documentation>
-        </xs:annotation>
         <xs:sequence>
             <xs:element name="group" type="rbcs:groupType" maxOccurs="unbounded" minOccurs="0"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="groupType">
-        <xs:annotation>
-            <xs:documentation>
-                The definition of a user group, with the list of its member users
-            </xs:documentation>
-        </xs:annotation>
         <xs:sequence>
             <xs:element name="users" type="rbcs:userRefsType" maxOccurs="1" minOccurs="0">
                 <xs:unique name="userRefWriterKey">
@@ -467,35 +146,11 @@
                     <xs:field xpath="@ref"/>
                 </xs:unique>
             </xs:element>
-            <xs:element name="roles" type="rbcs:rolesType" maxOccurs="1" minOccurs="0">
-                <xs:annotation>
-                    <xs:documentation>
-                        The list of application roles awarded to all the members of this group
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="user-quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        The call quota for each user in this group
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="group-quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1">
-                <xs:annotation>
-                    <xs:documentation>
-                        The cumulative call quota for all users in this group
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="roles" type="rbcs:rolesType" maxOccurs="1" minOccurs="0"/>
+            <xs:element name="user-quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="group-quota" type="rbcs:quotaType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
-        <xs:attribute name="name" type="xs:token">
-            <xs:annotation>
-                <xs:documentation>
-                    The group's name
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="name" type="xs:token"/>
     </xs:complexType>
 
     <xs:simpleType name="role" final="restriction" >
@@ -515,11 +170,6 @@
     </xs:complexType>
 
     <xs:complexType name="userRefsType">
-        <xs:annotation>
-            <xs:documentation>
-                A list of references to users in the &lt;users&gt; section
-            </xs:documentation>
-        </xs:annotation>
         <xs:sequence>
                 <xs:element name="user" type="rbcs:userRefType" maxOccurs="unbounded" minOccurs="0"/>
                 <xs:element name="anonymous" minOccurs="0" maxOccurs="1"/>
@@ -527,106 +177,28 @@
     </xs:complexType>
 
     <xs:complexType name="userRefType">
-        <xs:annotation>
-            <xs:documentation>
-                A reference to a user in the &lt;users&gt; section
-            </xs:documentation>
-        </xs:annotation>
-        <xs:attribute name="ref" type="xs:string" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    Name of the referenced user
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="ref" type="xs:string" use="required"/>
     </xs:complexType>
 
     <xs:complexType name="tlsType">
-        <xs:annotation>
-            <xs:documentation>
-                Enable TLS protocol
-            </xs:documentation>
-        </xs:annotation>
         <xs:all>
-            <xs:element name="keystore" type="rbcs:keyStoreType" >
-                <xs:annotation>
-                    <xs:documentation>
-                        Path to the keystore file that contains the server's key and certificate
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
-            <xs:element name="truststore" type="rbcs:trustStoreType" minOccurs="0">
-                <xs:annotation>
-                    <xs:documentation>
-                        Path to the truststore file that contains the trusted CAs
-                        for TLS client certificate verification
-                    </xs:documentation>
-                </xs:annotation>
-            </xs:element>
+            <xs:element name="keystore" type="rbcs:keyStoreType" />
+            <xs:element name="truststore" type="rbcs:trustStoreType" minOccurs="0"/>
         </xs:all>
     </xs:complexType>
 
     <xs:complexType name="keyStoreType">
-        <xs:attribute name="file" type="xs:string" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    System path to the keystore file
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="password" type="xs:string">
-            <xs:annotation>
-                <xs:documentation>
-                    Password to open they keystore file
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="key-alias" type="xs:string" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    Alias of the keystore entry containing the private key
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="key-password" type="xs:string">
-            <xs:annotation>
-                <xs:documentation>
-                    Private key entry's encryption password
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="file" type="xs:string" use="required"/>
+        <xs:attribute name="password" type="xs:string"/>
+        <xs:attribute name="key-alias" type="xs:string" use="required"/>
+        <xs:attribute name="key-password" type="xs:string"/>
     </xs:complexType>
 
     <xs:complexType name="trustStoreType">
-        <xs:attribute name="file" type="xs:string" use="required">
-            <xs:annotation>
-                <xs:documentation>
-                    Path to the trustore file
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="password" type="xs:string">
-            <xs:annotation>
-                <xs:documentation>
-                    Trustore file password
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="check-certificate-status" type="xs:boolean">
-            <xs:annotation>
-                <xs:documentation>
-                    Whether or not check the certificate validity using CRL/OCSP
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
-        <xs:attribute name="require-client-certificate" type="xs:boolean" use="optional" default="false">
-            <xs:annotation>
-                <xs:documentation>
-                    If true, the server requires a TLS client certificate from the client and simply refuses to connect
-                    when a client certificate isn't provided
-                </xs:documentation>
-            </xs:annotation>
-        </xs:attribute>
+        <xs:attribute name="file" type="xs:string" use="required"/>
+        <xs:attribute name="password" type="xs:string"/>
+        <xs:attribute name="check-certificate-status" type="xs:boolean"/>
+        <xs:attribute name="require-client-certificate" type="xs:boolean" use="optional" default="false"/>
     </xs:complexType>
 
     <xs:complexType name="propertiesType">
@@ -648,17 +220,5 @@
         <xs:attribute name="port" type="xs:unsignedShort" use="required"/>
     </xs:complexType>
 
-    <xs:simpleType name="byteSizeType">
-        <xs:restriction base="xs:token">
-            <xs:pattern value="(0x[a-f0-9]+|[0-9]+)"/>
-        </xs:restriction>
-    </xs:simpleType>
-
-    <xs:simpleType name="compressionLevelType">
-        <xs:restriction base="xs:integer">
-            <xs:minInclusive value="-1"/>
-            <xs:maxInclusive value="9"/>
-        </xs:restriction>
-    </xs:simpleType>
 
 </xs:schema>

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

@@ -38,6 +38,8 @@ abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
             serverPath,
             Configuration.EventExecutor(false),
             Configuration.Connection(
+                Duration.of(10, ChronoUnit.SECONDS),
+                Duration.of(10, ChronoUnit.SECONDS),
                 Duration.of(60, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
@@ -45,13 +47,11 @@ abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
             ),
             users.asSequence().map { it.name to it}.toMap(),
             sequenceOf(writersGroup, readersGroup).map { it.name to it}.toMap(),
-            FileSystemCacheConfiguration(
-                this.cacheDir,
+            FileSystemCacheConfiguration(this.cacheDir,
                 maxAge = Duration.ofSeconds(3600 * 24),
                 digestAlgorithm = "MD5",
                 compressionLevel = Deflater.DEFAULT_COMPRESSION,
-                compressionEnabled = false,
-                chunkSize = 0x1000
+                compressionEnabled = false
             ),
             Configuration.BasicAuthentication(),
             null,

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

@@ -43,9 +43,8 @@ abstract class AbstractServerTest {
     }
 
     private fun stopServer() {
-        this.serverHandle?.let {
-            it.sendShutdownSignal()
-            it.get()
+        this.serverHandle?.use {
+            it.shutdown()
         }
     }
 }

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

@@ -143,6 +143,8 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
             serverPath,
             Configuration.EventExecutor(false),
             Configuration.Connection(
+                Duration.of(10, ChronoUnit.SECONDS),
+                Duration.of(10, ChronoUnit.SECONDS),
                 Duration.of(60, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
@@ -152,10 +154,9 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
             sequenceOf(writersGroup, readersGroup).map { it.name to it }.toMap(),
             FileSystemCacheConfiguration(this.cacheDir,
                 maxAge = Duration.ofSeconds(3600 * 24),
-                compressionEnabled = false,
+                compressionEnabled = true,
                 compressionLevel = Deflater.DEFAULT_COMPRESSION,
-                digestAlgorithm = "MD5",
-                chunkSize = 0x1000
+                digestAlgorithm = "MD5"
             ),
 //            InMemoryCacheConfiguration(
 //                maxAge = Duration.ofSeconds(3600 * 24),

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

@@ -86,7 +86,7 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
     @Test
     @Order(4)
     fun putAsAWriterUser() {
-        val client: HttpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()
+        val client: HttpClient = HttpClient.newHttpClient()
 
         val (key, value) = keyValuePair
         val user = cfg.users.values.find {

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

@@ -38,6 +38,8 @@ class NoAuthServerTest : AbstractServerTest() {
             serverPath,
             Configuration.EventExecutor(false),
             Configuration.Connection(
+                Duration.of(10, ChronoUnit.SECONDS),
+                Duration.of(10, ChronoUnit.SECONDS),
                 Duration.of(60, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
                 Duration.of(30, ChronoUnit.SECONDS),
@@ -50,8 +52,7 @@ class NoAuthServerTest : AbstractServerTest() {
                 compressionEnabled = true,
                 digestAlgorithm = "MD5",
                 compressionLevel = Deflater.DEFAULT_COMPRESSION,
-                maxSize = 0x1000000,
-                chunkSize = 0x1000
+                maxSize = 0x1000000
             ),
             null,
             null,
@@ -79,7 +80,7 @@ class NoAuthServerTest : AbstractServerTest() {
     @Test
     @Order(1)
     fun putWithNoAuthorizationHeader() {
-        val client: HttpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()
+        val client: HttpClient = HttpClient.newHttpClient()
         val (key, value) = keyValuePair
 
         val requestBuilder = newRequestBuilder(key)
@@ -118,56 +119,6 @@ class NoAuthServerTest : AbstractServerTest() {
 
     @Test
     @Order(4)
-    fun getUnhandledPath() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, _) = newEntry(random)
-        val requestBuilder = HttpRequest.newBuilder()
-            .uri(URI.create("http://${cfg.host}:${cfg.port}/some/other/path/$key"))
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(5)
-    fun putUnhandledPath() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = newEntry(random)
-        val requestBuilder = HttpRequest.newBuilder()
-            .uri(URI.create("http://${cfg.host}:${cfg.port}/some/other/path/$key"))
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(6)
-    fun getRelativeUnhandledPath() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, _) = newEntry(random)
-        val requestBuilder = HttpRequest.newBuilder()
-            .uri(URI.create("http://${cfg.host}:${cfg.port}/some/nested/path/../../../some/other/path/$key"))
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(7)
-    fun getRelativePath() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-        val requestBuilder = HttpRequest.newBuilder()
-            .uri(URI.create("http://${cfg.host}:${cfg.port}/some/other/path/../../nested/path/$key"))
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(10)
     fun traceTest() {
         val client: HttpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()
         val requestBuilder = newRequestBuilder("").method(

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

@@ -4,12 +4,14 @@
              xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd">
     <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="22"/>
     <connection
+            write-timeout="PT25M"
+            read-timeout="PT20M"
             read-idle-timeout="PT10M"
             write-idle-timeout="PT11M"
             idle-timeout="PT30M"
             max-request-size="101325"/>
     <event-executor use-virtual-threads="false"/>
-    <cache xs:type="rbcs:fileSystemCacheType" path="/tmp/rbcs" max-age="P7D" chunk-size="0xa910"/>
+    <cache xs:type="rbcs:fileSystemCacheType" path="/tmp/rbcs" max-age="P7D"/>
     <authentication>
         <none/>
     </authentication>

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

@@ -9,9 +9,11 @@
             max-request-size="67108864"
             idle-timeout="PT30S"
             read-idle-timeout="PT60S"
-            write-idle-timeout="PT60S"/>
+            write-idle-timeout="PT60S"
+            read-timeout="PT5M"
+            write-timeout="PT5M"/>
     <event-executor use-virtual-threads="true"/>
-    <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" chunk-size="123">
+    <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" max-size="16777216" compression-mode="deflate">
         <server host="memcached" port="11211"/>
     </cache>
     <authorization>

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

@@ -5,12 +5,14 @@
              xs:schemaLocation="urn:net.woggioni.rbcs.server.memcache jpms://net.woggioni.rbcs.server.memcache/net/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd">
     <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="50"/>
     <connection
+            write-timeout="PT25M"
+            read-timeout="PT20M"
             read-idle-timeout="PT10M"
             write-idle-timeout="PT11M"
             idle-timeout="PT30M"
             max-request-size="101325"/>
     <event-executor use-virtual-threads="false"/>
-    <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" digest="SHA-256" chunk-size="456" compression-mode="deflate" compression-level="7">
+    <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" max-size="101325" digest="SHA-256">
         <server host="127.0.0.1" port="11211" max-connections="10" connection-timeout="PT20S"/>
     </cache>
     <authentication>

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

@@ -4,12 +4,14 @@
              xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd">
     <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="180"/>
     <connection
+            write-timeout="PT25M"
+            read-timeout="PT20M"
             read-idle-timeout="PT10M"
             write-idle-timeout="PT11M"
             idle-timeout="PT30M"
             max-request-size="4096"/>
     <event-executor use-virtual-threads="false"/>
-    <cache xs:type="rbcs:inMemoryCacheType" max-age="P7D" chunk-size="0xa91f"/>
+    <cache xs:type="rbcs:inMemoryCacheType" max-age="P7D"/>
     <authorization>
         <users>
             <user name="user1" password="password1">

rbcs-servlet/Dockerfile

@@ -1,3 +0,0 @@
-FROM tomcat:jdk21
-
-COPY ./rbcs-servlet-*.war /usr/local/tomcat/webapps/rbcs-servlet.war

rbcs-servlet/README.md

@@ -1,28 +0,0 @@
-## How to run
-
-```bash
-gradlew dockerBuildImage
-```
- then in this directory run
-```bash
-docker run --rm -p 127.0.0.1:8080:8080 -m 1G --name tomcat -v $(pwd)/conf/server.xml:/usr/local/tomcat/conf/server.xml gitea.woggioni.net/woggioni/rbcs/servlet:latest
-```
-
-you can call the servlet cache with this RBCS client profile
-```xml
-    <profile name="servlet" base-url="http://127.0.0.1:8080/rbcs-servlet/cache/" max-connections="100" enable-compression="false">
-    	<no-auth/>
-    	<connection
-	        idle-timeout="PT5S"
-	        read-idle-timeout="PT10S"
-	        write-idle-timeout="PT10S"
-	        read-timeout="PT5S"
-	        write-timeout="PT5S"/>
-        <retry-policy max-attempts="10" initial-delay="PT1S" exp="1.2"/>
-    </profile>
-```
-
-## Notes
-
-The servlet implementation has an in memory cache whose maximum
-size is hardcoded to 0x8000000 bytes (around 134 MB)

rbcs-servlet/build.gradle

@@ -1,33 +0,0 @@
-plugins {
-    alias(catalog.plugins.kotlin.jvm)
-    alias(catalog.plugins.gradle.docker)
-    id 'war'
-}
-
-import com.bmuschko.gradle.docker.tasks.image.DockerBuildImage
-
-dependencies {
-    compileOnly catalog.jakarta.servlet.api
-    compileOnly catalog.jakarta.enterprise.cdi.api
-
-    implementation catalog.jwo
-    implementation catalog.jakarta.el
-    implementation catalog.jakarta.cdi.el.api
-    implementation catalog.weld.servlet.core
-    implementation catalog.weld.web
-}
-
-Provider<Copy> prepareDockerBuild = tasks.register('prepareDockerBuild', Copy) {
-    group = 'docker'
-    into project.layout.buildDirectory.file('docker')
-    from(tasks.war)
-    from(file('Dockerfile'))
-}
-
-Provider<DockerBuildImage> dockerBuild = tasks.register('dockerBuildImage', DockerBuildImage) {
-    group = 'docker'
-    dependsOn(prepareDockerBuild)
-    images.add('gitea.woggioni.net/woggioni/rbcs/servlet:latest')
-    images.add("gitea.woggioni.net/woggioni/rbcs/servlet:${version}")
-}
-

rbcs-servlet/conf/server.xml

@@ -1,140 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Note:  A "Server" is not itself a "Container", so you may not
-     define subcomponents such as "Valves" at this level.
-     Documentation at /docs/config/server.html
- -->
-<Server port="8005" shutdown="SHUTDOWN">
-    <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
-    <!-- Security listener. Documentation at /docs/config/listeners.html
-    <Listener className="org.apache.catalina.security.SecurityListener" />
-    -->
-    <!-- OpenSSL support using Tomcat Native -->
-    <Listener className="org.apache.catalina.core.AprLifecycleListener" />
-    <!-- OpenSSL support using FFM API from Java 22 -->
-    <!-- <Listener className="org.apache.catalina.core.OpenSSLLifecycleListener" /> -->
-    <!-- Prevent memory leaks due to use of particular java/javax APIs-->
-    <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
-    <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
-    <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
-
-    <!-- Global JNDI resources
-         Documentation at /docs/jndi-resources-howto.html
-    -->
-    <GlobalNamingResources>
-        <!-- Editable user database that can also be used by
-             UserDatabaseRealm to authenticate users
-        -->
-        <Resource name="UserDatabase" auth="Container"
-                  type="org.apache.catalina.UserDatabase"
-                  description="User database that can be updated and saved"
-                  factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
-                  pathname="conf/tomcat-users.xml" />
-    </GlobalNamingResources>
-
-    <!-- A "Service" is a collection of one or more "Connectors" that share
-         a single "Container" Note:  A "Service" is not itself a "Container",
-         so you may not define subcomponents such as "Valves" at this level.
-         Documentation at /docs/config/service.html
-     -->
-    <Service name="Catalina">
-
-        <!--The connectors can use a shared executor, you can define one or more named thread pools-->
-<!--        <Executor name="tomcatThreadPool" namePrefix="catalina-exec-" maxThreads="150" minSpareThreads="4"/>-->
-        <Executor name="tomcatThreadPool" namePrefix="virtual-exec-" className="org.apache.catalina.core.StandardVirtualThreadExecutor"/>
-
-
-
-        <!-- A "Connector" represents an endpoint by which requests are received
-             and responses are returned. Documentation at :
-             HTTP Connector: /docs/config/http.html
-             AJP  Connector: /docs/config/ajp.html
-             Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
-        -->
-<!--        <Connector port="8080" protocol="HTTP/1.1" executor="tomcatThreadPool"-->
-<!--                   connectionTimeout="20000"-->
-<!--                   redirectPort="8443" />-->
-        <Connector port="8080" protocol="HTTP/1.1"
-                   connectionTimeout="20000"
-                   redirectPort="8443" />
-        <!-- A "Connector" using the shared thread pool-->
-        <!--
-        <Connector executor="tomcatThreadPool"
-                   port="8080" protocol="HTTP/1.1"
-                   connectionTimeout="20000"
-                   redirectPort="8443" />
-        -->
-        <!-- Define an SSL/TLS HTTP/1.1 Connector on port 8443 with HTTP/2
-             This connector uses the NIO implementation. The default
-             SSLImplementation will depend on the presence of the APR/native
-             library and the useOpenSSL attribute of the AprLifecycleListener.
-             Either JSSE or OpenSSL style configuration may be used regardless of
-             the SSLImplementation selected. JSSE style configuration is used below.
-        -->
-        <!--
-        <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
-                   maxThreads="150" SSLEnabled="true">
-            <UpgradeProtocol className="org.apache.coyote.http2.Http2Protocol" />
-            <SSLHostConfig>
-                <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
-                             certificateKeystorePassword="changeit" type="RSA" />
-            </SSLHostConfig>
-        </Connector>
-        -->
-
-        <!-- Define an AJP 1.3 Connector on port 8009 -->
-        <!--
-        <Connector protocol="AJP/1.3"
-                   address="::1"
-                   port="8009"
-                   redirectPort="8443" />
-        -->
-
-        <!-- An Engine represents the entry point (within Catalina) that processes
-             every request.  The Engine implementation for Tomcat stand alone
-             analyzes the HTTP headers included with the request, and passes them
-             on to the appropriate Host (virtual host).
-             Documentation at /docs/config/engine.html -->
-
-        <!-- You should set jvmRoute to support load-balancing via AJP ie :
-        <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
-        -->
-        <Engine name="Catalina" defaultHost="localhost">
-
-            <!--For clustering, please take a look at documentation at:
-                /docs/cluster-howto.html  (simple how to)
-                /docs/config/cluster.html (reference documentation) -->
-            <!--
-            <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
-            -->
-
-            <!-- Use the LockOutRealm to prevent attempts to guess user passwords
-                 via a brute-force attack -->
-            <Realm className="org.apache.catalina.realm.LockOutRealm">
-                <!-- This Realm uses the UserDatabase configured in the global JNDI
-                     resources under the key "UserDatabase".  Any edits
-                     that are performed against this UserDatabase are immediately
-                     available for use by the Realm.  -->
-                <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
-                       resourceName="UserDatabase"/>
-            </Realm>
-
-            <Host name="localhost"  appBase="webapps"
-                  unpackWARs="true" autoDeploy="true">
-
-                <!-- SingleSignOn valve, share authentication between web applications
-                     Documentation at: /docs/config/valve.html -->
-                <!--
-                <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
-                -->
-
-                <!-- Access log processes all example.
-                     Documentation at: /docs/config/valve.html
-                     Note: The pattern used is equivalent to using pattern="common" -->
-                <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
-                       prefix="localhost_access_log" suffix=".txt"
-                       pattern="%h %l %u %t &quot;%r&quot; %s %b" />
-
-            </Host>
-        </Engine>
-    </Service>
-</Server>

rbcs-servlet/conf/tomcat-users.xml

@@ -1,58 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one or more
-  contributor license agreements.  See the NOTICE file distributed with
-  this work for additional information regarding copyright ownership.
-  The ASF licenses this file to You under the Apache License, Version 2.0
-  (the "License"); you may not use this file except in compliance with
-  the License.  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
--->
-<tomcat-users xmlns="http://tomcat.apache.org/xml"
-              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-              xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
-              version="1.0">
-    <!--
-      By default, no user is included in the "manager-gui" role required
-      to operate the "/manager/html" web application.  If you wish to use this app,
-      you must define such a user - the username and password are arbitrary.
-
-      Built-in Tomcat manager roles:
-        - manager-gui    - allows access to the HTML GUI and the status pages
-        - manager-script - allows access to the HTTP API and the status pages
-        - manager-jmx    - allows access to the JMX proxy and the status pages
-        - manager-status - allows access to the status pages only
-
-      The users below are wrapped in a comment and are therefore ignored. If you
-      wish to configure one or more of these users for use with the manager web
-      application, do not forget to remove the <!.. ..> that surrounds them. You
-      will also need to set the passwords to something appropriate.
-    -->
-    <!--
-      <user username="admin" password="<must-be-changed>" roles="manager-gui"/>
-      <user username="robot" password="<must-be-changed>" roles="manager-script"/>
-    -->
-    <user username="luser" password="password" roles="manager-gui,admin-gui"/>
-
-    <!--
-      The sample user and role entries below are intended for use with the
-      examples web application. They are wrapped in a comment and thus are ignored
-      when reading this file. If you wish to configure these users for use with the
-      examples web application, do not forget to remove the <!.. ..> that surrounds
-      them. You will also need to set the passwords to something appropriate.
-    -->
-    <!--
-      <role rolename="tomcat"/>
-      <role rolename="role1"/>
-      <user username="tomcat" password="<must-be-changed>" roles="tomcat"/>
-      <user username="both" password="<must-be-changed>" roles="tomcat,role1"/>
-      <user username="role1" password="<must-be-changed>" roles="role1"/>
-    -->
-</tomcat-users>

rbcs-servlet/src/main/kotlin/net/woggioni/rbcs/servlet/CacheServlet.kt

@@ -1,169 +0,0 @@
-package net.woggioni.rbcs.servlet
-
-import jakarta.annotation.PreDestroy
-import jakarta.enterprise.context.ApplicationScoped
-import jakarta.inject.Inject
-import jakarta.servlet.annotation.WebServlet
-import jakarta.servlet.http.HttpServlet
-import jakarta.servlet.http.HttpServletRequest
-import jakarta.servlet.http.HttpServletResponse
-import net.woggioni.jwo.HttpClient.HttpStatus
-import net.woggioni.jwo.JWO
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
-import java.nio.file.Path
-import java.time.Duration
-import java.time.Instant
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.PriorityBlockingQueue
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicLong
-import java.util.logging.Logger
-
-
-private class CacheKey(private val value: ByteArray) {
-    override fun equals(other: Any?) = if (other is CacheKey) {
-        value.contentEquals(other.value)
-    } else false
-
-    override fun hashCode() = value.contentHashCode()
-}
-
-
-@ApplicationScoped
-open class InMemoryServletCache : AutoCloseable {
-
-    private val maxAge= Duration.ofDays(7)
-    private val maxSize = 0x8000000
-
-    companion object {
-        @JvmStatic
-        private val log = Logger.getLogger(this::class.java.name)
-    }
-
-    private val size = AtomicLong()
-    private val map = ConcurrentHashMap<CacheKey, ByteArray>()
-
-    private class RemovalQueueElement(val key: CacheKey, val value: ByteArray, val expiry: Instant) :
-        Comparable<RemovalQueueElement> {
-        override fun compareTo(other: RemovalQueueElement) = expiry.compareTo(other.expiry)
-    }
-
-    private val removalQueue = PriorityBlockingQueue<RemovalQueueElement>()
-
-    @Volatile
-    private var running = false
-
-    private val garbageCollector = Thread.ofVirtual().name("in-memory-cache-gc").start {
-        while (running) {
-            val el = removalQueue.poll(1, TimeUnit.SECONDS) ?: continue
-            val value = el.value
-            val now = Instant.now()
-            if (now > el.expiry) {
-                val removed = map.remove(el.key, value)
-                if (removed) {
-                    updateSizeAfterRemoval(value)
-                }
-            } else {
-                removalQueue.put(el)
-                Thread.sleep(minOf(Duration.between(now, el.expiry), Duration.ofSeconds(1)))
-            }
-        }
-    }
-
-    private fun removeEldest(): Long {
-        while (true) {
-            val el = removalQueue.take()
-            val value = el.value
-            val removed = map.remove(el.key, value)
-            if (removed) {
-                val newSize = updateSizeAfterRemoval(value)
-                return newSize
-            }
-        }
-    }
-
-    private fun updateSizeAfterRemoval(removed: ByteArray): Long {
-        return size.updateAndGet { currentSize: Long ->
-            currentSize - removed.size
-        }
-    }
-
-    @PreDestroy
-    override fun close() {
-        running = false
-        garbageCollector.join()
-    }
-
-    open fun get(key: ByteArray) = map[CacheKey(key)]
-
-    open fun put(
-        key: ByteArray,
-        value: ByteArray,
-    ) {
-        val cacheKey = CacheKey(key)
-        val oldSize = map.put(cacheKey, value)?.let { old ->
-            val result = old.size
-            result
-        } ?: 0
-        val delta = value.size - oldSize
-        var newSize = size.updateAndGet { currentSize: Long ->
-            currentSize + delta
-        }
-        removalQueue.put(RemovalQueueElement(cacheKey, value, Instant.now().plus(maxAge)))
-        while (newSize > maxSize) {
-            newSize = removeEldest()
-        }
-    }
-}
-
-
-@WebServlet(urlPatterns = ["/cache/*"])
-class CacheServlet : HttpServlet() {
-    companion object {
-        @JvmStatic
-        private val log = Logger.getLogger(this::class.java.name)
-    }
-
-    @Inject
-    private lateinit var cache : InMemoryServletCache
-
-    private fun getKey(req : HttpServletRequest) : String {
-        return Path.of(req.pathInfo).fileName.toString()
-    }
-
-    override fun doPut(req: HttpServletRequest, resp: HttpServletResponse) {
-        val baos = ByteArrayOutputStream()
-        baos.use {
-            JWO.copy(req.inputStream, baos)
-        }
-        val key = getKey(req)
-        cache.put(key.toByteArray(Charsets.UTF_8), baos.toByteArray())
-        resp.status = 201
-        resp.setContentLength(0)
-        log.fine {
-            "[${Thread.currentThread().name}] Added value for key $key"
-        }
-    }
-
-    override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) {
-        val key = getKey(req)
-        val value = cache.get(key.toByteArray(Charsets.UTF_8))
-        if (value == null) {
-            log.fine {
-                "[${Thread.currentThread().name}] Cache miss for key $key"
-            }
-            resp.status = HttpStatus.NOT_FOUND.code
-            resp.setContentLength(0)
-        } else {
-            log.fine {
-                "[${Thread.currentThread().name}] Cache hit for key $key"
-            }
-            resp.status = HttpStatus.OK.code
-            resp.setContentLength(value.size)
-            ByteArrayInputStream(value).use {
-                JWO.copy(it, resp.outputStream)
-            }
-        }
-    }
-}

rbcs-servlet/src/main/resources/META-INF/beans.xml

@@ -1,5 +0,0 @@
-<beans xmlns="https://jakarta.ee/xml/ns/jakartaee"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/beans_4_0.xsd"
-       version="4.0">
-</beans>

rbcs-servlet/src/main/resources/META-INF/context.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Context antiJARLocking="true">
-    <Resource name="BeanManager"
-              auth="Container"
-              type="javax.enterprise.inject.spi.BeanManager"
-              factory="org.jboss.weld.resources.ManagerObjectFactory"/>
-</Context>

rbcs-servlet/src/main/resources/logging.properties

@@ -1,8 +0,0 @@
-handlers = java.util.logging.ConsoleHandler
-.level=INFO
-net.woggioni.rbcs.servlet.level=FINEST
-java.util.logging.ConsoleHandler.level=INFO
-java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
-java.util.logging.SimpleFormatter.format   = %1$tF %1$tT [%4$s] %2$s %5$s %6$s%n
-org.apache.catalina.core.ContainerBase.[Catalina].level=ALL
-org.apache.catalina.core.ContainerBase.[Catalina].handlers=java.util.logging.ConsoleHandler

rbcs-servlet/src/main/webapp/WEB-INF/web.xml

@@ -1,8 +0,0 @@
-<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
-         version="6.0">
-    <listener>
-        <listener-class>org.jboss.weld.module.web.servlet.WeldTerminalListener</listener-class>
-    </listener>
-</web-app>

settings.gradle

@@ -29,7 +29,6 @@ include 'rbcs-api'
 include 'rbcs-common'
 include 'rbcs-server-memcache'
 include 'rbcs-cli'
+include 'docker'
 include 'rbcs-client'
 include 'rbcs-server'
-include 'rbcs-servlet'
-include 'docker'