added Graal native image build for the server

.gitea/workflows/build-dev.yaml

@@ -1,80 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 'dev'
-jobs:
-  build:
-    runs-on: woryzen
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v4
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v3
-      - name: Execute Gradle build
-        run: ./gradlew build
-      - name: Prepare Docker image build
-        run: ./gradlew prepareDockerBuild
-      - name: Get project version
-        id: retrieve-version
-        run: ./gradlew -q version >> "$GITHUB_OUTPUT"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: docker-container
-      - name: Login to Gitea container registry
-        uses: docker/login-action@v3
-        with:
-          registry: gitea.woggioni.net
-          username: woggioni
-          password: ${{ secrets.PUBLISHER_TOKEN }}
-      -
-        name: Build rbcs Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64,linux/arm64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:vanilla-dev
-          target: release-vanilla
-          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/rbcs:buildx
-      -
-        name: Build rbcs memcache Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64,linux/arm64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:memcache-dev
-          target: release-memcache
-          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/rbcs:buildx
-          cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/rbcs:buildx
-      -
-        name: Build rbcs native Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:native-dev
-          target: release-native
-      -
-        name: Build rbcs jlink Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:jlink-dev
-          target: release-jlink
-

.gitea/workflows/build.yaml

@@ -5,7 +5,7 @@ on:
       - '*'
 jobs:
   build:
-    runs-on: woryzen
+    runs-on: hostinger
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
@@ -31,7 +31,7 @@ jobs:
           username: woggioni
           password: ${{ secrets.PUBLISHER_TOKEN }}
       -
-        name: Build rbcs Docker image
+        name: Build gbcs Docker image
         uses: docker/build-push-action@v5.3.0
         with:
           context: "docker/build/docker"
@@ -39,12 +39,12 @@ jobs:
           push: true
           pull: true
           tags: |
-            gitea.woggioni.net/woggioni/rbcs:vanilla
-            gitea.woggioni.net/woggioni/rbcs:vanilla-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-vanilla
-          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/rbcs:buildx
+            gitea.woggioni.net/woggioni/gbcs:latest
+            gitea.woggioni.net/woggioni/gbcs:${{ steps.retrieve-version.outputs.VERSION }}
+          target: release
+          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       -
-        name: Build rbcs memcache Docker image
+        name: Build gbcs memcache Docker image
         uses: docker/build-push-action@v5.3.0
         with:
           context: "docker/build/docker"
@@ -52,37 +52,11 @@ jobs:
           push: true
           pull: true
           tags: |
-            gitea.woggioni.net/woggioni/rbcs:latest
-            gitea.woggioni.net/woggioni/rbcs:${{ steps.retrieve-version.outputs.VERSION }}
-            gitea.woggioni.net/woggioni/rbcs:memcache
-            gitea.woggioni.net/woggioni/rbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
+            gitea.woggioni.net/woggioni/gbcs:memcache
+            gitea.woggioni.net/woggioni/gbcs:memcache-${{ steps.retrieve-version.outputs.VERSION }}
           target: release-memcache
-          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/rbcs:buildx
-          cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/rbcs:buildx
-      -
-        name: Build rbcs native Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:native
-            gitea.woggioni.net/woggioni/rbcs:native-${{ steps.retrieve-version.outputs.VERSION }}
-          target: release-native
-      -
-        name: Build rbcs jlink Docker image
-        uses: docker/build-push-action@v5.3.0
-        with:
-          context: "docker/build/docker"
-          platforms: linux/amd64
-          push: true
-          pull: true
-          tags: |
-            gitea.woggioni.net/woggioni/rbcs:jlink
-            gitea.woggioni.net/woggioni/rbcs:jlink-${{ steps.retrieve-version.outputs.VERSION }}-jlink
-          target: release-jlink
+          cache-from: type=registry,ref=gitea.woggioni.net/woggioni/gbcs:buildx
+          cache-to: type=registry,mode=max,compression=zstd,image-manifest=true,oci-mediatypes=true,ref=gitea.woggioni.net/woggioni/gbcs:buildx
       - name: Publish artifacts
         env:
           PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}

.gitignore

@@ -4,4 +4,4 @@
 # Ignore Gradle build output directory
 build
 
-rbcs-cli/native-image/*.json
+gbcs-cli/native-image/*.json

LICENSE

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 Y. T. CHUNG <zonyitoo@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,433 +0,0 @@
-# Remote Build Cache Server
-
-![Release](https://img.shields.io/gitea/v/release/woggioni/rbcs?gitea_url=https%3A%2F%2Fgitea.woggioni.net)
-![Version](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Fgitea.woggioni.net%2Fapi%2Fpackages%2Fwoggioni%2Fmaven%2Fnet%2Fwoggioni%2Frbcs-cli%2Fmaven-metadata.xml)
-![License](https://img.shields.io/badge/license-MIT-green)
-![Language](https://img.shields.io/gitea/languages/count/woggioni/rbcs?gitea_url=https%3A%2F%2Fgitea.woggioni.net)
-
-<!--
-![Last commit](https://img.shields.io/gitea/last-commit/woggioni/rbcs?gitea_url=https%3A%2F%2Fgitea.woggioni.net)
--->
-
-Speed up your builds by sharing and reusing unchanged build outputs across your team.
-
-Remote Build Cache Server (RBCS) allows teams to share and reuse unchanged build and test outputs, 
-significantly reducing build times for both local and CI environments. By eliminating redundant work, 
-RBCS helps teams become more productive and efficient.
-
-**Key Features:**
-- Support for both Gradle and Maven build environments
-- Pluggable storage backends (in-memory, disk-backed, memcached)
-- Flexible authentication (HTTP basic or TLS certificate)
-- Role-based access control
-- Request throttling
-
-## Table of Contents
-- [Quickstart](#quickstart)
-- [Integration with build tools](#integration-with-build-tools)
-  - [Use RBCS with Gradle](#use-rbcs-with-gradle)
-  - [Use RBCS with Maven](#use-rbcs-with-maven)
-- [Server configuration](#server-configuration)
-- [Authentication](#authentication)
-  - [HTTP Basic authentication](#configure-http-basic-authentication)
-  - [TLS client certificate authentication](#configure-tls-certificate-authentication)
-- [Authentication & Access Control](#access-control)
-- [Plugins](#plugins)
-- [Client Tools](#rbcs-client)
-- [Logging](#logging)
-- [Performance](#performance)
-- [FAQ](#faq)
-
-
-
-Remote Build Cache Server (shortened to RBCS) allows you to share and reuse unchanged build 
-and test outputs across the team. This speeds up local and CI builds since cycles are not wasted
-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
-
-### Use the all-in-one jar file 
-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
-
-### Use the Docker image
-You can pull the latest Docker image with
-```bash
-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
-
-### Use the native executable
-If you are on a Linux X86_64 machine you can download the native executable
-from [here](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni:rbcs-cli/).
-It behaves the same as the jar file but it doesn't require a JVM and it has faster startup times.
-because of GraalVM's [closed-world assumption](https://www.graalvm.org/latest/reference-manual/native-image/basics/#static-analysis),
-the native executable does not supports plugins, so it comes with all plugins embedded into it.
-
-> [!WARNING]
-> The native executable is built with `-march=skylake`, so it may fail with SIGILL on x86 CPUs that do not support
-> the full skylake instruction set (as a rule of thumb, older than 2015)
-
-## Integration with build tools
-
-### Use 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.
-
-### Use 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
-
-
-## Server configuration
-RBCS reads an XML configuration file, by default named `rbcs-server.xml`.
-The expected location of the `rbcs-server.xml` file depends on the operating system,
-if the configuration file is not found a default one will be created and its location is printed
-on the console
-
-```bash
-user@76a90cbcd75d:~$ rbcs-cli server
-2025-01-01 00:00:00,000 [INFO ] (main) n.w.r.c.impl.commands.ServerCommand -- Creating default configuration file at '/home/user/.config/rbcs/rbcs-server.xml'
-```
-
-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-server.xml` file.
-It can also be directly specified from the command line with
-```bash
-java -jar rbcs-cli.jar server -c /path/to/rbcs-server.xml
-```
-
-The server configuration file follows the XML format and uses XML schema for validation
-(you can find the schema for the `rbcs-server.xml` configuration file [here](https://gitea.woggioni.net/woggioni/rbcs/src/branch/master/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs-server.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
-
-```xml
-<bind host="${sys:rpc.bind.address}" port="${env:RBCS_SERVER_PORT}"/>
-```
-
-Full documentation for all tags and attributes and configuration file examples
-are 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.
-
-## Authentication
-
-RBCS supports 2 authentication mechanisms:
-
-- HTTP basic authentication
-- TLS certificate authentication
-
-### Configure HTTP basic authentication
-
-Add a `<basic>` element to the `<authentication>` element in your `rbcs-server.xml`
-```xml
-    <authentication>
-      <basic/>
-    </authentication>
-```
-
-### Configure TLS certificate authentication
-
-Add a `<client-certificate>` element to the `<authentication>` element in your `rbcs-server.xml`
-```xml
-    <authentication>
-        <client-certificate>
-            <user-extractor attribute-name="CN" pattern="(.*)"/>
-            <group-extractor attribute-name="O" pattern="(.*)"/>
-        </client-certificate>
-    </authentication>
-```
-The `<user-extractor>` here determines how the username is extracted from the
-subject's X.500 name in the TLS certificate presented by the client, where `attribute-name`
-is the `RelativeDistinguishedName` (RDN) identifier and pattern is a regular expression
-that will be applied to extract the username from the first group present in the regex.
-An error will be thrown if the regular expression contains no groups, while additional
-groups are ignored.
-
-Similarly, the `<group-extractor>` here determines how the group name is extracted from the
-subject's X.500 name in the TLS certificate presented by the client. 
-Note that this allows to assign roles to incoming requests without necessarily assigning them
-a username.
-
-
-
-## Access control
-
-RBCS supports role-based access control (RBAC), three roles are available:
-- `Reader` can perform `GET` calls
-- `Writer` can perform `PUT` calls
-- `Healthcheck` can perform `TRACE` calls
-
-Roles are assigned to groups so that a user will have a role only if that roles belongs
-to one of the groups he is a member of.
-
-There is also a special `<anonymous>` user 
-which matches any request who hasn't been authenticated and that can be assigned
-to any group like a normal user. This permits to have a build cache that is
-publicly readable but only writable by authenticated users (e.g. CI/CD pipeline).
-
-### Defining users
-
-Users can be defined in the `<authorization>` element
-```xml
-    <authorization>
-        <users>
-            <user name="user1" password="kb/vNnkn2RvyPkTN6Q07uH0F7wI7u61MkManD3NHregRukBg4KHehfbqtLTb39fZjHA+SRH+EpEWDCf+Rihr5H5C1YN5qwmArV0p8O5ptC4="/>
-            <user name="user2" password="2J7MAhdIzZ3SO+JGB+K6wPhb4P5LH1L4L7yJCl5QrxNfAWRr5jTUExJRbcgbH1UfnkCbIO1p+xTDq+FCj3LFBZeMZUNZ47npN+WR7AX3VTo="/>
-            <anonymous/>
-        </users>
-        <groups>
-            <group name="readers">
-                <users>
-                    <anonymous/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-            </group>
-            <group name="writers">
-                <users>
-                    <user ref="user1"/>
-                    <user ref="user2"/>
-                </users>
-                <roles>
-                    <reader/>
-                    <writer/>
-                    <healthcheck/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-```
-
-The `password` attribute is only used for HTTP Basic authentication, so it can be omitted
-if you use TLS certificate authentication. It must contain a password hash that can be derived from
-the actual password using the following command
-
-```bash
-java -jar rbcs-cli.jar password
-```
-
-## Reliability
-
-RBCS implements the [TRACE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/TRACE) HTTP method and this functionality can be used
-as a health check (mind you need to have `Healthcheck` role in order to perform it and match the server's `prefix` in the URL).
-
-## RBCS Client
-
-RBCS ships with a command line client that can be used for testing, benchmarking or to manually 
-upload/download files to the cache. It must be configured with the `rbcs-client.xml`, 
-whose location follows the same logic of the `rbcs-server.xml`. 
-The `rbcs-client.xml` must adhere to the [rbcs-client.xsd](rbcs-client/src/main/resources/net/woggioni/rbcs/client/schema/rbcs-client.xsd) 
-XML schema
-
-The documentation for the `rbcs-client.xml` configuration file is available [here](conf/client_configuration.md)
-
-### GET command
-
-```bash
-java -jar rbcs-cli.jar client -p $CLIENT_PROFILE_NAME get -k $CACHE_KEY -v $FILE_WHERE_THE_VALUE_WILL_BE_STORED
-```
-
-### PUT command
-
-```bash
-java -jar rbcs-cli.jar client -p $CLIENT_PROFILE_NAME put -k $CACHE_KEY -v $FILE_TO_BE_UPLOADED
-```
-
-If you don't specify the key, a UUID key based on the file content will be used, 
-if you add the `-i` command line parameter, the uploaded file will be served with
-`Content-Disposition: inline` HTTP header so that browser will attempt to render 
-it in the page instead of triggering a file download (in this way you can create a temporary web page).
-
-The client will try to detect the file mime type upon upload but if you want to be sure you can specify
-it manually with the `-t` parameter. 
-
-### Benchmark command
-
-```bash
-java -jar rbcs-cli.jar client -p $CLIENT_PROFILE_NAME benchamrk -s 4096 -e 10000
-```
-This will insert 10000 randomly generates entries of 4096 bytes into RBCS, then retrieve them
-and check that the retrieved value matches what was inserted. 
-It will also print throughput stats on the way.
-
-## Logging
-
-RBCS uses [logback](https://logback.qos.ch/) and ships with a [default logging configuration](./conf/logback.xml) that
-can be overridden with `-Dlogback.configurationFile=path/to/custom/configuration.xml`, refer to
-[Logback documentation](https://logback.qos.ch/manual/configuration.html) for more details about
-how to configure Logback
-
-## Performance
-
-You can check performance benchmarks [here](doc/benchmarks.md)
-
-## FAQ
-### Why should I use a build cache?
-
-#### Build Caches Improve Build & Test Performance
-
-Building software consists of a number of steps, like compiling sources, executing tests, and linking binaries. We’ve seen that a binary artifact repository helps when such a step requires an external component by downloading the artifact from the repository rather than building it locally.
-However, there are many additional steps in this build process which can be optimized to reduce the build time. An obvious strategy is to avoid executing build steps which dominate the total build time when these build steps are not needed.
-Most build times are dominated by the testing step. 
-
-While binary repositories cannot capture the outcome of a test build step (only the test reports 
-when included in binary artifacts), build caches are designed to eliminate redundant executions 
-for every build step. Moreover, it generalizes the concept of avoiding work associated with any 
-incremental step of the build, including test execution, compilation and resource processing. 
-The mechanism itself is comparable to a pure function. That is, given some inputs such as source 
-files and  environment parameters we know that the output is always going to be the same. 
-As a result, we can cache it and retrieve it based on a simple cryptographic hash of the inputs.
-Build caching is supported natively by some build tools. 
-
-#### Improve CI builds with a remote build cache
-
-When analyzing the role of a build cache it is important to take into account the granularity 
-of the changes that it caches. Imagine a full build for a project with 40 to 50 modules 
-which fails at the last step (deployment) because the staging environment is temporarily unavailable.
-Although the vast majority of the build steps (potentially thousands) succeed, 
-the change can not be deployed to the staging environment. 
-Without a build cache one typically relies on a very complex CI configuration to reuse build step outputs
-or would have to repeat the full build once the environment is available.
-
-Some build tools don’t support incremental builds properly. For example, outputs of a build started
-from scratch may vary when compared to subsequent builds that rely on the initial build’s output.
-As a result, to preserve build integrity, it’s crucial to rebuild from scratch, or ‘cleanly,’ in this
-scenario.
-
-With a build cache, only the last step needs to be executed and the build can be re-triggered 
-when the environment is back online. This automatically saves all of the time and 
-resources required across the different build steps which were successfully executed. 
-Instead of executing the intermediate steps, the build tool pulls the outputs from the build cache,
-avoiding a lot of redundant work
-
-#### Share outputs with a remote build cache
-
-One of the most important advantages of a remote build cache is the ability to share build outputs. 
-In most CI configurations, for example, a number of pipelines are created.
-These may include one for building the sources, one for testing, one for publishing the outcomes 
-to a remote repository, and other pipelines to test on different platforms. 
-There are even situations where CI builds partially build a project (i.e. some modules and not others).
-
-Most of those pipelines share a lot of intermediate build steps. All builds which perform testing
-require the binaries to be ready. All publishing builds require all previous steps to be executed.
-And because modern CI infrastructure means executing everything in containerized (isolated) environments,
-significant resources are wasted by repeatedly building the same intermediate artifacts.
-
-A remote build cache greatly reduces this overhead by orders of magnitudes because it provides a way
-for all those pipelines to share their outputs. After all, there is no point recreating an output that
-is already available in the cache.
-
-Because there are inherent dependencies between software components of a build,
-introducing a build cache dramatically reduces the impact of exploding a component into multiple pieces,
-allowing for increased modularity without increased overhead.
-
-#### Make local developers more efficient with remote build caches
-
-It is common for different teams within a company to work on different modules of a single large
-application. In this case, most teams don’t care about building the other parts of the software.
-By introducing a remote cache developers immediately benefit from pre-built artifacts when checking out code. 
-Because it has already been built on CI, they don’t have to do it locally.
-
-Introducing a remote cache is a huge benefit for those developers. Consider that a typical developer’s
-day begins by performing a code checkout. Most likely the checked out code has already been built on CI.
-Therefore, no time is wasted running the first build of the day. The remote cache provides all of the
-intermediate artifacts needed. And, in the event local changes are made, the remote cache still leverages
-partial cache hits for projects which are independent. As other developers in the organization request 
-CI builds, the remote cache continues to populate, increasing the likelihood of these remote cache hits
-across team members.
-

benchmark/rbcs-filesystem.yml

@@ -1,94 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: rbcs-server
-data:
-  rbcs-server.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-server.xsd"
-        >
-            <bind host="0.0.0.0" port="8080" incoming-connections-backlog-size="128"/>
-            <connection
-                    max-request-size="0xd000000"
-                    idle-timeout="PT15S"
-                    read-idle-timeout="PT30S"
-                    write-idle-timeout="PT30S"/>
-            <event-executor use-virtual-threads="true"/>
-            <cache xs:type="rbcs:fileSystemCacheType" max-age="P7D" enable-compression="false" path="/home/luser/cache" digest="SHA-224"/>
-        </rbcs:server>
-
----
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
-  name: rbcs-pvc
-  namespace: default
-spec:
-  accessModes:
-    - ReadWriteOnce
-  storageClassName: local-path
-  resources:
-    requests:
-      storage: 16Gi
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: rbcs-deployment
-  labels:
-    app: rbcs
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: rbcs
-  template:
-    metadata:
-      labels:
-        app: rbcs
-    spec:
-      containers:
-        - name: rbcs
-          image: gitea.woggioni.net/woggioni/rbcs:memcache
-          imagePullPolicy: Always
-          command: ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=75","-jar", "/home/luser/rbcs.jar"]
-          args: ['server', '-c', 'rbcs-server.xml']
-          ports:
-          - containerPort: 8080
-          volumeMounts:
-          - name: config-volume
-            mountPath: /home/luser/rbcs-server.xml
-            subPath: rbcs-server.xml
-          - name: cache-volume
-            mountPath: /home/luser/cache
-          resources:
-            requests:
-              memory: "0.25Gi"
-              cpu: "1"
-            limits:
-              memory: "0.5Gi"
-              cpu: "1"
-      volumes:
-        - name: config-volume
-          configMap:
-            name: rbcs-server
-        - name: cache-volume
-          persistentVolumeClaim:
-            claimName: rbcs-pvc
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: rbcs-service
-spec:
-  type: LoadBalancer
-  ports:
-  - port: 8080
-    targetPort: 8080
-    protocol: TCP
-  selector:
-    app: rbcs
-

benchmark/rbcs-in-memory.yml

@@ -1,77 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: rbcs-server
-data:
-  rbcs-server.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-server.xsd"
-        >
-            <bind host="0.0.0.0" port="8080" incoming-connections-backlog-size="128"/>
-            <connection
-                    max-request-size="0xd000000"
-                    idle-timeout="PT15S"
-                    read-idle-timeout="PT30S"
-                    write-idle-timeout="PT30S"/>
-            <event-executor use-virtual-threads="true"/>
-            <cache xs:type="rbcs:inMemoryCacheType" max-age="P7D" enable-compression="false" max-size="0x40000000" digest="SHA-224"/>
-        </rbcs:server>
-
----
-
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: rbcs-deployment
-  labels:
-    app: rbcs
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: rbcs
-  template:
-    metadata:
-      labels:
-        app: rbcs
-    spec:
-      containers:
-        - name: rbcs
-          image: gitea.woggioni.net/woggioni/rbcs:memcache
-          imagePullPolicy: Always
-          command: ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=75","-jar", "/home/luser/rbcs.jar"]
-          args: ['server', '-c', 'rbcs-server.xml']
-          ports:
-          - containerPort: 8080
-          volumeMounts:
-          - name: config-volume
-            mountPath: /home/luser/rbcs-server.xml
-            subPath: rbcs-server.xml
-          resources:
-            requests:
-              memory: "0.5Gi"
-              cpu: "1"
-            limits:
-              memory: "4Gi"
-              cpu: "1"
-      volumes:
-        - name: config-volume
-          configMap:
-            name: rbcs-server
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: rbcs-service
-spec:
-  type: LoadBalancer
-  ports:
-  - port: 8080
-    targetPort: 8080
-    protocol: TCP
-  selector:
-    app: rbcs
-

benchmark/rbcs-memcache.yml

@@ -1,118 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: rbcs-server
-data:
-  rbcs-server.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-server.xsd"
-        >
-            <bind host="0.0.0.0" port="8080" incoming-connections-backlog-size="128"/>
-            <connection
-                    max-request-size="0xd000000"
-                    idle-timeout="PT15S"
-                    read-idle-timeout="PT30S"
-                    write-idle-timeout="PT30S"/>
-            <event-executor use-virtual-threads="true"/>
-            <!--cache xs:type="rbcs:inMemoryCacheType" max-age="P7D" enable-compression="false" max-size="0x10000000" /-->
-            <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" chunk-size="0x1000" digest="SHA-224">
-                <server host="memcached-service" port="11211" max-connections="256"/>
-            </cache>
-        </rbcs:server>
-
----
-
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: rbcs-deployment
-  labels:
-    app: rbcs
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: rbcs
-  template:
-    metadata:
-      labels:
-        app: rbcs
-    spec:
-      containers:
-        - name: rbcs
-          image: gitea.woggioni.net/woggioni/rbcs:memcache
-          imagePullPolicy: Always
-          command: ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=75","-jar", "/home/luser/rbcs.jar"]
-          args: ['server', '-c', 'rbcs-server.xml']
-          ports:
-          - containerPort: 8080
-          volumeMounts:
-          - name: config-volume
-            mountPath: /home/luser/rbcs-server.xml
-            subPath: rbcs-server.xml
-          resources:
-            requests:
-              memory: "0.5Gi"
-              cpu: "1"
-            limits:
-              memory: "0.5Gi"
-              cpu: "3.5"
-      volumes:
-        - name: config-volume
-          configMap:
-            name: rbcs-server
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: rbcs-service
-spec:
-  type: LoadBalancer
-  ports:
-  - port: 8080
-    targetPort: 8080
-    protocol: TCP
-  selector:
-    app: rbcs
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: memcached-deployment
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: memcached
-  template:
-    metadata:
-      labels:
-        app: memcached
-    spec:
-      containers:
-      - name: memcached
-        image: memcached
-        args: ["-I", "128m", "-m", "4096", "-t", "1"]
-        resources:
-          requests:
-            memory: "1Gi"
-            cpu: "500m"        # 0.5 CPU
-          limits:
-            memory: "5Gi"
-            cpu: "500m"        # 0.5 CP
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: memcached-service
-spec:
-  type: ClusterIP  # ClusterIP makes it accessible only within the cluster
-  ports:
-  - port: 11211     # Default memcached port
-    targetPort: 11211
-    protocol: TCP
-  selector:
-    app: memcached

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('gbcs.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'
             }
         }
@@ -38,7 +41,8 @@ allprojects { subproject ->
             withSourcesJar()
             modularity.inferModulePath = true
             toolchain {
-                languageVersion = JavaLanguageVersion.of(21)
+                languageVersion = JavaLanguageVersion.of(23)
+                vendor = JvmVendorSpec.ORACLE
             }
         }
 

doc/benchmarks.md

@@ -1,86 +0,0 @@
-# RBCS performance benchmarks
-
-All test were executed under the following conditions:
-- CPU: Intel Celeron J3455 (4 physical cores)
-- memory: 8GB DDR3L 1600 MHz
-- disk: SATA3 120GB SSD
-- HTTP compression: disabled
-- cache compression: disabled
-- digest: none
-- authentication: disabled
-- TLS: disabled
-- network RTT: 14ms
-- network bandwidth: 112 MiB/s
-### In memory cache backend
-
-
-| Cache backend  | CPU                 | CPU quota | Memory quota (GB) | Request size (b) | Client connections | PUT (req/s) | GET (req/s) |
-|----------------|---------------------|-----------|-------------------|------------------|--------------------|-------------|-------------|
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 128              | 10                 | 7867        | 13762       |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 128              | 100                | 7728        | 14180       |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 512              | 10                 | 7964        | 10992       |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 512              | 100                | 8415        | 12478       |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 4096             | 10                 | 4268        | 5395        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 4096             | 100                | 5585        | 8259        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 65536            | 10                 | 1063        | 1185        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 65536            | 100                | 1522        | 1366        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 128              | 10                 | 11271       | 14092       |             
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 128              | 100                | 16064       | 24201       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 512              | 10                 | 11504       | 13077       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 512              | 100                | 17379       | 22094       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 4096             | 10                 | 9151        | 9489        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 4096             | 100                | 13194       | 18268       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 65536            | 10                 | 1590        | 1174        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 65536            | 100                | 1539        | 1561        |
-
-### Filesystem cache backend
-
-compression: disabled
-digest: none
-authentication: disabled
-TLS: disabled
-
-| Cache backend | CPU                 | CPU quota | Memory quota (GB) | Request size (b) | Client connections | PUT (req/s) | GET (req/s) |
-|---------------|---------------------|-----------|-------------------|------------------|--------------------|-------------|-------------|
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 128              | 10                 | 1478        | 5771        |             
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 128              | 100                | 3166        | 8070        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 512              | 10                 | 1717        | 5895        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 512              | 100                | 1125        | 6564        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 4096             | 10                 | 819         | 2509        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 4096             | 100                | 1136        | 2365        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 65536            | 10                 | 584         | 632         |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.5               | 65536            | 100                | 529         | 635         |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 128              | 10                 | 1227        | 3342        |             
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 128              | 100                | 1156        | 4035        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 512              | 10                 | 979         | 3294        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 512              | 100                | 1217        | 3888        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 4096             | 10                 | 535         | 1805        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 4096             | 100                | 555         | 1910        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 65536            | 10                 | 301         | 494         |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.5               | 65536            | 100                | 353         | 595         |
-
-### Memcache cache backend
-
-compression: disabled
-digest: MD5
-authentication: disabled
-TLS: disabled
-
-| Cache backend | CPU                 | CPU quota | Memory quota (GB) | Request size (b) | Client connections | PUT (req/s) | GET (req/s) |
-|---------------|---------------------|-----------|-------------------|------------------|--------------------|-------------|-------------|
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 128              | 10                 | 3380        | 6083        |             
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 128              | 100                | 3323        | 4998        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 10                 | 3924        | 6086        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 100                | 3440        | 5049        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 10                 | 3347        | 5255        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 100                | 3685        | 4693        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 10                 | 1304        | 1343        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 100                | 1481        | 1541        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 10                 | 4667        | 7984        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 100                | 4044        | 8358        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 10                 | 4177        | 7828        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 100                | 4079        | 8794        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 10                 | 4588        | 6869        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 100                | 5343        | 7797        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 10                 | 1624        | 1317        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 100                | 1633        | 1317        |

doc/client_configuration.md

@@ -1,125 +0,0 @@
-# XML Schema Documentation: RBCS Client Configuration
-
-This document provides detailed information about the XML schema for RBCS client configuration, which defines profiles for connecting to RBCS servers.
-
-## Root Element
-
-### `profiles`
-The root element that contains a collection of server profiles.
-- **Type**: `profilesType`
-- **Contains**: Zero or more `profile` elements
-
-## Complex Types
-
-### `profilesType`
-Defines the structure for the profiles collection.
-- **Elements**:
-    - `profile`: Server connection profile (0 to unbounded)
-
-### `profileType`
-Defines a server connection profile with authentication, connection settings, and retry policies.
-
-- **Attributes**:
-    - `name` (required): Name of the server profile, referenced with the '-p' parameter in rbcs-cli
-    - `base-url` (required): RBCs server URL
-    - `max-connections`: Maximum number of concurrent TCP connections (default: 50)
-    - `connection-timeout`: Timeout for establishing connections
-    - `enable-compression`: Whether to enable HTTP compression (default: true)
-
-- **Elements** (in sequence):
-    - **Authentication** (choice of one):
-        - `no-auth`: Disable authentication
-        - `basic-auth`: Enable HTTP basic authentication
-        - `tls-client-auth`: Enable TLS certificate authentication
-    - `connection` (optional): Connection timeout settings
-    - `retry-policy` (optional): Retry policy for failed requests
-    - `tls-trust-store` (optional): Custom truststore for server certificate validation
-
-### `connectionType`
-Defines connection timeout settings.
-
-- **Attributes**:
-    - `idle-timeout`: Close connection after inactivity period (default: PT30S - 30 seconds)
-    - `read-idle-timeout`: Close connection when no read occurs (default: PT60S - 60 seconds)
-    - `write-idle-timeout`: Close connection when no write occurs (default: PT60S - 60 seconds)
-
-### `noAuthType`
-Indicates no authentication should be used.
-- No attributes or elements
-
-### `basicAuthType`
-Configures HTTP Basic Authentication.
-
-- **Attributes**:
-    - `user` (required): Username for authentication
-    - `password` (required): Password for authentication
-
-### `tlsClientAuthType`
-Configures TLS client certificate authentication.
-
-- **Attributes**:
-    - `key-store-file` (required): Path to the keystore file
-    - `key-store-password` (required): Password to open the keystore
-    - `key-alias` (required): Alias of the keystore entry with the private key
-    - `key-password` (optional): Private key entry's encryption password
-
-### `retryType`
-Defines retry policy using exponential backoff.
-
-- **Attributes**:
-    - `max-attempts` (required): Maximum number of retry attempts
-    - `initial-delay`: Delay before first retry (default: PT1S - 1 second)
-    - `exp`: Exponent for computing next delay (default: 2.0)
-
-### `trustStoreType`
-Configures custom truststore for server certificate validation.
-
-- **Attributes**:
-    - `file` (required): Path to the truststore file
-    - `password`: Truststore file password
-    - `check-certificate-status`: Whether to check certificate validity using CRL/OCSP
-    - `verify-server-certificate`: Whether to validate server certificates (default: true)
-
-## Sample XML Document
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<profiles xmlns="urn:net.woggioni.rbcs.client">
-  <!-- Profile with basic authentication -->
-  <profile name="production-server" 
-           base-url="https://rbcs.example.com/api" 
-           max-connections="100" 
-           enable-compression="true">
-    <basic-auth user="admin" password="secure_password123"/>
-    <connection idle-timeout="PT45S" 
-                read-idle-timeout="PT90S" 
-                write-idle-timeout="PT90S"/>
-    <retry-policy max-attempts="5" 
-                 initial-delay="PT2S" 
-                 exp="1.5"/>
-    <tls-trust-store file="/path/to/truststore.jks" 
-                    password="truststore_password" 
-                    check-certificate-status="true"/>
-  </profile>
-  
-  <!-- Profile with TLS client authentication -->
-  <profile name="secure-server" 
-           base-url="https://secure.example.com/api" 
-           max-connections="25">
-    <tls-client-auth key-store-file="/path/to/keystore.p12" 
-                    key-store-password="keystore_password" 
-                    key-alias="client-cert" 
-                    key-password="key_password"/>
-    <retry-policy max-attempts="3"/>
-  </profile>
-  
-  <!-- Profile with no authentication -->
-  <profile name="development" 
-           base-url="http://localhost:8080/api" 
-           enable-compression="false">
-    <no-auth/>
-  </profile>
-</profiles>
-```
-
-This sample XML document demonstrates three different profiles with various authentication methods and configuration options as defined in the schema.

doc/server_configuration.md

@@ -1,189 +0,0 @@
-### RBCS server configuration file elements and attributes
-
-#### Root Element: `server`
-The root element that contains all server configuration.
-
-**Attributes:**
-- `path` (optional): URI path prefix for cache requests. Example: if set to "cache", requests would be made to "http://www.example.com/cache/KEY"
-
-#### Child Elements
-
-#### `<bind>`
-Configures server socket settings.
-
-**Attributes:**
-- `host` (required): Server bind address
-- `port` (required): Server port number
-- `incoming-connections-backlog-size` (optional, default: 1024): Maximum queue length for incoming connection indications
-
-#### `<connection>`
-Configures connection handling parameters.
-
-**Attributes:**
-- `idle-timeout` (optional, default: PT30S): Connection timeout when no activity
-- `read-idle-timeout` (optional, default: PT60S): Connection timeout when no reads
-- `write-idle-timeout` (optional, default: PT60S): Connection timeout when no writes
-- `max-request-size` (optional, default: 0x4000000): Maximum allowed request body size
-- `chunk-size` (default: 0x10000): Maximum socket write size
-
-#### `<event-executor>`
-Configures event execution settings.
-
-**Attributes:**
-- `use-virtual-threads` (optional, default: true): Whether to use virtual threads for the server handler
-
-#### `<cache>`
-Defines cache storage implementation. Two types are available:
-
-##### InMemory Cache
-
-A simple storage backend that uses an hash map to store data in memory
-
-**Attributes:**
-- `max-age` (default: P1D): Cache entry lifetime
-- `max-size` (default: 0x1000000): Maximum cache size in bytes
-- `digest` (default: MD5): Key hashing algorithm
-- `enable-compression` (default: true): Enable deflate compression
-- `compression-level` (default: -1): Compression level (-1 to 9)
-
-##### FileSystem Cache
-
-A storage backend that stores data in a folder on the disk
-
-**Attributes:**
-- `path`: Storage directory path
-- `max-age` (default: P1D): Cache entry lifetime
-- `digest` (default: MD5): Key hashing algorithm
-- `enable-compression` (default: true): Enable deflate compression
-- `compression-level` (default: -1): Compression level
-
-#### `<authorization>`
-Configures user and group-based access control.
-
-##### `<users>`
-List of registered users.
-- Contains `<user>` elements:
-
-  **Attributes:**
-    - `name` (required): Username
-    - `password` (optional): For basic authentication
-- Can contain an `anonymous` element to allow for unauthenticated access
-
-##### `<groups>`
-List of user groups.
-- Contains `<group>` elements:
-
-    **Attributes:**
-    - `name`: Group name
-    - Can contain:
-        - `users`: List of user references
-        - `roles`: List of roles (READER/WRITER)
-        - `user-quota`: Per-user quota
-        - `group-quota`: Group-wide quota
-
-#### `<authentication>`
-Configures authentication mechanism. Options:
-- `<basic>`: HTTP basic authentication
-- `<client-certificate>`: TLS certificate authentication, it uses attributes of the subject's X.500 name
-  to extract the username and group of the client.
-
-  Example:
-  ```xml
-    <client-certificate>
-        <user-extractor attribute-name="CN" pattern="(.*)"/>
-        <group-extractor attribute-name="O" pattern="(.*)"/>
-    </client-certificate>
-  ```
-- `<none>`: No authentication
-
-#### `<tls>`
-Configures TLS encryption.
-
-**Child Elements:**
-- `<keystore>`: Server certificate configuration
-
-    **Attributes:**
-    - `file` (required): Keystore file path
-    - `password`: Keystore password
-    - `key-alias` (required): Private key alias
-    - `key-password`: Private key password
-
-- `<truststore>`: Client certificate verification
-
-    **Attributes:**  
-    - `file` (required): Truststore file path
-    - `password`: Truststore password
-    - `check-certificate-status`: Enable CRL/OCSP checking
-    - `require-client-certificate` (default: false): Require client certificates
-
-
-----------------------------
-
-# Complete configuration example
-
-```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"
-             xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs-server.xsd"
->
-    <bind host="0.0.0.0" port="8080" incoming-connections-backlog-size="1024"/>
-    <connection
-            max-request-size="67108864"
-            idle-timeout="PT10S"
-            read-idle-timeout="PT20S"
-            write-idle-timeout="PT20S"
-            chunk-size="0x1000"/>
-    <event-executor use-virtual-threads="true"/>
-  
-    <cache xs:type="rbcs:inMemoryCacheType" max-age="P7D" enable-compression="false" max-size="0x10000000" />
-  
-  <!-- uncomment this to enable the filesystem storage backend, sotring cache data in "${sys:java.io.tmpdir}/rbcs"
-    <cache xs:type="rbcs:fileSystemCacheType" max-age="P7D" enable-compression="false" path="${sys:java.io.tmpdir}/rbcs"/>
-  -->
-
-  <!-- uncomment this to use memcache as the storage backend, also make sure you have 
-       the memcache plugin installed in the `plugins` directory if you are using running
-       the jar version of RBCS
-  <cache xs:type="rbcs-memcache:memcacheCacheType" max-age="P7D" digest="MD5">
-    <server host="127.0.0.1" port="11211" max-connections="256"/>
-  </cache>
-  -->
-
-  <authorization>
-        <users>
-            <user name="user1" password="II+qeNLft2pZ/JVNo9F7jpjM/BqEcfsJW27NZ6dPVs8tAwHbxrJppKYsbL7J/SMl">
-                <quota calls="100" period="PT1S"/>
-            </user>
-            <user name="user2" password="v6T9+q6/VNpvLknji3ixPiyz2YZCQMXj2FN7hvzbfc2Ig+IzAHO0iiBCH9oWuBDq"/>
-            <anonymous>
-                <quota calls="10" period="PT60S" initial-available-calls="10" max-available-calls="10"/>
-            </anonymous>
-        </users>
-        <groups>
-            <group name="readers">
-                <users>
-                    <anonymous/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-            </group>
-            <group name="writers">
-                <users>
-                    <user ref="user1"/>
-                    <user ref="user2"/>
-                </users>
-                <roles>
-                    <reader/>
-                    <writer/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-    <authentication>
-      <basic/>
-    </authentication>
-</rbcs:server>
-
-```

docker/Dockerfile

@@ -3,40 +3,14 @@ RUN adduser -D luser
 USER luser
 WORKDIR /home/luser
 
-FROM base-release AS release-vanilla
-ADD rbcs-cli-envelope-*.jar rbcs.jar
-ENTRYPOINT ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=70", "-XX:GCTimeRatio=24", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/rbcs.jar"]
+FROM base-release AS release
+ADD gbcs-cli-envelope-*.jar gbcs.jar
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]
 
 FROM base-release AS release-memcache
-ADD --chown=luser:luser rbcs-cli-envelope-*.jar rbcs.jar
+ADD --chown=luser:luser gbcs-cli-envelope-*.jar gbcs.jar
 RUN mkdir plugins
 WORKDIR /home/luser/plugins
-RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/rbcs-server-memcache*.tar
+RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcache*.tar
 WORKDIR /home/luser
-ADD logback.xml .
-ENTRYPOINT ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=70", "-XX:GCTimeRatio=24", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/rbcs.jar"]
-
-FROM busybox:musl AS base-native
-RUN mkdir -p /var/lib/rbcs /etc/rbcs
-RUN adduser -D -u 1000 rbcs -h /var/lib/rbcs
-
-FROM scratch AS release-native
-COPY --from=base-native /etc/passwd /etc/passwd
-COPY --from=base-native /etc/rbcs /etc/rbcs
-COPY --from=base-native /var/lib/rbcs /var/lib/rbcs
-ADD rbcs-cli.upx /usr/bin/rbcs-cli
-ENV RBCS_CONFIGURATION_DIR="/etc/rbcs"
-USER rbcs
-WORKDIR /var/lib/rbcs
-ENTRYPOINT ["/usr/bin/rbcs-cli", "-XX:MaximumHeapSizePercent=70"]
-
-FROM debian:12-slim AS release-jlink
-RUN mkdir -p /usr/share/java/rbcs
-RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/rbcs-cli*.tar -C /usr/share/java/rbcs
-ADD --chmod=755 rbcs-cli.sh /usr/local/bin/rbcs-cli
-RUN adduser -u 1000 luser
-USER luser
-WORKDIR /home/luser
-ADD logback.xml .
-ENV JAVA_OPTS=-XX:-UseJVMCICompiler\ -Dlogback.configurationFile=logback.xml\ -XX:MaxRAMPercentage=70\ -XX:GCTimeRatio=24\ -XX:+UseZGC\ -XX:+ZGenerational
-ENTRYPOINT ["/usr/local/bin/rbcs-cli"]
+ENTRYPOINT ["java", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/gbcs.jar", "server"]

docker/README.md

@@ -1,28 +0,0 @@
-# RBCS Docker images
-There are 3 image flavours:
-- vanilla
-- memcache
-- native
-
-The `vanilla` image only contains the envelope 
-jar file with no plugins and is based on `eclipse-temurin:21-jre-alpine`
-
-The `memcache` image is similar to the `vanilla` image, except that it also contains
-the `rbcs-server-memcache` plugin in the `plugins` folder, use this image if you don't want to use the `native`
-image and want to use memcache as the cache backend
-
-The `native` image contains a native, statically-linked executable created with GraalVM Native Image
-that has no userspace dependencies. It also embeds the memcache plugin inside the executable.
-Use this image for maximum efficiency and minimal memory footprint. 
-
-The `jlink` image contains a custom Java runtime created with GraalVM's Jlink
-that only depends on glibc. It also contains the memcache plugin in the module path.
-Use this image for best performance.
-
-## Which image should I use?
-The `native` image uses Java's SerialGC, so it's ideal for constrained environment like containers or small servers,
-if you have a lot of resources and want to squeeze out the maximum throughput you should consider the
-`vanilla` or `memcache` image, then choose and fine tune the garbage collector.
-
-Also the `native` image is only available for the `x86_64` architecture at the moment, 
-while `vanilla` and `memcache` also ship a `aarch64` variant.

docker/build.gradle

@@ -18,8 +18,8 @@ configurations {
 }
 
 dependencies {
-    docker project(path: ':rbcs-cli', configuration: 'release')
-    docker project(path: ':rbcs-server-memcache', configuration: 'release')
+    docker project(path: ':gbcs-cli', configuration: 'release')
+    docker project(path: ':gbcs-server-memcache', configuration: 'release')
 }
 
 Provider<Task> cleanTaskProvider = tasks.named(BasePlugin.CLEAN_TASK_NAME) {}
@@ -29,30 +29,27 @@ Provider<Copy> prepareDockerBuild = tasks.register('prepareDockerBuild', Copy) {
     group = 'docker'
     into project.layout.buildDirectory.file('docker')
     from(configurations.docker)
-    from(files('Dockerfile', 'rbcs-cli.sh'))
-    from(rootProject.file('conf')) {
-        include 'logback.xml'
-    }
+    from(file('Dockerfile'))
 }
 
 Provider<DockerBuildImage> dockerBuild = tasks.register('dockerBuildImage', DockerBuildImage) {
     group = 'docker'
     dependsOn prepareDockerBuild
-    images.add('gitea.woggioni.net/woggioni/rbcs:latest')
-    images.add("gitea.woggioni.net/woggioni/rbcs:${version}")
+    images.add('gitea.woggioni.net/woggioni/gbcs:latest')
+    images.add("gitea.woggioni.net/woggioni/gbcs:${version}")
 }
 
 Provider<DockerTagImage> dockerTag = tasks.register('dockerTagImage', DockerTagImage) {
     group = 'docker'
-    repository = 'gitea.woggioni.net/woggioni/rbcs'
-    imageId = 'gitea.woggioni.net/woggioni/rbcs:latest'
+    repository = 'gitea.woggioni.net/woggioni/gbcs'
+    imageId = 'gitea.woggioni.net/woggioni/gbcs:latest'
     tag = version
 }
 
 Provider<DockerTagImage> dockerTagMemcache = tasks.register('dockerTagMemcacheImage', DockerTagImage) {
     group = 'docker'
-    repository = 'gitea.woggioni.net/woggioni/rbcs'
-    imageId = 'gitea.woggioni.net/woggioni/rbcs:memcache'
+    repository = 'gitea.woggioni.net/woggioni/gbcs'
+    imageId = 'gitea.woggioni.net/woggioni/gbcs:memcache'
     tag = "${version}-memcache"
 }
 
@@ -66,3 +63,5 @@ Provider<DockerPushImage> dockerPush = tasks.register('dockerPushImage', DockerP
     }
     images = [dockerTag.flatMap{ it.tag }, dockerTagMemcache.flatMap{ it.tag }]
 }
+
+

docker/rbcs-cli.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-DIR=/usr/share/java/rbcs
-$DIR/bin/java $JAVA_OPTS -m net.woggioni.rbcs.cli "$@"

gbcs-api/build.gradle

@@ -5,12 +5,7 @@ plugins {
 }
 
 dependencies {
-    implementation catalog.slf4j.api
-    implementation project(':rbcs-common')
-    api catalog.netty.common
     api catalog.netty.buffer
-    api catalog.netty.handler
-    api catalog.netty.codec.http
 }
 
 publishing {

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

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

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

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

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.api;
+package net.woggioni.gbcs.api;
 
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.api;
+package net.woggioni.gbcs.api;
 
 
 import lombok.EqualsAndHashCode;
@@ -21,8 +21,6 @@ public class Configuration {
     @NonNull
     EventExecutor eventExecutor;
     @NonNull
-    RateLimiter rateLimiter;
-    @NonNull
     Connection connection;
     Map<String, User> users;
     Map<String, Group> groups;
@@ -30,13 +28,6 @@ public class Configuration {
     Authentication authentication;
     Tls tls;
 
-    @Value
-    public static class RateLimiter {
-        boolean delayRequest;
-        int messageBufferSize;
-        int maxQueuedMessages;
-    }
-
     @Value
     public static class EventExecutor {
         boolean useVirtualThreads;
@@ -44,11 +35,12 @@ public class Configuration {
 
     @Value
     public static class Connection {
+        Duration readTimeout;
+        Duration writeTimeout;
         Duration idleTimeout;
         Duration readIdleTimeout;
         Duration writeIdleTimeout;
         int maxRequestSize;
-        int chunkSize;
     }
 
     @Value
@@ -93,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;
@@ -132,7 +135,7 @@ public class Configuration {
     }
 
     public interface Cache {
-        CacheHandlerFactory materialize();
+        net.woggioni.gbcs.api.Cache materialize();
         String getNamespaceURI();
         String getTypeName();
     }
@@ -143,7 +146,6 @@ public class Configuration {
             int incomingConnectionsBacklogSize,
             String serverPath,
             EventExecutor eventExecutor,
-            RateLimiter rateLimiter,
             Connection connection,
             Map<String, User> users,
             Map<String, Group> groups,
@@ -157,7 +159,6 @@ public class Configuration {
                 incomingConnectionsBacklogSize,
                 serverPath != null && !serverPath.isEmpty() && !serverPath.equals("/") ? serverPath : null,
                 eventExecutor,
-                rateLimiter,
                 connection,
                 users,
                 groups,

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

@@ -0,0 +1,5 @@
+package net.woggioni.gbcs.api;
+
+public enum Role {
+    Reader, Writer
+}

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

@@ -1,6 +1,6 @@
-package net.woggioni.rbcs.api.exception;
+package net.woggioni.gbcs.api.exception;
 
-public class CacheException extends RbcsException {
+public class CacheException extends GbcsException {
     public CacheException(String message, Throwable cause) {
         super(message, cause);
     }

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

@@ -1,6 +1,6 @@
-package net.woggioni.rbcs.api.exception;
+package net.woggioni.gbcs.api.exception;
 
-public class ConfigurationException extends RbcsException {
+public class ConfigurationException extends GbcsException {
     public ConfigurationException(String message, Throwable cause) {
         super(message, cause);
     }

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

@@ -1,6 +1,6 @@
-package net.woggioni.rbcs.api.exception;
+package net.woggioni.gbcs.api.exception;
 
-public class ContentTooLargeException extends RbcsException {
+public class ContentTooLargeException extends GbcsException {
     public ContentTooLargeException(String message, Throwable cause) {
         super(message, cause);
     }

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

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

gbcs-cli/build.gradle

@@ -0,0 +1,101 @@
+plugins {
+    id 'java-library'
+    alias catalog.plugins.kotlin.jvm
+    alias catalog.plugins.envelope
+    alias catalog.plugins.sambal
+    alias catalog.plugins.graalvm.native.image
+    alias catalog.plugins.graalvm.jlink
+    alias catalog.plugins.jpms.check
+    id 'maven-publish'
+}
+
+import net.woggioni.gradle.envelope.EnvelopeJarTask
+import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
+import net.woggioni.gradle.graalvm.NativeImagePlugin
+import net.woggioni.gradle.graalvm.NativeImageTask
+import net.woggioni.gradle.graalvm.JlinkPlugin
+import net.woggioni.gradle.graalvm.JlinkTask
+
+Property<String> mainModuleName = objects.property(String.class)
+mainModuleName.set('net.woggioni.gbcs.cli')
+Property<String> mainClassName = objects.property(String.class)
+mainClassName.set('net.woggioni.gbcs.cli.GradleBuildCacheServerCli')
+
+tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
+    options.javaModuleMainClass = mainClassName
+}
+
+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(':gbcs-client')
+    implementation project(':gbcs-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.gbcs.LoggingConfig'
+//    systemProperties['log.config.source'] = 'net/woggioni/gbcs/cli/logging.properties'
+//    systemProperties['java.util.logging.config.file'] = 'classpath:net/woggioni/gbcs/cli/logging.properties'
+    systemProperties['logback.configurationFile'] = 'classpath:net/woggioni/gbcs/cli/logback.xml'
+    systemProperties['io.netty.leakDetectionLevel'] = 'DISABLED'
+
+//    systemProperties['org.slf4j.simpleLogger.showDateTime'] = 'true'
+//    systemProperties['org.slf4j.simpleLogger.defaultLogLevel'] = 'debug'
+//    systemProperties['org.slf4j.simpleLogger.log.com.google.code.yanf4j'] = 'warn'
+//    systemProperties['org.slf4j.simpleLogger.log.net.rubyeye.xmemcached'] = 'warn'
+//    systemProperties['org.slf4j.simpleLogger.dateTimeFormat'] = 'yyyy-MM-dd\'T\'HH:mm:ss.SSSZ'
+}
+
+tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask) {
+    mainClass = mainClassName
+    mainModule = mainModuleName
+}
+
+tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
+    mainClass = mainClassName
+    mainModule = mainModuleName
+    useMusl = true
+    buildStaticImage = true
+}
+
+tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
+    mainClass = mainClassName
+    mainModule = 'net.woggioni.gbcs.cli'
+}
+
+artifacts {
+    release(envelopeJarTaskProvider)
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            artifact envelopeJar
+        }
+    }
+}
+
+

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

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

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

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

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

@@ -0,0 +1,69 @@
+package net.woggioni.gbcs.cli
+
+import net.woggioni.gbcs.cli.impl.AbstractVersionProvider
+import net.woggioni.gbcs.cli.impl.GbcsCommand
+import net.woggioni.gbcs.cli.impl.commands.BenchmarkCommand
+import net.woggioni.gbcs.cli.impl.commands.ClientCommand
+import net.woggioni.gbcs.cli.impl.commands.GetCommand
+import net.woggioni.gbcs.cli.impl.commands.HealthCheckCommand
+import net.woggioni.gbcs.cli.impl.commands.PasswordHashCommand
+import net.woggioni.gbcs.cli.impl.commands.PutCommand
+import net.woggioni.gbcs.cli.impl.commands.ServerCommand
+import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
+import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.jwo.Application
+import picocli.CommandLine
+import picocli.CommandLine.Model.CommandSpec
+
+
+@CommandLine.Command(
+    name = "gbcs", versionProvider = GradleBuildCacheServerCli.VersionProvider::class
+)
+class GradleBuildCacheServerCli : GbcsCommand() {
+
+    class VersionProvider : AbstractVersionProvider()
+    companion object {
+        @JvmStatic
+        fun main(vararg args: String) {
+            val currentClassLoader = GradleBuildCacheServerCli::class.java.classLoader
+            Thread.currentThread().contextClassLoader = currentClassLoader
+            if(currentClassLoader.javaClass.name == "net.woggioni.envelope.loader.ModuleClassLoader") {
+                //We're running in an envelope jar and custom URL protocols won't work
+                GbcsUrlStreamHandlerFactory.install()
+            }
+            val log = contextLogger()
+            val app = Application.builder("gbcs")
+                .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")
+                .configurationDirectoryPropertyKey("net.woggioni.gbcs.conf.dir")
+                .build()
+            val gbcsCli = GradleBuildCacheServerCli()
+            val commandLine = CommandLine(gbcsCli)
+            commandLine.setExecutionExceptionHandler { ex, cl, parseResult ->
+                log.error(ex.message, ex)
+                CommandLine.ExitCode.SOFTWARE
+            }
+            commandLine.addSubcommand(ServerCommand(app))
+            commandLine.addSubcommand(PasswordHashCommand())
+            commandLine.addSubcommand(
+                CommandLine(ClientCommand(app)).apply {
+                    addSubcommand(BenchmarkCommand())
+                    addSubcommand(PutCommand())
+                    addSubcommand(GetCommand())
+                    addSubcommand(HealthCheckCommand())
+                })
+            System.exit(commandLine.execute(*args))
+        }
+    }
+
+    @CommandLine.Option(names = ["-V", "--version"], versionHelp = true)
+    var versionHelp = false
+        private set
+
+    @CommandLine.Spec
+    private lateinit var spec: CommandSpec
+
+
+    override fun run() {
+        spec.commandLine().usage(System.out);
+    }
+}

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

@@ -1,9 +1,9 @@
-package net.woggioni.rbcs.cli.impl
+package net.woggioni.gbcs.cli.impl
 
+import picocli.CommandLine
 import java.util.jar.Attributes
 import java.util.jar.JarFile
 import java.util.jar.Manifest
-import picocli.CommandLine
 
 
 abstract class AbstractVersionProvider : CommandLine.IVersionProvider {

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

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

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

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

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

@@ -1,45 +1,38 @@
-package net.woggioni.rbcs.cli.impl.commands
+package net.woggioni.gbcs.cli.impl.commands
 
-import java.nio.file.Path
+import net.woggioni.gbcs.cli.impl.GbcsCommand
+import net.woggioni.gbcs.client.GradleBuildCacheClient
 import net.woggioni.jwo.Application
-import net.woggioni.rbcs.cli.impl.RbcsCommand
-import net.woggioni.rbcs.client.Configuration
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
 import picocli.CommandLine
+import java.nio.file.Path
 
 @CommandLine.Command(
     name = "client",
-    description = ["RBCS client"],
+    description = ["GBCS client"],
     showDefaultValues = true
 )
-class ClientCommand(app : Application) : RbcsCommand() {
+class ClientCommand(app : Application) : GbcsCommand() {
 
     @CommandLine.Option(
         names = ["-c", "--configuration"],
         description = ["Path to the client configuration file"],
         paramLabel = "CONFIGURATION_FILE"
     )
-    private var configurationFile : Path = findConfigurationFile(app, "rbcs-client.xml")
+    private var configurationFile : Path = findConfigurationFile(app, "gbcs-client.xml")
 
     @CommandLine.Option(
         names = ["-p", "--profile"],
         description = ["Name of the client profile to be used"],
         paramLabel = "PROFILE",
-        required = false
+        required = true
     )
     var profileName : String? = null
-        get() = field ?: throw IllegalArgumentException("A profile name must be specified using the '-p' command line parameter")
 
-    val configuration : Configuration by lazy {
-        Configuration.parse(configurationFile)
+    val configuration : GradleBuildCacheClient.Configuration by lazy {
+        GradleBuildCacheClient.Configuration.parse(configurationFile)
     }
 
     override fun run() {
-        val log = createLogger<ClientCommand>()
-        log.debug {
-            "Using configuration file '$configurationFile'"
-        }
         println("Available profiles:")
         configuration.profiles.forEach { (profileName, _) ->
             println(profileName)

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

@@ -1,35 +1,19 @@
-package net.woggioni.rbcs.cli.impl.commands
+package net.woggioni.gbcs.cli.impl.commands
 
-import java.io.OutputStream
+import net.woggioni.gbcs.cli.impl.GbcsCommand
+import net.woggioni.gbcs.client.GradleBuildCacheClient
+import net.woggioni.gbcs.common.contextLogger
+import picocli.CommandLine
 import java.nio.file.Files
 import java.nio.file.Path
-import net.woggioni.rbcs.cli.impl.RbcsCommand
-import net.woggioni.rbcs.client.Configuration
-import net.woggioni.rbcs.client.RemoteBuildCacheClient
-import net.woggioni.rbcs.common.createLogger
-import picocli.CommandLine
 
 @CommandLine.Command(
     name = "get",
     description = ["Fetch a value from the cache with the specified key"],
     showDefaultValues = true
 )
-class GetCommand : RbcsCommand() {
-    companion object {
-        private val log = createLogger<GetCommand>()
-
-        fun execute(profile : Configuration.Profile, key : String, outputStream: OutputStream) {
-            RemoteBuildCacheClient(profile).use { client ->
-                client.get(key).thenApply { value ->
-                    value?.let {
-                        outputStream.use {
-                            it.write(value)
-                        }
-                    } ?: throw NoSuchElementException("No value found for key $key")
-                }.get()
-            }
-        }
-    }
+class GetCommand : GbcsCommand() {
+    private val log = contextLogger()
 
     @CommandLine.Spec
     private lateinit var spec: CommandLine.Model.CommandSpec
@@ -54,6 +38,14 @@ class GetCommand : RbcsCommand() {
             clientCommand.configuration.profiles[profileName]
                 ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
         }
-        execute(profile, key, (output?.let(Files::newOutputStream) ?: System.out))
+        GradleBuildCacheClient(profile).use { client ->
+            client.get(key).thenApply { value ->
+                value?.let {
+                    (output?.let(Files::newOutputStream) ?: System.out).use {
+                        it.write(value)
+                    }
+                } ?: throw NoSuchElementException("No value found for key $key")
+            }.get()
+        }
     }
 }

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

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

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

@@ -1,21 +1,21 @@
-package net.woggioni.rbcs.cli.impl.commands
+package net.woggioni.gbcs.cli.impl.commands
 
+import net.woggioni.gbcs.cli.impl.GbcsCommand
+import net.woggioni.gbcs.cli.impl.converters.OutputStreamConverter
+import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.jwo.UncloseableOutputStream
+import picocli.CommandLine
 import java.io.OutputStream
 import java.io.OutputStreamWriter
 import java.io.PrintWriter
-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 picocli.CommandLine
 
 
 @CommandLine.Command(
     name = "password",
-    description = ["Generate a password hash to add to RBCS configuration file"],
+    description = ["Generate a password hash to add to GBCS configuration file"],
     showDefaultValues = true
 )
-class PasswordHashCommand : RbcsCommand() {
+class PasswordHashCommand : GbcsCommand() {
     @CommandLine.Option(
         names = ["-o", "--output-file"],
         description = ["Write the output to a file instead of stdout"],

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

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

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

@@ -1,30 +1,29 @@
-package net.woggioni.rbcs.cli.impl.commands
+package net.woggioni.gbcs.cli.impl.commands
 
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.cli.impl.GbcsCommand
+import net.woggioni.gbcs.cli.impl.converters.DurationConverter
+import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.gbcs.common.debug
+import net.woggioni.gbcs.common.info
+import net.woggioni.gbcs.server.GradleBuildCacheServer
+import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
+import net.woggioni.jwo.Application
+import net.woggioni.jwo.JWO
+import picocli.CommandLine
 import java.io.ByteArrayOutputStream
 import java.nio.file.Files
 import java.nio.file.Path
 import java.time.Duration
-import java.util.concurrent.TimeUnit
-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.debug
-import net.woggioni.rbcs.common.info
-import net.woggioni.rbcs.server.RemoteBuildCacheServer
-import net.woggioni.rbcs.server.RemoteBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
-import picocli.CommandLine
 
 @CommandLine.Command(
     name = "server",
-    description = ["RBCS server"],
+    description = ["GBCS server"],
     showDefaultValues = true
 )
-class ServerCommand(app : Application) : RbcsCommand() {
-    companion object {
-        private val log = createLogger<ServerCommand>()
-    }
+class ServerCommand(app : Application) : GbcsCommand() {
+
+    private val log = contextLogger()
 
     private fun createDefaultConfigurationFile(configurationFile: Path) {
         log.info {
@@ -51,7 +50,7 @@ class ServerCommand(app : Application) : RbcsCommand() {
         description = ["Read the application configuration from this file"],
         paramLabel = "CONFIG_FILE"
     )
-    private var configurationFile: Path = findConfigurationFile(app, "rbcs-server.xml")
+    private var configurationFile: Path = findConfigurationFile(app, "gbcs-server.xml")
 
     override fun run() {
         if (!Files.exists(configurationFile)) {
@@ -59,32 +58,20 @@ class ServerCommand(app : Application) : RbcsCommand() {
             createDefaultConfigurationFile(configurationFile)
         }
 
-        log.debug {
-            "Using configuration file '$configurationFile'"
-        }
-        val configuration = RemoteBuildCacheServer.loadConfiguration(configurationFile)
+        val configuration = GradleBuildCacheServer.loadConfiguration(configurationFile)
         log.debug {
             ByteArrayOutputStream().also {
-                RemoteBuildCacheServer.dumpConfiguration(configuration, it)
+                GradleBuildCacheServer.dumpConfiguration(configuration, it)
             }.let {
                 "Server configuration:\n${String(it.toByteArray())}"
             }
         }
-        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)
+        val server = GradleBuildCacheServer(configuration)
+        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()
     }
 }

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

@@ -1,7 +1,7 @@
-package net.woggioni.rbcs.cli.impl.converters
+package net.woggioni.gbcs.cli.impl.converters
 
-import java.time.Duration
 import picocli.CommandLine
+import java.time.Duration
 
 
 class DurationConverter : CommandLine.ITypeConverter<Duration> {

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

@@ -1,9 +1,9 @@
-package net.woggioni.rbcs.cli.impl.converters
+package net.woggioni.gbcs.cli.impl.converters
 
+import picocli.CommandLine
 import java.io.InputStream
 import java.nio.file.Files
 import java.nio.file.Paths
-import picocli.CommandLine
 
 
 class InputStreamConverter : CommandLine.ITypeConverter<InputStream> {

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

@@ -1,9 +1,9 @@
-package net.woggioni.rbcs.cli.impl.converters
+package net.woggioni.gbcs.cli.impl.converters
 
+import picocli.CommandLine
 import java.io.OutputStream
 import java.nio.file.Files
 import java.nio.file.Paths
-import picocli.CommandLine
 
 
 class OutputStreamConverter : CommandLine.ITypeConverter<OutputStream> {

gbcs-client/build.gradle

@@ -4,13 +4,11 @@ plugins {
 }
 
 dependencies {
-    implementation project(':rbcs-api')
-    implementation project(':rbcs-common')
+    implementation project(':gbcs-api')
+    implementation project(':gbcs-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

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

@@ -1,4 +1,4 @@
-module net.woggioni.rbcs.client {
+module net.woggioni.gbcs.client {
     requires io.netty.handler;
     requires io.netty.codec.http;
     requires io.netty.transport;
@@ -6,12 +6,12 @@ module net.woggioni.rbcs.client {
     requires io.netty.common;
     requires io.netty.buffer;
     requires java.xml;
-    requires net.woggioni.rbcs.common;
-    requires net.woggioni.rbcs.api;
+    requires net.woggioni.gbcs.common;
+    requires net.woggioni.gbcs.api;
     requires io.netty.codec;
     requires org.slf4j;
 
-    exports net.woggioni.rbcs.client;
+    exports net.woggioni.gbcs.client;
 
-    opens net.woggioni.rbcs.client.schema;
+    opens net.woggioni.gbcs.client.schema;
 }

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.client
+package net.woggioni.gbcs.client
 
 import io.netty.bootstrap.Bootstrap
 import io.netty.buffer.ByteBuf
@@ -7,10 +7,8 @@ import io.netty.channel.Channel
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPipeline
-import io.netty.channel.IoEventLoopGroup
-import io.netty.channel.MultiThreadIoEventLoopGroup
 import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.channel.nio.NioIoHandler
+import io.netty.channel.nio.NioEventLoopGroup
 import io.netty.channel.pool.AbstractChannelPoolHandler
 import io.netty.channel.pool.ChannelPool
 import io.netty.channel.pool.FixedChannelPool
@@ -30,70 +28,75 @@ 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.Future as NettyFuture
 import io.netty.util.concurrent.GenericFutureListener
-import java.io.IOException
+import net.woggioni.gbcs.client.impl.Parser
+import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.gbcs.common.debug
+import net.woggioni.gbcs.common.trace
 import java.net.InetSocketAddress
 import java.net.URI
+import java.nio.file.Files
+import java.nio.file.Path
+import java.security.PrivateKey
 import java.security.cert.X509Certificate
+import java.time.Duration
 import java.util.Base64
 import java.util.concurrent.CompletableFuture
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
 import java.util.concurrent.atomic.AtomicInteger
-import javax.net.ssl.TrustManagerFactory
-import javax.net.ssl.X509TrustManager
-import kotlin.random.Random
-import net.woggioni.rbcs.api.CacheValueMetadata
-import net.woggioni.rbcs.common.RBCS.loadKeystore
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
-import net.woggioni.rbcs.common.trace
+import io.netty.util.concurrent.Future as NettyFuture
 
-class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
-    companion object {
-        private val log = createLogger<RemoteBuildCacheClient>()
-    }
 
-    private val group: IoEventLoopGroup
-    private val sslContext: SslContext
+class GradleBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
+    private val group: NioEventLoopGroup
+    private var sslContext: SslContext
+    private val log = contextLogger()
     private val pool: ChannelPool
 
+    data class Configuration(
+        val profiles: Map<String, Profile>
+    ) {
+        sealed class Authentication {
+            data class TlsClientAuthenticationCredentials(
+                val key: PrivateKey,
+                val certificateChain: Array<X509Certificate>
+            ) : Authentication()
+
+            data class BasicAuthenticationCredentials(val username: String, val password: String) : Authentication()
+        }
+
+        class RetryPolicy(
+            val maxAttempts: Int,
+            val initialDelayMillis: Long,
+            val exp: Double
+        )
+
+        data class Profile(
+            val serverURI: URI,
+            val authentication: Authentication?,
+            val connectionTimeout: Duration?,
+            val maxConnections: Int,
+            val retryPolicy: RetryPolicy?,
+        )
+
+        companion object {
+            fun parse(path: Path): Configuration {
+                return Files.newInputStream(path).use {
+                    Xml.parseXml(path.toUri().toURL(), it)
+                }.let(Parser::parse)
+            }
+        }
+    }
+
     init {
-        group = MultiThreadIoEventLoopGroup(NioIoHandler.newFactory())
+        group = NioEventLoopGroup()
         sslContext = SslContextBuilder.forClient().also { builder ->
             (profile.authentication as? Configuration.Authentication.TlsClientAuthenticationCredentials)?.let { tlsClientAuthenticationCredentials ->
-                builder.apply {
-                    keyManager(
-                        tlsClientAuthenticationCredentials.key,
-                        *tlsClientAuthenticationCredentials.certificateChain
-                    )
-                    profile.tlsTruststore?.let { trustStore ->
-                        if (!trustStore.verifyServerCertificate) {
-                            trustManager(object : X509TrustManager {
-                                override fun checkClientTrusted(certChain: Array<out X509Certificate>, p1: String?) {
-                                }
-
-                                override fun checkServerTrusted(certChain: Array<out X509Certificate>, p1: String?) {
-                                }
-
-                                override fun getAcceptedIssuers() = null
-                            })
-                        } else {
-                            trustStore.file?.let {
-                                val ts = loadKeystore(it, trustStore.password)
-                                val trustManagerFactory: TrustManagerFactory =
-                                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
-                                trustManagerFactory.init(ts)
-                                trustManager(trustManagerFactory)
-                            }
-                        }
-                    }
-                }
+                builder.keyManager(
+                    tlsClientAuthenticationCredentials.key,
+                    *tlsClientAuthenticationCredentials.certificateChain
+                )
             }
         }.build()
 
@@ -138,37 +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 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))
@@ -176,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())
             }
@@ -224,7 +206,6 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                 retryPolicy.initialDelayMillis.toDouble(),
                 retryPolicy.exp,
                 outcomeHandler,
-                Random.Default,
                 operation
             )
         } else {
@@ -254,37 +235,27 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
     fun get(key: String): CompletableFuture<ByteArray?> {
         return executeWithRetry {
             sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
-        }.thenApply { response ->
-            val status = response.status()
-            if (response.status() == HttpResponseStatus.NOT_FOUND) {
-                response.release()
+        }.thenApply {
+            val status = it.status()
+            if (it.status() == HttpResponseStatus.NOT_FOUND) {
                 null
-            } else if (response.status() != HttpResponseStatus.OK) {
-                response.release()
+            } else if (it.status() != HttpResponseStatus.OK) {
                 throw HttpException(status)
             } else {
-                response.content().also {
-                    it.retain()
-                    response.release()
-                }
+                it.content()
             }
         }.thenApply { maybeByteBuf ->
-            maybeByteBuf?.let { buf ->
-                val result = ByteArray(buf.readableBytes())
-                buf.getBytes(0, result)
-                buf.release()
+            maybeByteBuf?.let {
+                val result = ByteArray(it.readableBytes())
+                it.getBytes(0, result)
                 result
             }
         }
     }
 
-    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) {
@@ -293,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>> {
-
             override fun operationComplete(channelFuture: Future<Channel>) {
                 if (channelFuture.isSuccess) {
                     val channel = channelFuture.now
                     val pipeline = channel.pipeline()
-
-                    val closeListener = GenericFutureListener<Future<Void>> {
-                        responseFuture.completeExceptionally(IOException("The remote server closed the connection"))
-                    }
-                    channel.closeFuture().addListener(closeListener)
-
-                    val responseHandler = object : SimpleChannelInboundHandler<FullHttpResponse>() {
-
-                        override fun handlerAdded(ctx: ChannelHandlerContext) {
-                            channel.closeFuture().removeListener(closeListener)
-                        }
-
+                    channel.pipeline().addLast("handler", object : SimpleChannelInboundHandler<FullHttpResponse>() {
                         override fun channelRead0(
                             ctx: ChannelHandlerContext,
                             response: FullHttpResponse
                         ) {
-                            pipeline.remove(this)
-                            responseFuture.complete(response.retainedDuplicate())
-                            if (!profile.connection.requestPipelining) {
-                                pool.release(channel)
-                            }
+                            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) {
-                            responseFuture.completeExceptionally(IOException("The remote server closed the connection"))
-                            super.channelInactive(ctx)
+                            pipeline.removeLast()
                             pool.release(channel)
                         }
-
-                        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)
-                                super.userEventTriggered(ctx, evt)
-                                if (this === pipeline.last()) {
-                                    ctx.close()
-                                }
-                                if (!profile.connection.requestPipelining) {
-                                    pool.release(channel)
-                                }
-                            } else {
-                                super.userEventTriggered(ctx, evt)
-                            }
-                        }
-                    }
-                    pipeline.addLast(responseHandler)
-
-
+                    })
                     // Prepare the HTTP request
                     val request: FullHttpRequest = let {
                         val content: ByteBuf? = body?.takeIf(ByteArray::isNotEmpty)?.let(Unpooled::wrappedBuffer)
@@ -379,22 +302,17 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                             uri.rawPath,
                             content ?: Unpooled.buffer(0)
                         ).apply {
-                            // Set headers
                             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}"
@@ -405,16 +323,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                         }
                     }
 
+                    // Set headers
                     // Send the request
-                    channel.writeAndFlush(request).addListener {
-                        if (!it.isSuccess) {
-                            val ex = it.cause()
-                            log.warn(ex.message, ex)
-                        }
-                        if (profile.connection.requestPipelining) {
-                            pool.release(channel)
-                        }
-                    }
+                    channel.writeAndFlush(request)
                 } else {
                     responseFuture.completeExceptionally(channelFuture.cause())
                 }

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.client
+package net.woggioni.gbcs.client
 
 import io.netty.handler.codec.http.HttpResponseStatus
 

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

@@ -1,5 +1,10 @@
-package net.woggioni.rbcs.client.impl
+package net.woggioni.gbcs.client.impl
 
+import net.woggioni.gbcs.api.exception.ConfigurationException
+import net.woggioni.gbcs.client.GradleBuildCacheClient
+import net.woggioni.gbcs.common.Xml.Companion.asIterable
+import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
+import org.w3c.dom.Document
 import java.net.URI
 import java.nio.file.Files
 import java.nio.file.Path
@@ -7,18 +12,12 @@ import java.security.KeyStore
 import java.security.PrivateKey
 import java.security.cert.X509Certificate
 import java.time.Duration
-import java.time.temporal.ChronoUnit
-import net.woggioni.rbcs.api.exception.ConfigurationException
-import net.woggioni.rbcs.client.Configuration
-import net.woggioni.rbcs.common.Xml.Companion.asIterable
-import net.woggioni.rbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
 
 object Parser {
 
-    fun parse(document: Document): Configuration {
+    fun parse(document: Document): GradleBuildCacheClient.Configuration {
         val root = document.documentElement
-        val profiles = mutableMapOf<String, Configuration.Profile>()
+        val profiles = mutableMapOf<String, GradleBuildCacheClient.Configuration.Profile>()
 
         for (child in root.asIterable()) {
             val tagName = child.localName
@@ -28,15 +27,8 @@ object Parser {
                         child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
                     val uri = child.renderAttribute("base-url")?.let(::URI)
                         ?: throw ConfigurationException("base-url attribute is required")
-                    var authentication: Configuration.Authentication? = null
-                    var retryPolicy: Configuration.RetryPolicy? = null
-                    var connection : Configuration.Connection = Configuration.Connection(
-                        Duration.ofSeconds(60),
-                        Duration.ofSeconds(60),
-                        Duration.ofSeconds(30),
-                        false
-                    )
-                    var trustStore : Configuration.TrustStore? = null
+                    var authentication: GradleBuildCacheClient.Configuration.Authentication? = null
+                    var retryPolicy: GradleBuildCacheClient.Configuration.RetryPolicy? = null
                     for (gchild in child.asIterable()) {
                         when (gchild.localName) {
                             "tls-client-auth" -> {
@@ -57,7 +49,7 @@ object Parser {
                                     .toList()
                                     .toTypedArray()
                                 authentication =
-                                    Configuration.Authentication.TlsClientAuthenticationCredentials(
+                                    GradleBuildCacheClient.Configuration.Authentication.TlsClientAuthenticationCredentials(
                                         key,
                                         certChain
                                     )
@@ -69,7 +61,7 @@ object Parser {
                                 val password = gchild.renderAttribute("password")
                                     ?: throw ConfigurationException("password attribute is required")
                                 authentication =
-                                    Configuration.Authentication.BasicAuthenticationCredentials(
+                                    GradleBuildCacheClient.Configuration.Authentication.BasicAuthenticationCredentials(
                                         username,
                                         password
                                     )
@@ -88,40 +80,12 @@ object Parser {
                                     gchild.renderAttribute("exp")
                                         ?.let(String::toDouble)
                                         ?: 2.0f
-                                retryPolicy = Configuration.RetryPolicy(
+                                retryPolicy = GradleBuildCacheClient.Configuration.RetryPolicy(
                                     maxAttempts,
                                     initialDelay.toMillis(),
                                     exp.toDouble()
                                 )
                             }
-
-                            "connection" -> {
-                                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)
-                                val requestPipelining = gchild.renderAttribute("request-pipelining")
-                                    ?.let(String::toBoolean) ?: false
-                                connection = Configuration.Connection(
-                                    readIdleTimeout,
-                                    writeIdleTimeout,
-                                    idleTimeout,
-                                    requestPipelining
-                                )
-                            }
-
-                            "tls-trust-store" -> {
-                                val file = gchild.renderAttribute("file")
-                                    ?.let(Path::of)
-                                val password = gchild.renderAttribute("password")
-                                val checkCertificateStatus = gchild.renderAttribute("check-certificate-status")
-                                    ?.let(String::toBoolean) ?: false
-                                val verifyServerCertificate = gchild.renderAttribute("verify-server-certificate")
-                                    ?.let(String::toBoolean) ?: true
-                                trustStore = Configuration.TrustStore(file, password, checkCertificateStatus, verifyServerCertificate)
-                            }
                         }
                     }
                     val maxConnections = child.renderAttribute("max-connections")
@@ -129,23 +93,16 @@ object Parser {
                         ?: 50
                     val connectionTimeout = child.renderAttribute("connection-timeout")
                         ?.let(Duration::parse)
-                    val compressionEnabled = child.renderAttribute("enable-compression")
-                        ?.let(String::toBoolean)
-                        ?: true
-
-                    profiles[name] = Configuration.Profile(
+                    profiles[name] = GradleBuildCacheClient.Configuration.Profile(
                         uri,
-                        connection,
                         authentication,
                         connectionTimeout,
                         maxConnections,
-                        compressionEnabled,
-                        retryPolicy,
-                        trustStore
+                        retryPolicy
                     )
                 }
             }
         }
-        return Configuration(profiles)
+        return GradleBuildCacheClient.Configuration(profiles)
     }
 }

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

@@ -1,10 +1,8 @@
-package net.woggioni.rbcs.client
+package net.woggioni.gbcs.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({

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

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

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

@@ -1,17 +1,17 @@
-package net.woggioni.rbcs.client
+package net.woggioni.gbcs.client
 
 import io.netty.util.concurrent.DefaultEventExecutorGroup
 import io.netty.util.concurrent.EventExecutorGroup
-import java.util.concurrent.CompletableFuture
-import java.util.stream.Stream
-import kotlin.random.Random
-import net.woggioni.rbcs.common.contextLogger
+import net.woggioni.gbcs.common.contextLogger
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.ArgumentsProvider
 import org.junit.jupiter.params.provider.ArgumentsSource
+import java.util.concurrent.CompletableFuture
+import java.util.stream.Stream
+import kotlin.random.Random
 
 class RetryTest {
 
@@ -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 < 0.1)
+                Assertions.assertTrue(err < 1e-3)
             }
             if (index == attempts.size - 1 && index < testArgs.maxAttempt - 1) {
                 /*

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

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

gbcs-common/build.gradle

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

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

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

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.common
+package net.woggioni.gbcs.common
 
 import io.netty.buffer.ByteBuf
 import java.io.InputStream

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

@@ -1,6 +1,7 @@
-package net.woggioni.rbcs.common
+package net.woggioni.gbcs.common
 
 import io.netty.buffer.ByteBuf
+import java.io.InputStream
 import java.io.OutputStream
 
 class ByteBufOutputStream(private val buf : ByteBuf) : OutputStream() {

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

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

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

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

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.common
+package net.woggioni.gbcs.common
 
 import java.io.IOException
 import java.io.InputStream
@@ -6,13 +6,14 @@ import java.net.URL
 import java.net.URLConnection
 import java.net.URLStreamHandler
 import java.net.spi.URLStreamHandlerProvider
+import java.util.Optional
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.stream.Collectors
 
 
-class RbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
+class GbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
 
-    private class ClasspathHandler(private val classLoader: ClassLoader = RbcsUrlStreamHandlerFactory::class.java.classLoader) :
+    private class ClasspathHandler(private val classLoader: ClassLoader = GbcsUrlStreamHandlerFactory::class.java.classLoader) :
         URLStreamHandler() {
 
         override fun openConnection(u: URL): URLConnection? {
@@ -87,12 +88,12 @@ class RbcsUrlStreamHandlerFactory : URLStreamHandlerProvider() {
         private val installed = AtomicBoolean(false)
         fun install() {
             if (!installed.getAndSet(true)) {
-                URL.setURLStreamHandlerFactory(RbcsUrlStreamHandlerFactory())
+                URL.setURLStreamHandlerFactory(GbcsUrlStreamHandlerFactory())
             }
         }
 
         private val packageMap: Map<String, List<Module>> by lazy {
-            RbcsUrlStreamHandlerFactory::class.java.module.layer
+            GbcsUrlStreamHandlerFactory::class.java.module.layer
                 .modules()
                 .stream()
                 .flatMap { m: Module ->

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

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

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

@@ -0,0 +1,111 @@
+package net.woggioni.gbcs.common
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import org.slf4j.event.Level
+import java.nio.file.Files
+import java.nio.file.Path
+import java.util.logging.LogManager
+
+inline fun <reified T> T.contextLogger() = LoggerFactory.getLogger(T::class.java)
+
+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) {
+        val (format, params) = messageBuilder()
+        info(format, params)
+    }
+}
+
+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) {
+        val (format, params) = messageBuilder()
+        warn(format, params)
+    }
+}
+
+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()) {
+        log.loggerMethod(messageBuilder())
+    }
+}
+
+inline fun Logger.log(level : Level, messageBuilder : () -> String) {
+    if(isEnabledForLevel(level)) {
+        makeLoggingEventBuilder(level).log(messageBuilder())
+    }
+}
+
+inline fun Logger.trace(messageBuilder : () -> String) {
+    if(isTraceEnabled) {
+        trace(messageBuilder())
+    }
+}
+
+inline fun Logger.debug(messageBuilder : () -> String) {
+    if(isDebugEnabled) {
+        debug(messageBuilder())
+    }
+}
+
+inline fun Logger.info(messageBuilder : () -> String) {
+    if(isInfoEnabled) {
+        info(messageBuilder())
+    }
+}
+
+inline fun Logger.warn(messageBuilder : () -> String) {
+    if(isWarnEnabled) {
+        warn(messageBuilder())
+    }
+}
+
+inline fun Logger.error(messageBuilder : () -> String) {
+    if(isErrorEnabled) {
+        error(messageBuilder())
+    }
+}
+
+
+class LoggingConfig {
+
+    init {
+        val logManager = LogManager.getLogManager()
+        System.getProperty("log.config.source")?.let withSource@ { source ->
+            val urls = LoggingConfig::class.java.classLoader.getResources(source)
+            while(urls.hasMoreElements()) {
+                val url = urls.nextElement()
+                url.openStream().use { inputStream ->
+                    logManager.readConfiguration(inputStream)
+                    return@withSource
+                }
+            }
+            Path.of(source).takeIf(Files::exists)
+                ?.let(Files::newInputStream)
+                ?.use(logManager::readConfiguration)
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+package net.woggioni.gbcs.common
+
+import java.security.SecureRandom
+import java.security.spec.KeySpec
+import java.util.Base64
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.PBEKeySpec
+
+object PasswordSecurity {
+    private const val KEY_LENGTH = 256
+
+    private fun concat(arr1: ByteArray, arr2: ByteArray): ByteArray {
+        val result = ByteArray(arr1.size + arr2.size)
+        var j = 0
+        for(element in arr1) {
+            result[j] = element
+            j += 1
+        }
+        for(element in arr2) {
+            result[j] = element
+            j += 1
+        }
+        return result
+    }
+
+    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, 10, KEY_LENGTH)
+        val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1")
+        val hash = factory.generateSecret(spec).encoded
+        return String(Base64.getEncoder().encode(concat(hash, actualSalt)))
+    }
+
+    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
+    }
+}

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

@@ -1,5 +1,15 @@
-package net.woggioni.rbcs.common
+package net.woggioni.gbcs.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
+import org.w3c.dom.Node
+import org.w3c.dom.NodeList
+import org.xml.sax.SAXNotRecognizedException
+import org.xml.sax.SAXNotSupportedException
+import org.xml.sax.SAXParseException
 import java.io.InputStream
 import java.io.OutputStream
 import java.net.URL
@@ -16,16 +26,7 @@ import javax.xml.transform.stream.StreamResult
 import javax.xml.transform.stream.StreamSource
 import javax.xml.validation.Schema
 import javax.xml.validation.SchemaFactory
-import net.woggioni.jwo.JWO
-import org.slf4j.event.Level
-import org.w3c.dom.Document
-import org.w3c.dom.Element
-import org.w3c.dom.Node
-import org.w3c.dom.NodeList
 import org.xml.sax.ErrorHandler as ErrHandler
-import org.xml.sax.SAXNotRecognizedException
-import org.xml.sax.SAXNotSupportedException
-import org.xml.sax.SAXParseException
 
 
 class NodeListIterator(private val nodeList: NodeList) : Iterator<Node> {
@@ -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)

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

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

gbcs-native/build.gradle

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

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

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

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

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

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

@@ -1,13 +1,9 @@
 {
   "resources":{
   "includes":[{
-    "pattern":"\\QMETA-INF/MANIFEST.MF\\E"
-  }, {
     "pattern":"\\QMETA-INF/services/ch.qos.logback.classic.spi.Configurator\\E"
   }, {
     "pattern":"\\QMETA-INF/services/java.lang.System$LoggerFinder\\E"
-  }, {
-    "pattern":"\\QMETA-INF/services/java.net.spi.InetAddressResolverProvider\\E"
   }, {
     "pattern":"\\QMETA-INF/services/java.net.spi.URLStreamHandlerProvider\\E"
   }, {
@@ -19,26 +15,26 @@
   }, {
     "pattern":"\\QMETA-INF/services/javax.xml.parsers.SAXParserFactory\\E"
   }, {
-    "pattern":"\\QMETA-INF/services/net.woggioni.rbcs.api.CacheProvider\\E"
+    "pattern":"\\QMETA-INF/services/net.woggioni.gbcs.api.CacheProvider\\E"
   }, {
     "pattern":"\\QMETA-INF/services/org.slf4j.spi.SLF4JServiceProvider\\E"
   }, {
-    "pattern":"\\Qclasspath:net/woggioni/rbcs/cli/logback.xml\\E"
+    "pattern":"\\Qclasspath:net/woggioni/gbcs/graal/logback.xml\\E"
   }, {
     "pattern":"\\Qlogback-test.scmo\\E"
   }, {
     "pattern":"\\Qlogback.scmo\\E"
   }, {
-    "pattern":"\\Qnet/woggioni/rbcs/cli/logback.xml\\E"
+    "pattern":"\\Qnet/woggioni/gbcs/graal/logback.xml\\E"
   }, {
-    "pattern":"\\Qnet/woggioni/rbcs/client/schema/rbcs-client.xsd\\E"
+    "pattern":"\\Qnet/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd\\E"
   }, {
-    "pattern":"\\Qnet/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd\\E"
-  }, {
-    "pattern":"\\Qnet/woggioni/rbcs/server/schema/rbcs-server.xsd\\E"
+    "pattern":"\\Qnet/woggioni/gbcs/server/schema/gbcs.xsd\\E"
   }]},
   "bundles":[{
     "name":"com.sun.org.apache.xerces.internal.impl.xpath.regex.message",
     "locales":[""]
+  }, {
+    "name": "com.sun.org.apache.xerces.internal.impl.msg.XMLSchemaMessages"
   }]
 }

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

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

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

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

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

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

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

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

gbcs-server-memcache/build.gradle

@@ -29,12 +29,11 @@ configurations {
 }
 
 dependencies {
-    implementation project(':rbcs-common')
-    implementation project(':rbcs-api')
+    implementation project(':gbcs-common')
+    implementation project(':gbcs-api')
     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

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

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

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

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

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

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

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

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

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

@@ -1,44 +1,45 @@
-package net.woggioni.rbcs.server.memcache
+package net.woggioni.gbcs.server.memcache
 
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-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.Xml
-import net.woggioni.rbcs.common.Xml.Companion.asIterable
-import net.woggioni.rbcs.common.Xml.Companion.renderAttribute
+import net.woggioni.gbcs.api.CacheProvider
+import net.woggioni.gbcs.api.exception.ConfigurationException
+import net.woggioni.gbcs.common.GBCS
+import net.woggioni.gbcs.common.HostAndPort
+import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.common.Xml.Companion.asIterable
+import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
 import org.w3c.dom.Document
 import org.w3c.dom.Element
+import java.time.Duration
+import java.time.temporal.ChronoUnit
 
 
 class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.rbcs.server.memcache/net/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd"
+    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcache/net/woggioni/gbcs/server/memcache/schema/gbcs-memcache.xsd"
 
     override fun getXmlType() = "memcacheCacheType"
 
-    override fun getXmlNamespace() = "urn:net.woggioni.rbcs.server.memcache"
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcache"
 
     val xmlNamespacePrefix : String
-        get() = "rbcs-memcache"
+        get() = "gbcs-memcache"
 
     override fun deserialize(el: Element): MemcacheCacheConfiguration {
         val servers = mutableListOf<MemcacheCacheConfiguration.Server>()
         val maxAge = el.renderAttribute("max-age")
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
-        val 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
                 }
             }
-        val keyPrefix = el.renderAttribute("key-prefix")
+            ?: MemcacheCacheConfiguration.CompressionMode.DEFLATE
         val digestAlgorithm = el.renderAttribute("digest")
         for (child in el.asIterable()) {
             when (child.nodeName) {
@@ -55,13 +56,13 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
                 }
             }
         }
+
         return MemcacheCacheConfiguration(
             servers,
             maxAge,
-            keyPrefix,
+            maxSize,
             digestAlgorithm,
             compressionMode,
-            compressionLevel
         )
     }
 
@@ -69,7 +70,8 @@ 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)
+
+            attr("xs:type", "${xmlNamespacePrefix}:$xmlType", GBCS.XML_SCHEMA_NAMESPACE_URI)
             for (server in servers) {
                 node("server") {
                     attr("host", server.endpoint.host)
@@ -79,23 +81,20 @@ class MemcacheCacheProvider : CacheProvider<MemcacheCacheConfiguration> {
                     }
                     attr("max-connections", server.maxConnections.toString())
                 }
-
             }
             attr("max-age", maxAge.toString())
-            keyPrefix?.let {
-                attr("key-prefix", it)
-            }
+            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
     }

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

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

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

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

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

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

gbcs-server/build.gradle

@@ -9,12 +9,9 @@ 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')
+    api project(':gbcs-common')
+    api project(':gbcs-api')
 
 //    runtimeOnly catalog.slf4j.jdk14
     testRuntimeOnly catalog.logback.classic
@@ -22,7 +19,7 @@ dependencies {
     testImplementation catalog.bcprov.jdk18on
     testImplementation catalog.bcpkix.jdk18on
 
-    testRuntimeOnly project(":rbcs-server-memcache")
+    testRuntimeOnly project(":gbcs-server-memcache")
 }
 
 test {
@@ -39,4 +36,3 @@ publishing {
 }
 
 
-

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

@@ -0,0 +1,29 @@
+import net.woggioni.gbcs.api.CacheProvider;
+import net.woggioni.gbcs.server.cache.FileSystemCacheProvider;
+import net.woggioni.gbcs.server.cache.InMemoryCacheProvider;
+
+module net.woggioni.gbcs.server {
+    requires java.sql;
+    requires java.xml;
+    requires java.logging;
+    requires java.naming;
+    requires kotlin.stdlib;
+    requires io.netty.buffer;
+    requires io.netty.transport;
+    requires io.netty.codec.http;
+    requires io.netty.common;
+    requires io.netty.handler;
+    requires io.netty.codec;
+    requires org.slf4j;
+    requires net.woggioni.jwo;
+    requires net.woggioni.gbcs.common;
+    requires net.woggioni.gbcs.api;
+
+    exports net.woggioni.gbcs.server;
+
+    opens net.woggioni.gbcs.server;
+    opens net.woggioni.gbcs.server.schema;
+
+    uses CacheProvider;
+    provides CacheProvider with FileSystemCacheProvider, InMemoryCacheProvider;
+}

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

@@ -1,9 +1,8 @@
-package net.woggioni.rbcs.server
+package net.woggioni.gbcs.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
@@ -11,19 +10,13 @@ import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.channel.ChannelInitializer
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPromise
-import io.netty.channel.MultiThreadIoEventLoopGroup
-import io.netty.channel.nio.NioIoHandler
-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.nio.NioEventLoopGroup
 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.HttpDecoderConfig
 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,58 +28,52 @@ import io.netty.handler.timeout.IdleState
 import io.netty.handler.timeout.IdleStateEvent
 import io.netty.handler.timeout.IdleStateHandler
 import io.netty.util.AttributeKey
+import io.netty.util.concurrent.DefaultEventExecutorGroup
 import io.netty.util.concurrent.EventExecutorGroup
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.api.exception.ConfigurationException
+import net.woggioni.gbcs.common.GBCS.toUrl
+import net.woggioni.gbcs.common.PasswordSecurity.decodePasswordHash
+import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.gbcs.common.debug
+import net.woggioni.gbcs.common.info
+import net.woggioni.gbcs.server.auth.AbstractNettyHttpAuthenticator
+import net.woggioni.gbcs.server.auth.Authorizer
+import net.woggioni.gbcs.server.auth.ClientCertificateValidator
+import net.woggioni.gbcs.server.auth.RoleAuthorizer
+import net.woggioni.gbcs.server.configuration.Parser
+import net.woggioni.gbcs.server.configuration.Serializer
+import net.woggioni.gbcs.server.exception.ExceptionHandler
+import net.woggioni.gbcs.server.handler.ServerHandler
+import net.woggioni.gbcs.server.throttling.ThrottlingHandler
+import net.woggioni.jwo.JWO
+import net.woggioni.jwo.Tuple2
 import java.io.OutputStream
 import java.net.InetSocketAddress
 import java.nio.file.Files
 import java.nio.file.Path
+import java.security.KeyStore
 import java.security.PrivateKey
 import java.security.cert.X509Certificate
-import java.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
-import net.woggioni.rbcs.api.AsyncCloseable
-import net.woggioni.rbcs.api.Configuration
-import net.woggioni.rbcs.api.exception.ConfigurationException
-import net.woggioni.rbcs.common.PasswordSecurity.decodePasswordHash
-import net.woggioni.rbcs.common.PasswordSecurity.hashPassword
-import net.woggioni.rbcs.common.RBCS.getTrustManager
-import net.woggioni.rbcs.common.RBCS.loadKeystore
-import net.woggioni.rbcs.common.RBCS.toUrl
-import net.woggioni.rbcs.common.Xml
-import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.debug
-import net.woggioni.rbcs.common.info
-import net.woggioni.rbcs.server.auth.AbstractNettyHttpAuthenticator
-import net.woggioni.rbcs.server.auth.Authorizer
-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.ReadTriggerDuplexHandler
-import net.woggioni.rbcs.server.handler.ServerHandler
-import net.woggioni.rbcs.server.throttling.BucketManager
-import net.woggioni.rbcs.server.throttling.ThrottlingHandler
 
-class RemoteBuildCacheServer(private val cfg: Configuration) {
+class GradleBuildCacheServer(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")
 
-        val DEFAULT_CONFIGURATION_URL by lazy { "jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/rbcs-default.xml".toUrl() }
+        val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
         private const val SSL_HANDLER_NAME = "sslHandler"
 
         fun loadConfiguration(configurationFile: Path): Configuration {
@@ -141,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) }
             }
         }
     }
@@ -155,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 {
@@ -206,9 +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>,
-    ) : ChannelInitializer<Channel>(), AsyncCloseable {
+        private val eventExecutorGroup: EventExecutorGroup
+    ) : ChannelInitializer<Channel>() {
 
         companion object {
             private fun createSslCtx(tls: Configuration.Tls): SslContext {
@@ -228,9 +211,9 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                         val clientAuth = tls.trustStore?.let { trustStore ->
                             val ts = loadKeystore(trustStore.file, trustStore.password)
                             trustManager(
-                                getTrustManager(ts, trustStore.isCheckCertificateStatus)
+                                ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
                             )
-                            if (trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
+                            if(trustStore.isRequireClientCertificate) ClientAuth.REQUIRE
                             else ClientAuth.OPTIONAL
                         } ?: ClientAuth.NONE
                         clientAuth(clientAuth)
@@ -238,12 +221,38 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                 }
             }
 
-            private val log = createLogger<ServerInitializer>()
+            fun loadKeystore(file: Path, password: String?): KeyStore {
+                val ext = JWO.splitExtension(file)
+                    .map(Tuple2<String, String>::get_2)
+                    .orElseThrow {
+                        IllegalArgumentException(
+                            "Keystore file '${file}' must have .jks, .p12, .pfx extension"
+                        )
+                    }
+                val keystore = when (ext.substring(1).lowercase()) {
+                    "jks" -> KeyStore.getInstance("JKS")
+                    "p12", "pfx" -> KeyStore.getInstance("PKCS12")
+                    else -> throw IllegalArgumentException(
+                        "Keystore file '${file}' must have .jks, .p12, .pfx extension"
+                    )
+                }
+                Files.newInputStream(file).use {
+                    keystore.load(it, password?.let(String::toCharArray))
+                }
+                return keystore
+            }
         }
 
-        private val 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())
@@ -298,13 +307,25 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                     "Closed connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
                 }
             }
-            ch.config().isAutoRead = false
             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,
@@ -319,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()
@@ -341,117 +359,63 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
             sslContext?.newHandler(ch.alloc())?.also {
                 pipeline.addLast(SSL_HANDLER_NAME, it)
             }
-            val httpDecoderConfig = HttpDecoderConfig().apply {
-                maxChunkSize = cfg.connection.chunkSize
-            }
-            pipeline.addLast(HttpServerCodec(httpDecoderConfig))
-            pipeline.addLast(ReadTriggerDuplexHandler.NAME, ReadTriggerDuplexHandler())
-            pipeline.addLast(MaxRequestSizeHandler.NAME, MaxRequestSizeHandler(cfg.connection.maxRequestSize))
+            pipeline.addLast(HttpServerCodec())
             pipeline.addLast(HttpChunkContentCompressor(1024))
             pipeline.addLast(ChunkedWriteHandler())
+            pipeline.addLast(HttpObjectAggregator(cfg.connection.maxRequestSize))
             authenticator?.let {
                 pipeline.addLast(it)
             }
-            pipeline.addLast(ThrottlingHandler(bucketManager,cfg.rateLimiter, cfg.connection))
-
-            val serverHandler = let {
-                val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
-                ServerHandler(prefix) {
-                    cacheHandlerFactory.newHandler(cfg, ch.eventLoop(), channelFactory, datagramChannelFactory)
-                }
-            }
-            pipeline.addLast(ServerHandler.NAME, serverHandler)
-            pipeline.addLast(ExceptionHandler.NAME, 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, bossGroup, 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,
-                bossGroup: EventExecutorGroup,
-                executorGroups: Iterable<EventExecutorGroup>,
-                serverInitializer: AsyncCloseable
-            ): CompletableFuture<Void> {
-                val result = CompletableFuture<Void>()
-                closeFuture.addListener {
-                    val errors = mutableListOf<Throwable>()
-                    val deadline = Instant.now().plusSeconds(20)
-
-                    serverInitializer.asyncClose().whenCompleteAsync { _, ex ->
-                        if(ex != null) {
-                            log.error(ex.message, ex)
-                            errors.addLast(ex)
-                        }
-
-                        executorGroups.forEach(EventExecutorGroup::shutdownGracefully)
-                        bossGroup.terminationFuture().sync()
-
-                        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 {
+                "GradleBuildCacheServer has been gracefully shut down"
+            }
         }
     }
 
     fun run(): ServerHandle {
         // Create the multithreaded event loops for the server
-        val bossGroup = MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory())
-        val channelFactory = ChannelFactory<SocketChannel> { NioSocketChannel() }
-        val datagramChannelFactory = ChannelFactory<DatagramChannel> { NioDatagramChannel() }
-        val serverChannelFactory = ChannelFactory<ServerSocketChannel> { NioServerSocketChannel() }
-        val workerGroup = MultiThreadIoEventLoopGroup(0, NioIoHandler.newFactory())
-
-        val serverInitializer = ServerInitializer(cfg, channelFactory, datagramChannelFactory)
+        val bossGroup = NioEventLoopGroup(1)
+        val serverSocketChannel = NioServerSocketChannel::class.java
+        val workerGroup = NioEventLoopGroup(0)
+        val eventExecutorGroup = run {
+            val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
+                Thread.ofVirtual().factory()
+            } else {
+                null
+            }
+            DefaultEventExecutorGroup(Runtime.getRuntime().availableProcessors(), threadFactory)
+        }
         val bootstrap = ServerBootstrap().apply {
             // Configure the server
             group(bossGroup, workerGroup)
-            channelFactory(serverChannelFactory)
-            childHandler(serverInitializer)
+            channel(serverSocketChannel)
+            childHandler(ServerInitializer(cfg, eventExecutorGroup))
             option(ChannelOption.SO_BACKLOG, cfg.incomingConnectionsBacklogSize)
             childOption(ChannelOption.SO_KEEPALIVE, true)
         }
@@ -459,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}"
+            "GradleBuildCacheServer is listening on ${cfg.host}:${cfg.port}"
         }
-
-        return ServerHandle(
-            httpChannel.closeFuture(),
-            bossGroup,
-            setOf(workerGroup),
-            serverInitializer
-        )
+        return ServerHandle(httpChannel, setOf(bossGroup, workerGroup, eventExecutorGroup))
     }
 }

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

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

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

@@ -1,4 +1,4 @@
-package net.woggioni.rbcs.server.auth
+package net.woggioni.gbcs.server.auth
 
 import io.netty.buffer.Unpooled
 import io.netty.channel.ChannelFutureListener
@@ -6,16 +6,15 @@ 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
 import io.netty.handler.codec.http.HttpVersion
 import io.netty.util.ReferenceCountUtil
-import net.woggioni.rbcs.api.Configuration
-import net.woggioni.rbcs.api.Configuration.Group
-import net.woggioni.rbcs.api.Role
-import net.woggioni.rbcs.server.RemoteBuildCacheServer
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.api.Configuration.Group
+import net.woggioni.gbcs.api.Role
+import net.woggioni.gbcs.server.GradleBuildCacheServer
 
 
 abstract class AbstractNettyHttpAuthenticator(private val authorizer: Authorizer) : ChannelInboundHandlerAdapter() {
@@ -41,8 +40,8 @@ abstract class AbstractNettyHttpAuthenticator(private val authorizer: Authorizer
     override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
         if (msg is HttpRequest) {
             val result = authenticate(ctx, msg) ?: return authenticationFailure(ctx, msg)
-            ctx.channel().attr(RemoteBuildCacheServer.userAttribute).set(result.user)
-            ctx.channel().attr(RemoteBuildCacheServer.groupAttribute).set(result.groups)
+            ctx.channel().attr(GradleBuildCacheServer.userAttribute).set(result.user)
+            ctx.channel().attr(GradleBuildCacheServer.groupAttribute).set(result.groups)
 
             val roles = (
                 (result.user?.let { user ->
@@ -58,8 +57,6 @@ abstract class AbstractNettyHttpAuthenticator(private val authorizer: Authorizer
             } else {
                 authorizationFailure(ctx, msg)
             }
-        } else if(msg is HttpContent) {
-            ctx.fireChannelRead(msg)
         }
     }
 

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

@@ -1,7 +1,7 @@
-package net.woggioni.rbcs.server.auth
+package net.woggioni.gbcs.server.auth
 
 import io.netty.handler.codec.http.HttpRequest
-import net.woggioni.rbcs.api.Role
+import net.woggioni.gbcs.api.Role
 
 fun interface Authorizer {
     fun authorize(roles : Set<Role>, request: HttpRequest) : Boolean

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

@@ -0,0 +1,90 @@
+package net.woggioni.gbcs.server.auth
+
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.ChannelInboundHandlerAdapter
+import io.netty.handler.ssl.SslHandler
+import io.netty.handler.ssl.SslHandshakeCompletionEvent
+import java.security.KeyStore
+import java.security.cert.CertPathValidator
+import java.security.cert.CertPathValidatorException
+import java.security.cert.CertificateException
+import java.security.cert.CertificateFactory
+import java.security.cert.PKIXParameters
+import java.security.cert.PKIXRevocationChecker
+import java.security.cert.X509Certificate
+import java.util.EnumSet
+import javax.net.ssl.SSLSession
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509TrustManager
+
+
+class ClientCertificateValidator private constructor(
+    private val sslHandler: SslHandler,
+    private val x509TrustManager: X509TrustManager
+) : ChannelInboundHandlerAdapter() {
+    override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
+        if (evt is SslHandshakeCompletionEvent) {
+            if (evt.isSuccess) {
+                val session: SSLSession = sslHandler.engine().session
+                val clientCertificateChain = session.peerCertificates as Array<X509Certificate>
+                val authType: String = clientCertificateChain[0].publicKey.algorithm
+                x509TrustManager.checkClientTrusted(clientCertificateChain, authType)
+            } else {
+                // Handle the failure, for example by closing the channel.
+            }
+        }
+        super.userEventTriggered(ctx, evt)
+    }
+
+    companion object {
+        fun getTrustManager(trustStore: KeyStore?, certificateRevocationEnabled: Boolean): X509TrustManager {
+            return if (trustStore != null) {
+                val certificateFactory = CertificateFactory.getInstance("X.509")
+                val validator = CertPathValidator.getInstance("PKIX").apply {
+                    val rc = revocationChecker as PKIXRevocationChecker
+                    rc.options = EnumSet.of(
+                        PKIXRevocationChecker.Option.NO_FALLBACK
+                    )
+                }
+                val params = PKIXParameters(trustStore).apply {
+                    isRevocationEnabled = certificateRevocationEnabled
+                }
+                object : X509TrustManager {
+                    override fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String) {
+                        val clientCertificateChain = certificateFactory.generateCertPath(chain.toList())
+                        try {
+                            validator.validate(clientCertificateChain, params)
+                        } catch (ex: CertPathValidatorException) {
+                            throw CertificateException(ex)
+                        }
+                    }
+
+                    override fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String) {
+                        throw NotImplementedError()
+                    }
+
+                    private val acceptedIssuers = trustStore.aliases().asSequence()
+                        .filter(trustStore::isCertificateEntry)
+                        .map(trustStore::getCertificate)
+                        .map { it as X509Certificate }
+                        .toList()
+                        .toTypedArray()
+
+                    override fun getAcceptedIssuers() = acceptedIssuers
+                }
+            } else {
+                val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+                trustManagerFactory.trustManagers.asSequence().filter { it is X509TrustManager }
+                    .single() as X509TrustManager
+            }
+        }
+
+        fun of(
+            sslHandler: SslHandler,
+            trustStore: KeyStore?,
+            certificateRevocationEnabled: Boolean
+        ): ClientCertificateValidator {
+            return ClientCertificateValidator(sslHandler, getTrustManager(trustStore, certificateRevocationEnabled))
+        }
+    }
+}

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

@@ -1,16 +1,15 @@
-package net.woggioni.rbcs.server.auth
+package net.woggioni.gbcs.server.auth
 
 import io.netty.handler.codec.http.HttpMethod
 import io.netty.handler.codec.http.HttpRequest
-import net.woggioni.rbcs.api.Role
+import net.woggioni.gbcs.api.Role
 
 class RoleAuthorizer : Authorizer {
 
     companion object {
         private val METHOD_MAP = mapOf(
-            Role.Reader to setOf(HttpMethod.GET, HttpMethod.HEAD),
-            Role.Writer to setOf(HttpMethod.PUT, HttpMethod.POST),
-            Role.Healthcheck to setOf(HttpMethod.TRACE)
+            Role.Reader to setOf(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.TRACE),
+            Role.Writer to setOf(HttpMethod.PUT, HttpMethod.POST)
         )
     }
 

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

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

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

@@ -0,0 +1,27 @@
+package net.woggioni.gbcs.server.cache
+
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.common.GBCS
+import net.woggioni.jwo.Application
+import java.nio.file.Path
+import java.time.Duration
+
+data class FileSystemCacheConfiguration(
+    val root: Path?,
+    val maxAge: Duration,
+    val digestAlgorithm : String?,
+    val compressionEnabled: Boolean,
+    val compressionLevel: Int,
+) : Configuration.Cache {
+    override fun materialize() = FileSystemCache(
+        root ?: Application.builder("gbcs").build().computeCacheDirectory(),
+        maxAge,
+        digestAlgorithm,
+        compressionEnabled,
+        compressionLevel
+    )
+
+    override fun getNamespaceURI() = GBCS.GBCS_NAMESPACE_URI
+
+    override fun getTypeName() = "fileSystemCacheType"
+}

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

@@ -1,22 +1,22 @@
-package net.woggioni.rbcs.server.cache
+package net.woggioni.gbcs.server.cache
 
+import net.woggioni.gbcs.api.CacheProvider
+import net.woggioni.gbcs.common.GBCS
+import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
+import org.w3c.dom.Document
+import org.w3c.dom.Element
 import java.nio.file.Path
 import java.time.Duration
 import java.util.zip.Deflater
-import net.woggioni.rbcs.api.CacheProvider
-import net.woggioni.rbcs.common.RBCS
-import net.woggioni.rbcs.common.Xml
-import net.woggioni.rbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import org.w3c.dom.Element
 
 class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
 
-    override fun getXmlSchemaLocation() = "classpath:net/woggioni/rbcs/server/schema/rbcs-server.xsd"
+    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/server/schema/gbcs.xsd"
 
     override fun getXmlType() = "fileSystemCacheType"
 
-    override fun getXmlNamespace() = "urn:net.woggioni.rbcs.server"
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server"
 
     override fun deserialize(el: Element): FileSystemCacheConfiguration {
         val path = el.renderAttribute("path")
@@ -30,25 +30,23 @@ class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
         val compressionLevel = el.renderAttribute("compression-level")
             ?.let(String::toInt)
             ?: Deflater.DEFAULT_COMPRESSION
-        val digestAlgorithm = el.renderAttribute("digest")
+        val digestAlgorithm = el.renderAttribute("digest") ?: "MD5"
 
         return FileSystemCacheConfiguration(
             path,
             maxAge,
             digestAlgorithm,
             enableCompression,
-            compressionLevel,
+            compressionLevel
         )
     }
 
     override fun serialize(doc: Document, cache : FileSystemCacheConfiguration) = cache.run {
         val result = doc.createElement("cache")
         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())
-            }
+            val prefix = doc.lookupPrefix(GBCS.GBCS_NAMESPACE_URI)
+            attr("xs:type", "${prefix}:fileSystemCacheType", GBCS.XML_SCHEMA_NAMESPACE_URI)
+            attr("path", root.toString())
             attr("max-age", maxAge.toString())
             digestAlgorithm?.let { digestAlgorithm ->
                 attr("digest", digestAlgorithm)

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

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

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

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