updated Netty to 4.2.1

updated tomcat configuration
update Netty to 4.2.0
2025-05-07 14:46:02 +08:00 · 2025-05-01 03:42:37 +08:00 · 2025-04-16 01:06:28 +08:00 · 2025-03-24 15:01:56 +08:00 · 2025-03-24 14:42:04 +08:00 · 2025-03-11 12:29:43 +08:00
47 changed files with 1021 additions and 601 deletions
--- a/.gitea/workflows/build-dev.yaml
+++ b/.gitea/workflows/build-dev.yaml
@@ -0,0 +1,80 @@
+name: CI
+on:
+  push:
+    branches:
+      - 'dev'
+jobs:
+  build:
+    runs-on: hostinger
+    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
+
--- a/.gitea/workflows/build.yaml
+++ b/.gitea/workflows/build.yaml
@@ -52,6 +52,8 @@ 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 }}
          target: release-memcache
@@ -66,11 +68,21 @@ 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: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
      - name: Publish artifacts
        env:
          PUBLISHER_TOKEN: ${{ secrets.PUBLISHER_TOKEN }}
--- a/benchmark/rbcs-filesystem.yml
+++ b/benchmark/rbcs-filesystem.yml
@@ -0,0 +1,94 @@
+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
+
--- a/benchmark/rbcs-in-memory.yml
+++ b/benchmark/rbcs-in-memory.yml
@@ -0,0 +1,77 @@
+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
+
--- a/benchmark/rbcs-memcache.yml
+++ b/benchmark/rbcs-memcache.yml
@@ -0,0 +1,118 @@
+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
--- a/doc/benchmarks.md
+++ b/doc/benchmarks.md
@@ -16,22 +16,22 @@ All test were executed under the following conditions:

 | 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                 | 3691        | 4037        |             
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 128              | 100                | 6881        | 7483        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 512              | 10                 | 3790        | 4069        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 512              | 100                | 6716        | 7408        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 4096             | 10                 | 3399        | 1974        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 4096             | 100                | 5341        | 6402        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 65536            | 10                 | 1099        | 1116        |
-| in-memory      | Intel Celeron J3455 | 1.00      | 4                 | 65536            | 100                | 1379        | 1703        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 128              | 10                 | 4443        | 5170        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 128              | 100                | 12813       | 13568       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 512              | 10                 | 4450        | 4383        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 512              | 100                | 12212       | 13586       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 4096             | 10                 | 3441        | 3012        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 4096             | 100                | 8982        | 10452       |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 65536            | 10                 | 1391        | 1167        |
-| in-memory      | Intel Celeron J3455 | 3.50      | 4                 | 65536            | 100                | 1303        | 1151        |
+| 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

@@ -42,23 +42,22 @@ 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.25              | 128              | 10                 | 1208        | 2048        |             
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 128              | 100                | 1304        | 2394        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 10                 | 1408        | 2157        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 100                | 1282        | 1888        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 10                 | 1291        | 1256        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 100                | 1170        | 1423        |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 10                 | 313         | 606         |
-| filesystem    | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 100                | 298         | 609         |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 10                 | 2195        | 3477        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 100                | 2480        | 6207        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 10                 | 2164        | 3413        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 100                | 2842        | 6218        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 10                 | 1302        | 2591        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 100                | 2270        | 3045        |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 10                 | 375         | 394         |
-| filesystem    | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 100                | 364         | 462         |
-
+| 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

@@ -69,19 +68,19 @@ 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                 | 2505        | 2578        |             
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 128              | 100                | 3582        | 3935        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 10                 | 2495        | 2784        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 512              | 100                | 3565        | 3883        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 10                 | 2174        | 2505        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 4096             | 100                | 2937        | 3563        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 10                 | 648         | 1074        |
-| memcache      | Intel Celeron J3455 | 1.00      | 0.25              | 65536            | 100                | 724         | 1548        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 10                 | 2362        | 2927        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 128              | 100                | 5491        | 6531        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 10                 | 2125        | 2807        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 512              | 100                | 5173        | 6242        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 10                 | 1720        | 2397        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 4096             | 100                | 3871        | 5859        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 10                 | 616         | 1016        |
-| memcache      | Intel Celeron J3455 | 3.50      | 0.25              | 65536            | 100                | 820         | 1677        |
+| 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        |
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -5,7 +5,7 @@ WORKDIR /home/luser

 FROM base-release AS release-vanilla
 ADD rbcs-cli-envelope-*.jar rbcs.jar
-ENTRYPOINT ["java", "-XX:+UseSerialGC", "-XX:GCTimeRatio=24", "-jar", "/home/luser/rbcs.jar", "server"]
+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-memcache
 ADD --chown=luser:luser rbcs-cli-envelope-*.jar rbcs.jar
@@ -14,10 +14,21 @@ WORKDIR /home/luser/plugins
 RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/rbcs-server-memcache*.tar
 WORKDIR /home/luser
 ADD logback.xml .
-ENTRYPOINT ["java", "-Dlogback.configurationFile=logback.xml", "-XX:+UseSerialGC", "-XX:GCTimeRatio=24", "-jar", "/home/luser/rbcs.jar", "server"]
+ENTRYPOINT ["java", "-Dlogback.configurationFile=logback.xml", "-XX:MaxRAMPercentage=70", "-XX:GCTimeRatio=24", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "/home/luser/rbcs.jar"]

 FROM scratch AS release-native
 ADD rbcs-cli.upx /rbcs/rbcs-cli
 ENV RBCS_CONFIGURATION_DIR="/rbcs"
 WORKDIR /rbcs
-ENTRYPOINT ["/rbcs/rbcs-cli"]
+ENTRYPOINT ["/rbcs/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"]
--- a/docker/README.md
+++ b/docker/README.md
@@ -11,11 +11,15 @@ The `memcache` image is similar to the `vanilla` image, except that it also cont
 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
+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. 

-## Which image shoud I use?
+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.
--- a/docker/build.gradle
+++ b/docker/build.gradle
@@ -29,7 +29,7 @@ Provider<Copy> prepareDockerBuild = tasks.register('prepareDockerBuild', Copy) {
    group = 'docker'
    into project.layout.buildDirectory.file('docker')
    from(configurations.docker)
-    from(file('Dockerfile'))
+    from(files('Dockerfile', 'rbcs-cli.sh'))
    from(rootProject.file('conf')) {
        include 'logback.xml'
    }
--- a/docker/rbcs-cli.sh
+++ b/docker/rbcs-cli.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+DIR=/usr/share/java/rbcs
+$DIR/bin/java $JAVA_OPTS -m net.woggioni.rbcs.cli "$@"
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,9 +2,9 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true

-rbcs.version = 0.2.0
+rbcs.version = 0.3.0-SNAPSHOT

-lys.version = 2025.03.03
+lys.version = 2025.05.07

 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
 docker.registry.url=gitea.woggioni.net
--- a/rbcs-api/build.gradle
+++ b/rbcs-api/build.gradle
@@ -5,9 +5,12 @@ 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 {
--- a/rbcs-api/src/main/java/module-info.java
+++ b/rbcs-api/src/main/java/module-info.java
@@ -1,10 +1,15 @@
 module net.woggioni.rbcs.api {
    requires static lombok;
-    requires java.xml;
-    requires io.netty.buffer;
    requires io.netty.handler;
-    requires io.netty.transport;
    requires io.netty.common;
+    requires net.woggioni.rbcs.common;
+    requires io.netty.transport;
+    requires io.netty.codec.http;
+    requires io.netty.buffer;
+    requires org.slf4j;
+    requires java.xml;
+
+
    exports net.woggioni.rbcs.api;
    exports net.woggioni.rbcs.api.exception;
    exports net.woggioni.rbcs.api.message;
--- a/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheHandler.java
+++ b/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheHandler.java
@@ -0,0 +1,57 @@
+package net.woggioni.rbcs.api;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.codec.http.LastHttpContent;
+import io.netty.util.ReferenceCounted;
+import lombok.extern.slf4j.Slf4j;
+import net.woggioni.rbcs.api.message.CacheMessage;
+
+@Slf4j
+public abstract class CacheHandler extends ChannelInboundHandlerAdapter {
+    private boolean requestFinished = false;
+
+    abstract protected void channelRead0(ChannelHandlerContext ctx, CacheMessage msg);
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+        if(!requestFinished && msg instanceof CacheMessage) {
+            if(msg instanceof CacheMessage.LastCacheContent) requestFinished = true;
+            try {
+                channelRead0(ctx, (CacheMessage) msg);
+            } finally {
+                if(msg instanceof ReferenceCounted rc) rc.release();
+            }
+        } else {
+            ctx.fireChannelRead(msg);
+        }
+    }
+
+    protected void sendMessageAndFlush(ChannelHandlerContext ctx, Object msg) {
+        sendMessage(ctx, msg, true);
+    }
+
+    protected void sendMessage(ChannelHandlerContext ctx, Object msg) {
+        sendMessage(ctx, msg, false);
+    }
+
+    private void sendMessage(ChannelHandlerContext ctx, Object msg, boolean flush) {
+        ctx.write(msg);
+        if(
+                msg instanceof CacheMessage.LastCacheContent ||
+                msg instanceof CacheMessage.CachePutResponse ||
+                msg instanceof CacheMessage.CacheValueNotFoundResponse ||
+                msg instanceof LastHttpContent
+        ) {
+            ctx.flush();
+            ctx.pipeline().remove(this);
+        } else if(flush) {
+            ctx.flush();
+        }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        super.exceptionCaught(ctx, cause);
+    }
+}
--- a/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheHandlerFactory.java
+++ b/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheHandlerFactory.java
@@ -1,13 +1,12 @@
 package net.woggioni.rbcs.api;

 import io.netty.channel.ChannelFactory;
-import io.netty.channel.ChannelHandler;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.socket.DatagramChannel;
 import io.netty.channel.socket.SocketChannel;

 public interface CacheHandlerFactory extends AsyncCloseable {
-    ChannelHandler newHandler(
+    CacheHandler newHandler(
            Configuration configuration,
            EventLoopGroup eventLoopGroup,
            ChannelFactory<SocketChannel> socketChannelFactory,
--- a/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheValueMetadata.java
+++ b/rbcs-api/src/main/java/net/woggioni/rbcs/api/CacheValueMetadata.java
@@ -1,10 +1,9 @@
 package net.woggioni.rbcs.api;

+import java.io.Serializable;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;

-import java.io.Serializable;
-
@Getter
@RequiredArgsConstructor
 public class CacheValueMetadata implements Serializable {
--- a/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java
+++ b/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java
@@ -1,16 +1,15 @@
 package net.woggioni.rbcs.api;


-import lombok.EqualsAndHashCode;
-import lombok.NonNull;
-import lombok.Value;
-
 import java.nio.file.Path;
 import java.security.cert.X509Certificate;
 import java.time.Duration;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.Value;

@Value
 public class Configuration {
--- a/rbcs-cli/build.gradle
+++ b/rbcs-cli/build.gradle
@@ -18,6 +18,7 @@ import net.woggioni.gradle.graalvm.UpxTask
 import net.woggioni.gradle.graalvm.JlinkPlugin
 import net.woggioni.gradle.graalvm.JlinkTask

+
 sourceSets {
    configureNativeImage {
        java {
@@ -29,6 +30,7 @@ sourceSets {
 }

 configurations {
+
    release {
        transitive = false
        canBeConsumed = true
@@ -105,6 +107,7 @@ tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfi
    systemProperty('io.netty.leakDetectionLevel', 'DISABLED')
    modularity.inferModulePath = false
    enabled = true
+    systemProperty('gradle.tmp.dir', temporaryDir.toString())
 }

 nativeImage {
@@ -119,16 +122,36 @@ nativeImage {
    linkAtBuildTime = false
    classpath = project.files(jarTaskProvider, configurations.nativeImage)
    compressExecutable = true
-    compressionLevel = 10
+    compressionLevel = 6
    useLZMA = false
 }

 Provider<UpxTask> upxTaskProvider = tasks.named(NativeImagePlugin.UPX_TASK_NAME, UpxTask) {
 }

-tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
+Provider<JlinkTask> jlinkTaskProvider = tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+        vendor = JvmVendorSpec.GRAAL_VM
+    }
+
    mainClass = mainClassName
    mainModule = 'net.woggioni.rbcs.cli'
+    classpath = project.files(
+            configurations.configureNativeImageRuntimeClasspath,
+            sourceSets.configureNativeImage.output
+    )
+    additionalModules = [
+        'net.woggioni.rbcs.server.memcache',
+        'ch.qos.logback.classic',
+        'jdk.crypto.ec'
+    ]
+    compressionLevel = 2
+    stripDebug = false
+}
+
+Provider<Tar> jlinkDistTarTaskProvider = tasks.named(JlinkPlugin.JLINK_DIST_TAR_TASK_NAME, Tar) {
+    exclude 'lib/libjvmcicompiler.so'
 }

 tasks.named(JavaPlugin.PROCESS_RESOURCES_TASK_NAME, ProcessResources) {
@@ -142,6 +165,7 @@ tasks.named(JavaPlugin.PROCESS_RESOURCES_TASK_NAME, ProcessResources) {
 artifacts {
    release(envelopeJarTaskProvider)
    release(upxTaskProvider)
+    release(jlinkDistTarTaskProvider)
 }

 publishing {
--- a/rbcs-cli/native-image/native-image.properties
+++ b/rbcs-cli/native-image/native-image.properties
@@ -1,2 +1,2 @@
-Args=-O3 -march=skylake --gc=serial --install-exit-handlers --initialize-at-run-time=io.netty --enable-url-protocols=jpms --initialize-at-build-time=net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory,net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory$JpmsHandler
+Args=-O3 -march=x86-64-v2 --gc=serial --install-exit-handlers --initialize-at-run-time=io.netty --enable-url-protocols=jpms --initialize-at-build-time=net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory,net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory$JpmsHandler
 #-H:TraceClassInitialization=io.netty.handler.ssl.BouncyCastleAlpnSslUtils
--- a/rbcs-cli/native-image/reflect-config.json
+++ b/rbcs-cli/native-image/reflect-config.json
@@ -120,6 +120,14 @@
  "name":"io.netty.buffer.AbstractReferenceCountedByteBuf",
  "fields":[{"name":"refCnt"}]
 },
+{
+  "name":"io.netty.buffer.AdaptivePoolingAllocator$Chunk",
+  "fields":[{"name":"refCnt"}]
+},
+{
+  "name":"io.netty.buffer.AdaptivePoolingAllocator$Magazine",
+  "fields":[{"name":"nextInLine"}]
+},
 {
  "name":"io.netty.channel.AbstractChannelHandlerContext",
  "fields":[{"name":"handlerState"}]
@@ -284,20 +292,13 @@
  "fields":[{"name":"producerIndex"}]
 },
 {
-  "name":"io.netty.util.internal.shaded.org.jctools.queues.unpadded.MpscUnpaddedArrayQueueConsumerIndexField",
+  "name":"io.netty.util.internal.shaded.org.jctools.queues.MpmcArrayQueueConsumerIndexField",
  "fields":[{"name":"consumerIndex"}]
 },
 {
-  "name":"io.netty.util.internal.shaded.org.jctools.queues.unpadded.MpscUnpaddedArrayQueueProducerIndexField",
+  "name":"io.netty.util.internal.shaded.org.jctools.queues.MpmcArrayQueueProducerIndexField",
  "fields":[{"name":"producerIndex"}]
 },
-{
-  "name":"io.netty.util.internal.shaded.org.jctools.queues.unpadded.MpscUnpaddedArrayQueueProducerLimitField",
-  "fields":[{"name":"producerLimit"}]
-},
-{
-  "name":"java.io.FilePermission"
-},
 {
  "name":"java.lang.Object",
  "allDeclaredFields":true,
@@ -307,26 +308,14 @@
  "name":"java.lang.ProcessHandle",
  "methods":[{"name":"current","parameterTypes":[] }, {"name":"pid","parameterTypes":[] }]
 },
-{
-  "name":"java.lang.RuntimePermission"
-},
 {
  "name":"java.lang.System",
  "methods":[{"name":"console","parameterTypes":[] }]
 },
 {
  "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"] }]
+  "fields":[{"name":"threadLocalRandomProbe"}],
+  "methods":[{"name":"isVirtual","parameterTypes":[] }]
 },
 {
  "name":"java.nio.Bits",
@@ -358,18 +347,12 @@
 {
  "name":"java.security.AlgorithmParametersSpi"
 },
-{
-  "name":"java.security.AllPermission"
-},
 {
  "name":"java.security.KeyStoreSpi"
 },
 {
  "name":"java.security.SecureRandomParameters"
 },
-{
-  "name":"java.security.SecurityPermission"
-},
 {
  "name":"java.sql.Connection"
 },
@@ -444,9 +427,6 @@
  "name":"java.time.ZonedDateTime",
  "methods":[{"name":"parse","parameterTypes":["java.lang.CharSequence"] }]
 },
-{
-  "name":"java.util.PropertyPermission"
-},
 {
  "name":"java.util.concurrent.ForkJoinTask",
  "fields":[{"name":"aux"}, {"name":"status"}]
@@ -467,26 +447,19 @@
  "name":"java.util.concurrent.atomic.Striped64$Cell",
  "fields":[{"name":"value"}]
 },
-{
-  "name":"java.util.zip.Adler32",
-  "methods":[{"name":"update","parameterTypes":["java.nio.ByteBuffer"] }]
-},
-{
-  "name":"java.util.zip.CRC32",
-  "methods":[{"name":"update","parameterTypes":["java.nio.ByteBuffer"] }]
-},
 {
  "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":"net.woggioni.rbcs.api.CacheHandler",
+  "methods":[{"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }]
+},
 {
  "name":"net.woggioni.rbcs.cli.RemoteBuildCacheServerCli",
  "allDeclaredFields":true,
@@ -552,11 +525,7 @@
 },
 {
  "name":"net.woggioni.rbcs.client.RemoteBuildCacheClient$sendRequest$1$operationComplete$responseHandler$1",
-  "methods":[{"name":"channelInactive","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }]
-},
-{
-  "name":"net.woggioni.rbcs.client.RemoteBuildCacheClient$sendRequest$1$operationComplete$timeoutHandler$1",
-  "methods":[{"name":"userEventTriggered","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }]
+  "methods":[{"name":"channelInactive","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":"net.woggioni.rbcs.server.RemoteBuildCacheServer$HttpChunkContentCompressor",
@@ -589,8 +558,7 @@
  "methods":[{"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }]
 },
 {
-  "name":"net.woggioni.rbcs.server.handler.CacheContentHandler",
-  "methods":[{"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }]
+  "name":"net.woggioni.rbcs.server.handler.BlackHoleRequestHandler"
 },
 {
  "name":"net.woggioni.rbcs.server.handler.MaxRequestSizeHandler",
@@ -598,7 +566,7 @@
 },
 {
  "name":"net.woggioni.rbcs.server.handler.ServerHandler",
-  "methods":[{"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }, {"name":"write","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object","io.netty.channel.ChannelPromise"] }]
+  "methods":[{"name":"channelRead","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object"] }, {"name":"channelReadComplete","parameterTypes":["io.netty.channel.ChannelHandlerContext"] }, {"name":"exceptionCaught","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Throwable"] }, {"name":"write","parameterTypes":["io.netty.channel.ChannelHandlerContext","java.lang.Object","io.netty.channel.ChannelPromise"] }]
 },
 {
  "name":"net.woggioni.rbcs.server.handler.TraceHandler",
@@ -619,7 +587,7 @@
 {
  "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":[] }]
+  "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":"sun.nio.ch.SelectorImpl",
@@ -641,10 +609,6 @@
  "name":"sun.security.provider.DSA$SHA256withDSA",
  "methods":[{"name":"<init>","parameterTypes":[] }]
 },
-{
-  "name":"sun.security.provider.JavaKeyStore$JKS",
-  "methods":[{"name":"<init>","parameterTypes":[] }]
-},
 {
  "name":"sun.security.provider.MD5",
  "methods":[{"name":"<init>","parameterTypes":[] }]
@@ -733,6 +697,14 @@
  "name":"sun.security.x509.CertificatePoliciesExtension",
  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
 },
+{
+  "name":"sun.security.x509.ExtendedKeyUsageExtension",
+  "methods":[{"name":"<init>","parameterTypes":["java.lang.Boolean","java.lang.Object"] }]
+},
+{
+  "name":"sun.security.x509.IssuerAlternativeNameExtension",
+  "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"] }]
--- a/rbcs-cli/native-image/resource-config.json
+++ b/rbcs-cli/native-image/resource-config.json
@@ -32,14 +32,12 @@
    "pattern":"\\Qnet/woggioni/rbcs/cli/logback.xml\\E"
  }, {
    "pattern":"\\Qnet/woggioni/rbcs/client/schema/rbcs-client.xsd\\E"
+  }, {
+    "pattern":"\\Qnet/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd\\E"
  }, {
    "pattern":"\\Qnet/woggioni/rbcs/server/rbcs-default.xml\\E"
  }, {
    "pattern":"\\Qnet/woggioni/rbcs/server/schema/rbcs-server.xsd\\E"
-  }, {
-    "pattern":"\\Q/net/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd\\E"
-  }, {
-    "pattern":"java.base:\\Qsun/text/resources/LineBreakIteratorData\\E"
  }]},
  "bundles":[{
    "name":"com.sun.org.apache.xerces.internal.impl.xpath.regex.message",
--- a/rbcs-cli/src/configureNativeImage/kotlin/net/woggioni/rbcs/cli/graal/GraalNativeImageConfiguration.kt
+++ b/rbcs-cli/src/configureNativeImage/kotlin/net/woggioni/rbcs/cli/graal/GraalNativeImageConfiguration.kt
@@ -32,7 +32,7 @@ object GraalNativeImageConfiguration {
    @JvmStatic
    fun main(vararg args : String) {

-        val serverURL = URI.create("file:conf/rbcs-client.xml").toURL()
+        val serverURL = URI.create("file:conf/rbcs-server.xml").toURL()
        val serverDoc = serverURL.openStream().use {
            Xml.parseXml(serverURL, it)
        }
@@ -71,7 +71,6 @@ object GraalNativeImageConfiguration {
                compressionLevel = Deflater.DEFAULT_COMPRESSION,
                compressionEnabled = false,
                maxSize = 0x1000000,
-                chunkSize = 0x1000
            ),
            FileSystemCacheConfiguration(
                Path.of(System.getProperty("java.io.tmpdir")).resolve("rbcs"),
@@ -79,7 +78,6 @@ object GraalNativeImageConfiguration {
                digestAlgorithm = "MD5",
                compressionLevel = Deflater.DEFAULT_COMPRESSION,
                compressionEnabled = false,
-                chunkSize = 0x1000
            ),
            MemcacheCacheConfiguration(
                listOf(MemcacheCacheConfiguration.Server(
@@ -91,7 +89,6 @@ object GraalNativeImageConfiguration {
                "MD5",
                null,
                1,
-                0x1000
            )
        )

@@ -107,6 +104,7 @@ object GraalNativeImageConfiguration {
                    Duration.ofSeconds(15),
                    Duration.ofSeconds(15),
                    0x10000,
+                    0x1000
                ),
                users.asSequence().map { it.name to it }.toMap(),
                sequenceOf(writersGroup, readersGroup).map { it.name to it }.toMap(),
@@ -127,7 +125,6 @@ object GraalNativeImageConfiguration {
                "MD5",
                null,
                1,
-                0x1000
            )

            val serverHandle = RemoteBuildCacheServer(serverConfiguration).run()
@@ -135,7 +132,12 @@ object GraalNativeImageConfiguration {

            val clientProfile = ClientConfiguration.Profile(
                URI.create("http://127.0.0.1:$serverPort/"),
-                null,
+                ClientConfiguration.Connection(
+                    Duration.ofSeconds(5),
+                    Duration.ofSeconds(5),
+                    Duration.ofSeconds(7),
+                    true,
+                ),
                ClientConfiguration.Authentication.BasicAuthenticationCredentials("user3", PASSWORD),
                Duration.ofSeconds(3),
                10,
@@ -177,6 +179,8 @@ object GraalNativeImageConfiguration {
            } catch (ee : ExecutionException) {
            }
        }
-        RemoteBuildCacheServerCli.main("--help")
+        System.setProperty("net.woggioni.rbcs.conf.dir", System.getProperty("gradle.tmp.dir"))
+        RemoteBuildCacheServerCli.createCommandLine().execute("--version")
+        RemoteBuildCacheServerCli.createCommandLine().execute("server", "-t", "PT10S")
    }
 }
--- a/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/RemoteBuildCacheServerCli.kt
+++ b/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/RemoteBuildCacheServerCli.kt
@@ -26,8 +26,8 @@ class RemoteBuildCacheServerCli : RbcsCommand() {
        private fun setPropertyIfNotPresent(key: String, value: String) {
            System.getProperty(key) ?: System.setProperty(key, value)
        }
-        @JvmStatic
-        fun main(vararg args: String) {
+
+        fun createCommandLine() : CommandLine {
            setPropertyIfNotPresent("logback.configurationFile", "net/woggioni/rbcs/cli/logback.xml")
            setPropertyIfNotPresent("io.netty.leakDetectionLevel", "DISABLED")
            val currentClassLoader = RemoteBuildCacheServerCli::class.java.classLoader
@@ -56,7 +56,12 @@ class RemoteBuildCacheServerCli : RbcsCommand() {
                    addSubcommand(GetCommand())
                    addSubcommand(HealthCheckCommand())
                })
-            System.exit(commandLine.execute(*args))
+            return commandLine
+        }
+
+        @JvmStatic
+        fun main(vararg args: String) {
+            System.exit(createCommandLine().execute(*args))
        }
    }

--- a/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ClientCommand.kt
+++ b/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ClientCommand.kt
@@ -6,7 +6,6 @@ import net.woggioni.rbcs.client.Configuration
 import net.woggioni.rbcs.common.createLogger
 import net.woggioni.rbcs.common.debug
 import picocli.CommandLine
-import java.lang.IllegalArgumentException
 import java.nio.file.Path

@CommandLine.Command(
--- a/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/Configuration.kt
+++ b/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/Configuration.kt
@@ -38,11 +38,12 @@ data class Configuration(
        val readIdleTimeout: Duration,
        val writeIdleTimeout: Duration,
        val idleTimeout: Duration,
+        val requestPipelining : Boolean,
    )

    data class Profile(
        val serverURI: URI,
-        val connection: Connection?,
+        val connection: Connection,
        val authentication: Authentication?,
        val connectionTimeout: Duration?,
        val maxConnections: Int,
--- a/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/RemoteBuildCacheClient.kt
+++ b/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/RemoteBuildCacheClient.kt
@@ -7,8 +7,10 @@ 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.NioEventLoopGroup
+import io.netty.channel.nio.NioIoHandler
 import io.netty.channel.pool.AbstractChannelPoolHandler
 import io.netty.channel.pool.ChannelPool
 import io.netty.channel.pool.FixedChannelPool
@@ -32,12 +34,8 @@ 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 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 java.io.IOException
 import java.net.InetSocketAddress
 import java.net.URI
@@ -50,19 +48,23 @@ import java.util.concurrent.atomic.AtomicInteger
 import javax.net.ssl.TrustManagerFactory
 import javax.net.ssl.X509TrustManager
 import kotlin.random.Random
-import io.netty.util.concurrent.Future as NettyFuture
+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

 class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoCloseable {
    companion object {
        private val log = createLogger<RemoteBuildCacheClient>()
    }

-    private val group: NioEventLoopGroup
+    private val group: IoEventLoopGroup
    private val sslContext: SslContext
    private val pool: ChannelPool

    init {
-        group = NioEventLoopGroup()
+        group = MultiThreadIoEventLoopGroup(NioIoHandler.newFactory())
        sslContext = SslContextBuilder.forClient().also { builder ->
            (profile.authentication as? Configuration.Authentication.TlsClientAuthenticationCredentials)?.let { tlsClientAuthenticationCredentials ->
                builder.apply {
@@ -318,6 +320,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                        ) {
                            pipeline.remove(this)
                            responseFuture.complete(response)
+                            if(!profile.connection.requestPipelining) {
+                                pool.release(channel)
+                            }
                        }

                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
@@ -332,6 +337,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC

                        override fun channelInactive(ctx: ChannelHandlerContext) {
                            responseFuture.completeExceptionally(IOException("The remote server closed the connection"))
+                            if(!profile.connection.requestPipelining) {
+                                pool.release(channel)
+                            }
                            super.channelInactive(ctx)
                        }

@@ -352,6 +360,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                                if (this === pipeline.last()) {
                                    ctx.close()
                                }
+                                if(!profile.connection.requestPipelining) {
+                                    pool.release(channel)
+                                }
                            } else {
                                super.userEventTriggered(ctx, evt)
                            }
@@ -401,8 +412,9 @@ class RemoteBuildCacheClient(private val profile: Configuration.Profile) : AutoC
                            val ex = it.cause()
                            log.warn(ex.message, ex)
                        }
-
-                        pool.release(channel)
+                        if(profile.connection.requestPipelining) {
+                            pool.release(channel)
+                        }
                    }
                } else {
                    responseFuture.completeExceptionally(channelFuture.cause())
--- a/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/impl/Parser.kt
+++ b/rbcs-client/src/main/kotlin/net/woggioni/rbcs/client/impl/Parser.kt
@@ -30,7 +30,12 @@ object Parser {
                        ?: throw ConfigurationException("base-url attribute is required")
                    var authentication: Configuration.Authentication? = null
                    var retryPolicy: Configuration.RetryPolicy? = null
-                    var connection : Configuration.Connection? = null
+                    var connection : Configuration.Connection = Configuration.Connection(
+                        Duration.ofSeconds(60),
+                        Duration.ofSeconds(60),
+                        Duration.ofSeconds(30),
+                        false
+                    )
                    var trustStore : Configuration.TrustStore? = null
                    for (gchild in child.asIterable()) {
                        when (gchild.localName) {
@@ -97,10 +102,13 @@ object Parser {
                                    ?.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
                                )
                            }

--- a/rbcs-client/src/main/resources/net/woggioni/rbcs/client/schema/rbcs-client.xsd
+++ b/rbcs-client/src/main/resources/net/woggioni/rbcs/client/schema/rbcs-client.xsd
@@ -123,6 +123,13 @@
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
+        <xs:attribute name="request-pipelining" type="xs:boolean" use="optional" default="false">
+            <xs:annotation>
+                <xs:documentation>
+                    Enables HTTP/1.1 request pipelining
+                </xs:documentation>
+            </xs:annotation>
+        </xs:attribute>
    </xs:complexType>

    <xs:complexType name="noAuthType">
--- a/rbcs-common/build.gradle
+++ b/rbcs-common/build.gradle
@@ -6,7 +6,7 @@ plugins {
 }

 dependencies {
-    implementation project(':rbcs-api')
+    implementation catalog.netty.transport
    implementation catalog.slf4j.api
    implementation catalog.jwo
    implementation catalog.netty.buffer
--- a/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheConfiguration.kt
+++ b/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheConfiguration.kt
@@ -1,11 +1,11 @@
 package net.woggioni.rbcs.server.memcache

 import io.netty.channel.ChannelFactory
-import io.netty.channel.ChannelHandler
 import io.netty.channel.EventLoopGroup
 import io.netty.channel.pool.FixedChannelPool
 import io.netty.channel.socket.DatagramChannel
 import io.netty.channel.socket.SocketChannel
+import net.woggioni.rbcs.api.CacheHandler
 import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.common.HostAndPort
@@ -51,7 +51,7 @@ data class MemcacheCacheConfiguration(
            eventLoop: EventLoopGroup,
            socketChannelFactory: ChannelFactory<SocketChannel>,
            datagramChannelFactory: ChannelFactory<DatagramChannel>,
-        ): ChannelHandler {
+        ): CacheHandler {
            return MemcacheCacheHandler(
                MemcacheClient(
                    this@MemcacheCacheConfiguration.servers,
--- a/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheHandler.kt
+++ b/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/MemcacheCacheHandler.kt
@@ -4,7 +4,6 @@ import io.netty.buffer.ByteBuf
 import io.netty.buffer.ByteBufAllocator
 import io.netty.buffer.CompositeByteBuf
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.handler.codec.memcache.DefaultLastMemcacheContent
 import io.netty.handler.codec.memcache.DefaultMemcacheContent
 import io.netty.handler.codec.memcache.LastMemcacheContent
@@ -13,6 +12,7 @@ import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes
 import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
 import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponseStatus
 import io.netty.handler.codec.memcache.binary.DefaultBinaryMemcacheRequest
+import net.woggioni.rbcs.api.CacheHandler
 import net.woggioni.rbcs.api.CacheValueMetadata
 import net.woggioni.rbcs.api.exception.ContentTooLargeException
 import net.woggioni.rbcs.api.message.CacheMessage
@@ -58,7 +58,7 @@ class MemcacheCacheHandler(
    private val compressionLevel: Int,
    private val chunkSize: Int,
    private val maxAge: Duration
-) : SimpleChannelInboundHandler<CacheMessage>() {
+) : CacheHandler() {
    companion object {
        private val log = createLogger<MemcacheCacheHandler>()

@@ -69,10 +69,14 @@ class MemcacheCacheHandler(
        }
    }

+    private interface InProgressRequest {
+
+    }
+
    private inner class InProgressGetRequest(
-        private val key: String,
+        val key: String,
        private val ctx: ChannelHandlerContext
-    ) {
+    ) : InProgressRequest {
        private val acc = ctx.alloc().compositeBuffer()
        private val chunk = ctx.alloc().compositeBuffer()
        private val outputStream = ByteBufOutputStream(chunk).let {
@@ -98,32 +102,35 @@ class MemcacheCacheHandler(
                        acc.retain()
                        it.readObject() as CacheValueMetadata
                    }
-                    ctx.writeAndFlush(CacheValueFoundResponse(key, metadata))
+                    log.trace(ctx) {
+                        "Sending response from cache"
+                    }
+                    sendMessageAndFlush(ctx, CacheValueFoundResponse(key, metadata))
                    responseSent = true
                    acc.readerIndex(Int.SIZE_BYTES + mSize)
                }
            if (responseSent) {
                acc.readBytes(outputStream, acc.readableBytes())
-                if(acc.readableBytes() >= chunkSize) {
+                if (acc.readableBytes() >= chunkSize) {
                    flush(false)
                }
            }
        }

-        private fun flush(last : Boolean) {
+        private fun flush(last: Boolean) {
            val toSend = extractChunk(chunk, ctx.alloc())
-            val msg = if(last) {
+            val msg = if (last) {
                log.trace(ctx) {
-                    "Sending last chunk to client on channel ${ctx.channel().id().asShortText()}"
+                    "Sending last chunk to client"
                }
                LastCacheContent(toSend)
            } else {
                log.trace(ctx) {
-                    "Sending chunk to client on channel ${ctx.channel().id().asShortText()}"
+                    "Sending chunk to client"
                }
                CacheContent(toSend)
            }
-            ctx.writeAndFlush(msg)
+            sendMessageAndFlush(ctx, msg)
        }

        fun commit() {
@@ -141,14 +148,14 @@ class MemcacheCacheHandler(
    }

    private inner class InProgressPutRequest(
-        private val ch : NettyChannel,
-        metadata : CacheValueMetadata,
-        val digest : ByteBuf,
+        private val ch: NettyChannel,
+        metadata: CacheValueMetadata,
+        val digest: ByteBuf,
        val requestController: CompletableFuture<MemcacheRequestController>,
        private val alloc: ByteBufAllocator
-    ) {
+    ) : InProgressRequest {
        private var totalSize = 0
-        private var tmpFile : FileChannel? = null
+        private var tmpFile: FileChannel? = null
        private val accumulator = alloc.compositeBuffer()
        private val stream = ByteBufOutputStream(accumulator).let {
            if (compressionEnabled) {
@@ -175,7 +182,7 @@ class MemcacheCacheHandler(
            tmpFile?.let {
                flushToDisk(it, accumulator)
            }
-            if(accumulator.readableBytes() > 0x100000) {
+            if (accumulator.readableBytes() > 0x100000) {
                log.debug(ch) {
                    "Entry is too big, buffering it into a file"
                }
@@ -192,18 +199,18 @@ class MemcacheCacheHandler(
            }
        }

-        private fun flushToDisk(fc : FileChannel, buf : CompositeByteBuf) {
+        private fun flushToDisk(fc: FileChannel, buf: CompositeByteBuf) {
            val chunk = extractChunk(buf, alloc)
            fc.write(chunk.nioBuffer())
            chunk.release()
        }

-        fun commit() : Pair<Int, ReadableByteChannel> {
+        fun commit(): Pair<Int, ReadableByteChannel> {
            digest.release()
            accumulator.retain()
            stream.close()
            val fileChannel = tmpFile
-            return if(fileChannel != null) {
+            return if (fileChannel != null) {
                flushToDisk(fileChannel, accumulator)
                accumulator.release()
                fileChannel.position(0)
@@ -224,8 +231,7 @@ class MemcacheCacheHandler(
        }
    }

-    private var inProgressPutRequest: InProgressPutRequest? = null
-    private var inProgressGetRequest: InProgressGetRequest? = null
+    private var inProgressRequest: InProgressRequest? = null

    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
        when (msg) {
@@ -252,32 +258,39 @@ class MemcacheCacheHandler(
                        log.debug(ctx) {
                            "Cache hit for key ${msg.key} on memcache"
                        }
-                        inProgressGetRequest = InProgressGetRequest(msg.key, ctx)
+                        inProgressRequest = InProgressGetRequest(msg.key, ctx)
                    }

                    BinaryMemcacheResponseStatus.KEY_ENOENT -> {
                        log.debug(ctx) {
                            "Cache miss for key ${msg.key} on memcache"
                        }
-                        ctx.writeAndFlush(CacheValueNotFoundResponse())
+                        sendMessageAndFlush(ctx, CacheValueNotFoundResponse())
                    }
                }
            }

            override fun contentReceived(content: MemcacheContent) {
                log.trace(ctx) {
-                    "${if(content is LastMemcacheContent) "Last chunk" else "Chunk"} of ${content.content().readableBytes()} bytes received from memcache for key ${msg.key}"
+                    "${if (content is LastMemcacheContent) "Last chunk" else "Chunk"} of ${
+                        content.content().readableBytes()
+                    } bytes received from memcache for key ${msg.key}"
                }
-                inProgressGetRequest?.write(content.content())
-                if (content is LastMemcacheContent) {
-                    inProgressGetRequest?.commit()
+                (inProgressRequest as? InProgressGetRequest)?.let { inProgressGetRequest ->
+                    inProgressGetRequest.write(content.content())
+                    if (content is LastMemcacheContent) {
+                        inProgressRequest = null
+                        inProgressGetRequest.commit()
+                    }
                }
            }

            override fun exceptionCaught(ex: Throwable) {
-                inProgressGetRequest?.let {
-                    inProgressGetRequest = null
-                    it.rollback()
+                (inProgressRequest as? InProgressGetRequest).let { inProgressGetRequest ->
+                    inProgressGetRequest?.let {
+                        inProgressRequest = null
+                        it.rollback()
+                    }
                }
                this@MemcacheCacheHandler.exceptionCaught(ctx, ex)
            }
@@ -290,6 +303,7 @@ class MemcacheCacheHandler(
                setOpcode(BinaryMemcacheOpcodes.GET)
            }
            requestHandle.sendRequest(request)
+            requestHandle.sendContent(LastMemcacheContent.EMPTY_LAST_CONTENT)
        }
    }

@@ -305,8 +319,9 @@ class MemcacheCacheHandler(
                        log.debug(ctx) {
                            "Inserted key ${msg.key} into memcache"
                        }
-                        ctx.writeAndFlush(CachePutResponse(msg.key))
+                        sendMessageAndFlush(ctx, CachePutResponse(msg.key))
                    }
+
                    else -> this@MemcacheCacheHandler.exceptionCaught(ctx, MemcacheException(status))
                }
            }
@@ -323,86 +338,103 @@ class MemcacheCacheHandler(
                this@MemcacheCacheHandler.exceptionCaught(ctx, ex)
            }
        }
-        inProgressPutRequest = InProgressPutRequest(ctx.channel(), msg.metadata, key, requestController, ctx.alloc())
+        inProgressRequest = InProgressPutRequest(ctx.channel(), msg.metadata, key, requestController, ctx.alloc())
    }

    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest?.let { request ->
-            log.trace(ctx) {
-                "Received chunk of ${msg.content().readableBytes()} bytes for memcache"
+        val request = inProgressRequest
+        when (request) {
+            is InProgressPutRequest -> {
+                log.trace(ctx) {
+                    "Received chunk of ${msg.content().readableBytes()} bytes for memcache"
+                }
+                request.write(msg.content())
+            }
+
+            is InProgressGetRequest -> {
+                msg.release()
            }
-            request.write(msg.content())
        }
    }

    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
-        inProgressPutRequest?.let { request ->
-            inProgressPutRequest = null
-            log.trace(ctx) {
-                "Received last chunk of ${msg.content().readableBytes()} bytes for memcache"
-            }
-            request.write(msg.content())
-            val key = request.digest.retainedDuplicate()
-            val (payloadSize, payloadSource) = request.commit()
-            val extras = ctx.alloc().buffer(8, 8)
-            extras.writeInt(0)
-            extras.writeInt(encodeExpiry(maxAge))
-            val totalBodyLength = request.digest.readableBytes() + extras.readableBytes() + payloadSize
-            request.requestController.whenComplete { requestController, ex ->
-                if(ex == null) {
-                    log.trace(ctx) {
-                        "Sending SET request to memcache"
-                    }
-                    requestController.sendRequest(DefaultBinaryMemcacheRequest().apply {
-                        setOpcode(BinaryMemcacheOpcodes.SET)
-                        setKey(key)
-                        setExtras(extras)
-                        setTotalBodyLength(totalBodyLength)
-                    })
-                    log.trace(ctx) {
-                        "Sending request payload to memcache"
-                    }
-                    payloadSource.use { source ->
-                        val bb = ByteBuffer.allocate(chunkSize)
-                        while (true) {
-                            val read = source.read(bb)
-                            bb.limit()
-                            if(read >= 0 && bb.position() < chunkSize && bb.hasRemaining()) {
-                                continue
-                            }
-                            val chunk = ctx.alloc().buffer(chunkSize)
-                            bb.flip()
-                            chunk.writeBytes(bb)
-                            bb.clear()
-                            log.trace(ctx) {
-                                "Sending ${chunk.readableBytes()} bytes chunk to memcache"
-                            }
-                            if(read < 0) {
-                                requestController.sendContent(DefaultLastMemcacheContent(chunk))
-                                break
-                            } else {
-                                requestController.sendContent(DefaultMemcacheContent(chunk))
+        val request = inProgressRequest
+        when (request) {
+            is InProgressPutRequest -> {
+                inProgressRequest = null
+                log.trace(ctx) {
+                    "Received last chunk of ${msg.content().readableBytes()} bytes for memcache"
+                }
+                request.write(msg.content())
+                val key = request.digest.retainedDuplicate()
+                val (payloadSize, payloadSource) = request.commit()
+                val extras = ctx.alloc().buffer(8, 8)
+                extras.writeInt(0)
+                extras.writeInt(encodeExpiry(maxAge))
+                val totalBodyLength = request.digest.readableBytes() + extras.readableBytes() + payloadSize
+                log.trace(ctx) {
+                    "Trying to send SET request to memcache"
+                }
+                request.requestController.whenComplete { requestController, ex ->
+                    if (ex == null) {
+                        log.trace(ctx) {
+                            "Sending SET request to memcache"
+                        }
+                        requestController.sendRequest(DefaultBinaryMemcacheRequest().apply {
+                            setOpcode(BinaryMemcacheOpcodes.SET)
+                            setKey(key)
+                            setExtras(extras)
+                            setTotalBodyLength(totalBodyLength)
+                        })
+                        log.trace(ctx) {
+                            "Sending request payload to memcache"
+                        }
+                        payloadSource.use { source ->
+                            val bb = ByteBuffer.allocate(chunkSize)
+                            while (true) {
+                                val read = source.read(bb)
+                                bb.limit()
+                                if (read >= 0 && bb.position() < chunkSize && bb.hasRemaining()) {
+                                    continue
+                                }
+                                val chunk = ctx.alloc().buffer(chunkSize)
+                                bb.flip()
+                                chunk.writeBytes(bb)
+                                bb.clear()
+                                log.trace(ctx) {
+                                    "Sending ${chunk.readableBytes()} bytes chunk to memcache"
+                                }
+                                if (read < 0) {
+                                    requestController.sendContent(DefaultLastMemcacheContent(chunk))
+                                    break
+                                } else {
+                                    requestController.sendContent(DefaultMemcacheContent(chunk))
+                                }
                            }
                        }
+                    } else {
+                        payloadSource.close()
                    }
-                } else {
-                    payloadSource.close()
                }
            }
        }
    }

    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressGetRequest?.let {
-            inProgressGetRequest = null
-            it.rollback()
-        }
-        inProgressPutRequest?.let {
-            inProgressPutRequest = null
-            it.requestController.thenAccept { controller ->
-                controller.exceptionCaught(cause)
+        val request = inProgressRequest
+        when (request) {
+            is InProgressPutRequest -> {
+                inProgressRequest = null
+                request.requestController.thenAccept { controller ->
+                    controller.exceptionCaught(cause)
+                }
+                request.rollback()
+            }
+
+            is InProgressGetRequest -> {
+                inProgressRequest = null
+                request.rollback()
            }
-            it.rollback()
        }
        super.exceptionCaught(ctx, cause)
    }
--- a/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/client/MemcacheClient.kt
+++ b/rbcs-server-memcache/src/main/kotlin/net/woggioni/rbcs/server/memcache/client/MemcacheClient.kt
@@ -12,7 +12,6 @@ import io.netty.channel.ChannelPipeline
 import io.netty.channel.EventLoopGroup
 import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.channel.pool.AbstractChannelPoolHandler
-import io.netty.channel.pool.ChannelPool
 import io.netty.channel.pool.FixedChannelPool
 import io.netty.channel.socket.SocketChannel
 import io.netty.handler.codec.memcache.LastMemcacheContent
@@ -24,7 +23,7 @@ import io.netty.handler.codec.memcache.binary.BinaryMemcacheResponse
 import io.netty.util.concurrent.GenericFutureListener
 import net.woggioni.rbcs.common.HostAndPort
 import net.woggioni.rbcs.common.createLogger
-import net.woggioni.rbcs.common.warn
+import net.woggioni.rbcs.common.trace
 import net.woggioni.rbcs.server.memcache.MemcacheCacheConfiguration
 import net.woggioni.rbcs.server.memcache.MemcacheCacheHandler
 import java.io.IOException
@@ -94,18 +93,6 @@ class MemcacheClient(
        pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
            override fun operationComplete(channelFuture: NettyFuture<Channel>) {
                if (channelFuture.isSuccess) {
-
-                    var requestSent = false
-                    var requestBodySent = false
-                    var requestFinished = false
-                    var responseReceived = false
-                    var responseBodyReceived = false
-                    var responseFinished = false
-                    var requestBodySize = 0
-                    var requestBodyBytesSent = 0
-
-
-
                    val channel = channelFuture.now
                    var connectionClosedByTheRemoteServer = true
                    val closeCallback = {
@@ -113,14 +100,7 @@ class MemcacheClient(
                            val ex = IOException("The memcache server closed the connection")
                            val completed = response.completeExceptionally(ex)
                            if(!completed) responseHandler.exceptionCaught(ex)
-                            log.warn {
-                                "RequestSent: $requestSent, RequestBodySent: $requestBodySent, " +
-                                "RequestFinished: $requestFinished, ResponseReceived: $responseReceived, " +
-                                "ResponseBodyReceived: $responseBodyReceived, ResponseFinished: $responseFinished, " +
-                                "RequestBodySize: $requestBodySize, RequestBodyBytesSent: $requestBodyBytesSent"
-                            }
                        }
-                        pool.release(channel)
                    }
                    val closeListener = ChannelFutureListener {
                        closeCallback()
@@ -140,18 +120,14 @@ class MemcacheClient(
                            when (msg) {
                                is BinaryMemcacheResponse -> {
                                    responseHandler.responseReceived(msg)
-                                    responseReceived = true
                                }

                                is LastMemcacheContent -> {
-                                    responseFinished = true
                                    responseHandler.contentReceived(msg)
                                    pipeline.remove(this)
-                                    pool.release(channel)
                                }

                                is MemcacheContent -> {
-                                    responseBodyReceived = true
                                    responseHandler.contentReceived(msg)
                                }
                            }
@@ -165,35 +141,43 @@ class MemcacheClient(
                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
                            connectionClosedByTheRemoteServer = false
                            ctx.close()
-                            pool.release(channel)
                            responseHandler.exceptionCaught(cause)
                        }
                    }

-                    channel.pipeline()
-                        .addLast("client-handler", handler)
+                    channel.pipeline().addLast(handler)
                    response.complete(object : MemcacheRequestController {
+                        private var channelReleased = false

                        override fun sendRequest(request: BinaryMemcacheRequest) {
-                            requestBodySize = request.totalBodyLength() - request.keyLength() - request.extrasLength()
                            channel.writeAndFlush(request)
-                            requestSent = true
                        }

                        override fun sendContent(content: MemcacheContent) {
-                            val size = content.content().readableBytes()
                            channel.writeAndFlush(content).addListener {
-                                requestBodyBytesSent += size
-                                requestBodySent = true
                                if(content is LastMemcacheContent) {
-                                    requestFinished = true
+                                    if(!channelReleased) {
+                                        pool.release(channel)
+                                        channelReleased = true
+                                        log.trace(channel) {
+                                            "Channel released"
+                                        }
+                                    }
                                }
                            }
                        }

                        override fun exceptionCaught(ex: Throwable) {
+                            log.warn(ex.message, ex)
                            connectionClosedByTheRemoteServer = false
                            channel.close()
+                            if(!channelReleased) {
+                                pool.release(channel)
+                                channelReleased = true
+                                log.trace(channel) {
+                                    "Channel released"
+                                }
+                            }
                        }
                    })
                } else {
--- a/rbcs-server/src/main/java/module-info.java
+++ b/rbcs-server/src/main/java/module-info.java
@@ -3,21 +3,19 @@ import net.woggioni.rbcs.server.cache.FileSystemCacheProvider;
 import net.woggioni.rbcs.server.cache.InMemoryCacheProvider;

 module net.woggioni.rbcs.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.rbcs.common;
    requires net.woggioni.rbcs.api;
+    requires io.netty.codec.compression;
+    requires io.netty.transport;
+    requires io.netty.buffer;
+    requires io.netty.common;
+    requires org.slf4j;

    exports net.woggioni.rbcs.server;

--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt
@@ -11,7 +11,8 @@ import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.channel.ChannelInitializer
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPromise
-import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.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
@@ -34,30 +35,7 @@ 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.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.ServerHandler
-import net.woggioni.rbcs.server.throttling.BucketManager
-import net.woggioni.rbcs.server.throttling.ThrottlingHandler
 import java.io.OutputStream
 import java.net.InetSocketAddress
 import java.nio.file.Files
@@ -76,6 +54,29 @@ 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.BlackHoleRequestHandler
+import net.woggioni.rbcs.server.handler.MaxRequestSizeHandler
+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) {

@@ -207,7 +208,6 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
        private val cfg: Configuration,
        private val channelFactory : ChannelFactory<SocketChannel>,
        private val datagramChannelFactory : ChannelFactory<DatagramChannel>,
-        private val eventExecutorGroup: EventExecutorGroup
    ) : ChannelInitializer<Channel>(), AsyncCloseable {

        companion object {
@@ -298,6 +298,7 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                    "Closed connection ${ch.id().asShortText()} with ${ch.remoteAddress()}"
                }
            }
+            ch.config().setAutoRead(false)
            val pipeline = ch.pipeline()
            cfg.connection.also { conn ->
                val readIdleTimeout = conn.readIdleTimeout.toMillis()
@@ -358,8 +359,9 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
                    cacheHandlerFactory.newHandler(cfg, ch.eventLoop(), channelFactory, datagramChannelFactory)
                }
            }
-            pipeline.addLast(eventExecutorGroup, ServerHandler.NAME, serverHandler)
+            pipeline.addLast(ServerHandler.NAME, serverHandler)
            pipeline.addLast(ExceptionHandler.NAME, ExceptionHandler)
+            pipeline.addLast(BlackHoleRequestHandler.NAME, BlackHoleRequestHandler())
        }

        override fun asyncClose() = cacheHandlerFactory.asyncClose()
@@ -438,20 +440,13 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {

    fun run(): ServerHandle {
        // Create the multithreaded event loops for the server
-        val bossGroup = NioEventLoopGroup(1)
+        val bossGroup = MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory())
        val channelFactory = ChannelFactory<SocketChannel> { NioSocketChannel() }
        val datagramChannelFactory = ChannelFactory<DatagramChannel> { NioDatagramChannel() }
        val serverChannelFactory = ChannelFactory<ServerSocketChannel> { NioServerSocketChannel() }
-        val workerGroup = NioEventLoopGroup(0)
-        val eventExecutorGroup = run {
-            val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
-                Thread.ofVirtual().factory()
-            } else {
-                null
-            }
-            DefaultEventExecutorGroup(Runtime.getRuntime().availableProcessors(), threadFactory)
-        }
-        val serverInitializer = ServerInitializer(cfg, channelFactory, datagramChannelFactory, workerGroup)
+        val workerGroup = MultiThreadIoEventLoopGroup(0, NioIoHandler.newFactory())
+
+        val serverInitializer = ServerInitializer(cfg, channelFactory, datagramChannelFactory)
        val bootstrap = ServerBootstrap().apply {
            // Configure the server
            group(bossGroup, workerGroup)
@@ -472,7 +467,7 @@ class RemoteBuildCacheServer(private val cfg: Configuration) {
        return ServerHandle(
            httpChannel.closeFuture(),
            bossGroup,
-            setOf(workerGroup, eventExecutorGroup),
+            setOf(workerGroup),
            serverInitializer
        )
    }
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/FileSystemCacheHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/FileSystemCacheHandler.kt
@@ -2,9 +2,9 @@ package net.woggioni.rbcs.server.cache

 import io.netty.buffer.ByteBuf
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.handler.codec.http.LastHttpContent
 import io.netty.handler.stream.ChunkedNioFile
+import net.woggioni.rbcs.api.CacheHandler
 import net.woggioni.rbcs.api.message.CacheMessage
 import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
 import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
@@ -26,12 +26,18 @@ class FileSystemCacheHandler(
    private val compressionEnabled: Boolean,
    private val compressionLevel: Int,
    private val chunkSize: Int
-) : SimpleChannelInboundHandler<CacheMessage>() {
+) : CacheHandler() {
+
+    private interface InProgressRequest{
+
+    }
+
+    private class InProgressGetRequest(val request : CacheGetRequest) : InProgressRequest

    private inner class InProgressPutRequest(
        val key : String,
        private val fileSink : FileSystemCache.FileSink
-    ) {
+    ) : InProgressRequest {

        private val stream = Channels.newOutputStream(fileSink.channel).let {
            if (compressionEnabled) {
@@ -55,7 +61,7 @@ class FileSystemCacheHandler(
        }
    }

-    private var inProgressPutRequest: InProgressPutRequest? = null
+    private var inProgressRequest: InProgressRequest? = null

    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
        when (msg) {
@@ -68,55 +74,64 @@ class FileSystemCacheHandler(
    }

    private fun handleGetRequest(ctx: ChannelHandlerContext, msg: CacheGetRequest) {
-        val key = String(Base64.getUrlEncoder().encode(processCacheKey(msg.key, digestAlgorithm)))
-        cache.get(key)?.also { entryValue ->
-            ctx.writeAndFlush(CacheValueFoundResponse(msg.key, entryValue.metadata))
-            entryValue.channel.let { channel ->
-                if(compressionEnabled) {
-                    InflaterInputStream(Channels.newInputStream(channel)).use { stream ->
+        inProgressRequest = InProgressGetRequest(msg)

-                        outerLoop@
-                        while (true) {
-                            val buf = ctx.alloc().heapBuffer(chunkSize)
-                            while(buf.readableBytes() < chunkSize) {
-                                val read = buf.writeBytes(stream, chunkSize)
-                                if(read < 0) {
-                                    ctx.writeAndFlush(LastCacheContent(buf))
-                                    break@outerLoop
-                                }
-                            }
-                            ctx.writeAndFlush(CacheContent(buf))
-                        }
-                    }
-                } else {
-                    ctx.writeAndFlush(ChunkedNioFile(channel, entryValue.offset, entryValue.size - entryValue.offset, chunkSize))
-                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                }
-            }
-        } ?: ctx.writeAndFlush(CacheValueNotFoundResponse())
    }

    private fun handlePutRequest(ctx: ChannelHandlerContext, msg: CachePutRequest) {
        val key = String(Base64.getUrlEncoder().encode(processCacheKey(msg.key, digestAlgorithm)))
        val sink = cache.put(key, msg.metadata)
-        inProgressPutRequest = InProgressPutRequest(msg.key, sink)
+        inProgressRequest = InProgressPutRequest(msg.key, sink)
    }

    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest!!.write(msg.content())
+        val request = inProgressRequest
+        if(request is InProgressPutRequest) {
+            request.write(msg.content())
+        }
    }

    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
-        inProgressPutRequest?.let { request ->
-            inProgressPutRequest = null
-            request.write(msg.content())
-            request.commit()
-            ctx.writeAndFlush(CachePutResponse(request.key))
+        when(val request = inProgressRequest) {
+            is InProgressPutRequest -> {
+                inProgressRequest = null
+                request.write(msg.content())
+                request.commit()
+                sendMessageAndFlush(ctx, CachePutResponse(request.key))
+            }
+            is InProgressGetRequest -> {
+                val key = String(Base64.getUrlEncoder().encode(processCacheKey(request.request.key, digestAlgorithm)))
+                cache.get(key)?.also { entryValue ->
+                    sendMessageAndFlush(ctx, CacheValueFoundResponse(request.request.key, entryValue.metadata))
+                    entryValue.channel.let { channel ->
+                        if(compressionEnabled) {
+                            InflaterInputStream(Channels.newInputStream(channel)).use { stream ->
+
+                                outerLoop@
+                                while (true) {
+                                    val buf = ctx.alloc().heapBuffer(chunkSize)
+                                    while(buf.readableBytes() < chunkSize) {
+                                        val read = buf.writeBytes(stream, chunkSize)
+                                        if(read < 0) {
+                                            sendMessageAndFlush(ctx, LastCacheContent(buf))
+                                            break@outerLoop
+                                        }
+                                    }
+                                    sendMessageAndFlush(ctx, CacheContent(buf))
+                                }
+                            }
+                        } else {
+                            sendMessage(ctx, ChunkedNioFile(channel, entryValue.offset, entryValue.size - entryValue.offset, chunkSize))
+                            sendMessageAndFlush(ctx, LastHttpContent.EMPTY_LAST_CONTENT)
+                        }
+                    }
+                } ?: sendMessageAndFlush(ctx, CacheValueNotFoundResponse())
+            }
        }
    }

    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressPutRequest?.rollback()
+        (inProgressRequest as? InProgressPutRequest)?.rollback()
        super.exceptionCaught(ctx, cause)
    }
 }
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCache.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCache.kt
@@ -75,6 +75,10 @@ class InMemoryCache(
                                cond.await(interval.toMillis(), TimeUnit.MILLISECONDS)
                            }
                        }
+                        map.forEach {
+                            it.value.content.release()
+                        }
+                        map.clear()
                    }
                    complete(null)
                } catch (ex: Throwable) {
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCacheConfiguration.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCacheConfiguration.kt
@@ -4,7 +4,6 @@ import io.netty.channel.ChannelFactory
 import io.netty.channel.EventLoopGroup
 import io.netty.channel.socket.DatagramChannel
 import io.netty.channel.socket.SocketChannel
-import io.netty.util.concurrent.Future
 import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.Configuration
 import net.woggioni.rbcs.common.RBCS
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCacheHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/cache/InMemoryCacheHandler.kt
@@ -2,15 +2,9 @@ package net.woggioni.rbcs.server.cache

 import io.netty.buffer.ByteBuf
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.SimpleChannelInboundHandler
+import net.woggioni.rbcs.api.CacheHandler
 import net.woggioni.rbcs.api.message.CacheMessage
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheGetRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutRequest
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
+import net.woggioni.rbcs.api.message.CacheMessage.*
 import net.woggioni.rbcs.common.ByteBufOutputStream
 import net.woggioni.rbcs.common.RBCS.processCacheKey
 import java.util.zip.Deflater
@@ -22,9 +16,17 @@ class InMemoryCacheHandler(
    private val digestAlgorithm: String?,
    private val compressionEnabled: Boolean,
    private val compressionLevel: Int
-) : SimpleChannelInboundHandler<CacheMessage>() {
+) : CacheHandler() {

-    private interface InProgressPutRequest : AutoCloseable {
+    private interface InProgressRequest : AutoCloseable {
+    }
+
+    private class InProgressGetRequest(val request : CacheGetRequest) : InProgressRequest {
+        override fun close() {
+        }
+    }
+
+    private interface InProgressPutRequest : InProgressRequest {
        val request: CachePutRequest
        val buf: ByteBuf

@@ -33,18 +35,14 @@ class InMemoryCacheHandler(

    private inner class InProgressPlainPutRequest(ctx: ChannelHandlerContext, override val request: CachePutRequest) :
        InProgressPutRequest {
-        override val buf = ctx.alloc().compositeBuffer()
-
-        private val stream = ByteBufOutputStream(buf).let {
-            if (compressionEnabled) {
-                DeflaterOutputStream(it, Deflater(compressionLevel))
-            } else {
-                it
-            }
-        }
+        override val buf = ctx.alloc().compositeHeapBuffer()

        override fun append(buf: ByteBuf) {
-            this.buf.addComponent(true, buf.retain())
+            if(buf.isDirect) {
+                this.buf.writeBytes(buf)
+            } else {
+                this.buf.addComponent(true, buf.retain())
+            }
        }

        override fun close() {
@@ -72,7 +70,7 @@ class InMemoryCacheHandler(
        }
    }

-    private var inProgressPutRequest: InProgressPutRequest? = null
+    private var inProgressRequest: InProgressRequest? = null

    override fun channelRead0(ctx: ChannelHandlerContext, msg: CacheMessage) {
        when (msg) {
@@ -85,24 +83,11 @@ class InMemoryCacheHandler(
    }

    private fun handleGetRequest(ctx: ChannelHandlerContext, msg: CacheGetRequest) {
-        cache.get(processCacheKey(msg.key, digestAlgorithm))?.let { value ->
-            ctx.writeAndFlush(CacheValueFoundResponse(msg.key, value.metadata))
-            if (compressionEnabled) {
-                val buf = ctx.alloc().heapBuffer()
-                InflaterOutputStream(ByteBufOutputStream(buf)).use {
-                    value.content.readBytes(it, value.content.readableBytes())
-                    value.content.release()
-                    buf.retain()
-                }
-                ctx.writeAndFlush(LastCacheContent(buf))
-            } else {
-                ctx.writeAndFlush(LastCacheContent(value.content))
-            }
-        } ?: ctx.writeAndFlush(CacheValueNotFoundResponse())
+        inProgressRequest = InProgressGetRequest(msg)
    }

    private fun handlePutRequest(ctx: ChannelHandlerContext, msg: CachePutRequest) {
-        inProgressPutRequest = if(compressionEnabled) {
+        inProgressRequest = if(compressionEnabled) {
            InProgressCompressedPutRequest(ctx, msg)
        } else {
            InProgressPlainPutRequest(ctx, msg)
@@ -110,27 +95,46 @@ class InMemoryCacheHandler(
    }

    private fun handleCacheContent(ctx: ChannelHandlerContext, msg: CacheContent) {
-        inProgressPutRequest?.append(msg.content())
+        val req = inProgressRequest
+        if(req is InProgressPutRequest) {
+            req.append(msg.content())
+        }
    }

    private fun handleLastCacheContent(ctx: ChannelHandlerContext, msg: LastCacheContent) {
        handleCacheContent(ctx, msg)
-        inProgressPutRequest?.let { inProgressRequest ->
-            inProgressPutRequest = null
-            val buf = inProgressRequest.buf
-            buf.retain()
-            inProgressRequest.close()
-            val cacheKey = processCacheKey(inProgressRequest.request.key, digestAlgorithm)
-            cache.put(cacheKey, CacheEntry(inProgressRequest.request.metadata, buf))
-            ctx.writeAndFlush(CachePutResponse(inProgressRequest.request.key))
+        when(val req = inProgressRequest) {
+            is InProgressGetRequest -> {
+                cache.get(processCacheKey(req.request.key, digestAlgorithm))?.let { value ->
+                    sendMessageAndFlush(ctx, CacheValueFoundResponse(req.request.key, value.metadata))
+                    if (compressionEnabled) {
+                        val buf = ctx.alloc().heapBuffer()
+                        InflaterOutputStream(ByteBufOutputStream(buf)).use {
+                            value.content.readBytes(it, value.content.readableBytes())
+                            value.content.release()
+                            buf.retain()
+                        }
+                        sendMessage(ctx, LastCacheContent(buf))
+                    } else {
+                        sendMessage(ctx, LastCacheContent(value.content))
+                    }
+                } ?: sendMessage(ctx, CacheValueNotFoundResponse())
+            }
+            is InProgressPutRequest -> {
+                this.inProgressRequest = null
+                val buf = req.buf
+                buf.retain()
+                req.close()
+                val cacheKey = processCacheKey(req.request.key, digestAlgorithm)
+                cache.put(cacheKey, CacheEntry(req.request.metadata, buf))
+                sendMessageAndFlush(ctx, CachePutResponse(req.request.key))
+            }
        }
    }

    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        inProgressPutRequest?.let { req ->
-            req.buf.release()
-            inProgressPutRequest = null
-        }
+        inProgressRequest?.close()
+        inProgressRequest = null
        super.exceptionCaught(ctx, cause)
    }
 }
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/event/RequestCompletedEvent.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/event/RequestCompletedEvent.kt
@@ -1,4 +0,0 @@
-package net.woggioni.rbcs.server.event
-
-class RequestCompletedEvent {
-}
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/BlackHoleRequestHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/BlackHoleRequestHandler.kt
@@ -0,0 +1,13 @@
+package net.woggioni.rbcs.server.handler
+
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.handler.codec.http.HttpContent
+
+class BlackHoleRequestHandler : SimpleChannelInboundHandler<HttpContent>() {
+    companion object {
+        val NAME = BlackHoleRequestHandler::class.java.name
+    }
+    override fun channelRead0(ctx: ChannelHandlerContext, msg: HttpContent) {
+    }
+}
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/CacheContentHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/CacheContentHandler.kt
@@ -1,79 +0,0 @@
-package net.woggioni.rbcs.server.handler
-
-import io.netty.channel.ChannelHandler
-import io.netty.channel.ChannelHandler.Sharable
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelOutboundHandler
-import io.netty.channel.ChannelPromise
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.handler.codec.http.HttpContent
-import io.netty.handler.codec.http.LastHttpContent
-import net.woggioni.rbcs.api.message.CacheMessage.CacheValueNotFoundResponse
-import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
-import net.woggioni.rbcs.api.message.CacheMessage.CachePutResponse
-import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
-import java.net.SocketAddress
-
-class CacheContentHandler(private val pairedHandler : ChannelHandler) : SimpleChannelInboundHandler<HttpContent>(), ChannelOutboundHandler {
-    private var requestFinished = false
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: HttpContent) {
-        if(requestFinished) {
-            ctx.fireChannelRead(msg.retain())
-        } else {
-            when (msg) {
-                is LastHttpContent -> {
-                    ctx.fireChannelRead(LastCacheContent(msg.content().retain()))
-                    requestFinished = true
-                }
-                else -> ctx.fireChannelRead(CacheContent(msg.content().retain()))
-            }
-        }
-    }
-
-    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-        super.exceptionCaught(ctx, cause)
-    }
-
-
-    override fun bind(ctx: ChannelHandlerContext, localAddress: SocketAddress, promise: ChannelPromise) {
-        ctx.bind(localAddress, promise)
-    }
-
-    override fun connect(
-        ctx: ChannelHandlerContext,
-        remoteAddress: SocketAddress,
-        localAddress: SocketAddress,
-        promise: ChannelPromise
-    ) {
-        ctx.connect(remoteAddress, localAddress, promise)
-    }
-
-    override fun disconnect(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.disconnect(promise)
-    }
-
-    override fun close(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.close(promise)
-    }
-
-    override fun deregister(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.deregister(promise)
-    }
-
-    override fun read(ctx: ChannelHandlerContext) {
-        ctx.read()
-    }
-
-    override fun flush(ctx: ChannelHandlerContext) {
-        ctx.flush()
-    }
-
-    override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise) {
-        ctx.write(msg, promise)
-        if(msg is LastCacheContent || msg is CachePutResponse || msg is CacheValueNotFoundResponse || msg is LastHttpContent) {
-            ctx.pipeline().remove(pairedHandler)
-            ctx.pipeline().remove(this)
-        }
-    }
-}
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/ResponseCapHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/ResponseCapHandler.kt
@@ -1,56 +0,0 @@
-package net.woggioni.rbcs.server.handler
-
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.channel.ChannelOutboundHandler
-import io.netty.channel.ChannelPromise
-import net.woggioni.rbcs.server.event.RequestCompletedEvent
-import java.net.SocketAddress
-
-class ResponseCapHandler : ChannelInboundHandlerAdapter(), ChannelOutboundHandler {
-    val bufferedMessages = mutableListOf<Any>()
-
-    override fun bind(ctx: ChannelHandlerContext, localAddress: SocketAddress, promise: ChannelPromise) {
-        ctx.bind(localAddress, promise)
-    }
-
-    override fun connect(
-        ctx: ChannelHandlerContext,
-        remoteAddress: SocketAddress,
-        localAddress: SocketAddress,
-        promise: ChannelPromise
-    ) {
-        ctx.connect(remoteAddress, localAddress, promise)
-    }
-
-    override fun disconnect(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.disconnect(promise)
-    }
-
-    override fun close(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.close(promise)
-    }
-
-    override fun deregister(ctx: ChannelHandlerContext, promise: ChannelPromise) {
-        ctx.deregister(promise)
-    }
-
-    override fun read(ctx: ChannelHandlerContext) {
-        ctx.read()
-    }
-
-    override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise) {
-        bufferedMessages.add(msg)
-    }
-
-    override fun flush(ctx: ChannelHandlerContext) {
-    }
-
-    override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
-        if(evt is RequestCompletedEvent) {
-            for(msg in bufferedMessages) ctx.write(msg)
-            ctx.flush()
-            ctx.pipeline().remove(this)
-        }
-    }
-}
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/ServerHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/handler/ServerHandler.kt
@@ -8,6 +8,7 @@ import io.netty.handler.codec.http.DefaultFullHttpResponse
 import io.netty.handler.codec.http.DefaultHttpContent
 import io.netty.handler.codec.http.DefaultHttpResponse
 import io.netty.handler.codec.http.DefaultLastHttpContent
+import io.netty.handler.codec.http.HttpContent
 import io.netty.handler.codec.http.HttpHeaderNames
 import io.netty.handler.codec.http.HttpHeaderValues
 import io.netty.handler.codec.http.HttpHeaders
@@ -17,7 +18,6 @@ import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpUtil
 import io.netty.handler.codec.http.HttpVersion
 import io.netty.handler.codec.http.LastHttpContent
-import net.woggioni.rbcs.api.CacheHandlerFactory
 import net.woggioni.rbcs.api.CacheValueMetadata
 import net.woggioni.rbcs.api.message.CacheMessage
 import net.woggioni.rbcs.api.message.CacheMessage.CacheContent
@@ -30,10 +30,8 @@ import net.woggioni.rbcs.api.message.CacheMessage.LastCacheContent
 import net.woggioni.rbcs.common.createLogger
 import net.woggioni.rbcs.common.debug
 import net.woggioni.rbcs.common.warn
-import net.woggioni.rbcs.server.event.RequestCompletedEvent
 import net.woggioni.rbcs.server.exception.ExceptionHandler
 import java.nio.file.Path
-import java.util.Locale

 class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupplier : () -> ChannelHandler) :
    ChannelDuplexHandler() {
@@ -47,6 +45,15 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
    private var keepAlive = true
    private var pipelinedRequests = 0

+    private fun newRequest() {
+        pipelinedRequests += 1
+    }
+
+    private fun requestCompleted(ctx : ChannelHandlerContext) {
+        pipelinedRequests -= 1
+        if(pipelinedRequests == 0) ctx.read()
+    }
+
    private fun resetRequestMetadata() {
        httpVersion = HttpVersion.HTTP_1_1
        keepAlive = true
@@ -65,22 +72,44 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
        }
    }

+    private var cacheRequestInProgress : Boolean = false
+
+    override fun handlerAdded(ctx: ChannelHandlerContext) {
+        ctx.read()
+    }

    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
        when (msg) {
            is HttpRequest -> handleRequest(ctx, msg)
+            is HttpContent -> {
+                if(cacheRequestInProgress) {
+                    if(msg is LastHttpContent) {
+                        super.channelRead(ctx, LastCacheContent(msg.content().retain()))
+                        cacheRequestInProgress = false
+                    } else {
+                        super.channelRead(ctx, CacheContent(msg.content().retain()))
+                    }
+                    msg.release()
+                } else {
+                    super.channelRead(ctx, msg)
+                }
+            }
            else -> super.channelRead(ctx, msg)
        }
    }

+    override fun channelReadComplete(ctx: ChannelHandlerContext) {
+        super.channelReadComplete(ctx)
+        if(cacheRequestInProgress) {
+            ctx.read()
+        }
+    }

    override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise?) {
        if (msg is CacheMessage) {
            try {
                when (msg) {
                    is CachePutResponse -> {
-                        pipelinedRequests -= 1
-                        ctx.fireUserEventTriggered(RequestCompletedEvent())
                        val response = DefaultFullHttpResponse(httpVersion, HttpResponseStatus.CREATED)
                        val keyBytes = msg.key.toByteArray(Charsets.UTF_8)
                        response.headers().apply {
@@ -92,16 +121,18 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
                        val buf = ctx.alloc().buffer(keyBytes.size).apply {
                            writeBytes(keyBytes)
                        }
-                        ctx.writeAndFlush(DefaultLastHttpContent(buf))
+                        ctx.writeAndFlush(DefaultLastHttpContent(buf)).also {
+                            requestCompleted(ctx)
+                        }
                    }

                    is CacheValueNotFoundResponse -> {
-                        pipelinedRequests -= 1
-                        ctx.fireUserEventTriggered(RequestCompletedEvent())
                        val response = DefaultFullHttpResponse(httpVersion, HttpResponseStatus.NOT_FOUND)
                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
                        setKeepAliveHeader(response.headers())
-                        ctx.writeAndFlush(response)
+                        ctx.writeAndFlush(response).also {
+                            requestCompleted(ctx)
+                        }
                    }

                    is CacheValueFoundResponse -> {
@@ -118,9 +149,9 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
                    }

                    is LastCacheContent -> {
-                        pipelinedRequests -= 1
-                        ctx.fireUserEventTriggered(RequestCompletedEvent())
-                        ctx.writeAndFlush(DefaultLastHttpContent(msg.content()))
+                        ctx.writeAndFlush(DefaultLastHttpContent(msg.content())).also {
+                            requestCompleted(ctx)
+                        }
                    }

                    is CacheContent -> {
@@ -140,9 +171,8 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
                resetRequestMetadata()
            }
        } else if(msg is LastHttpContent) {
-            pipelinedRequests -= 1
-            ctx.fireUserEventTriggered(RequestCompletedEvent())
            ctx.write(msg, promise)
+            requestCompleted(ctx)
        } else super.write(ctx, msg, promise)
    }

@@ -153,15 +183,12 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
        if (method === HttpMethod.GET) {
            val path = Path.of(msg.uri()).normalize()
            if (path.startsWith(serverPrefix)) {
+                cacheRequestInProgress = true
                val relativePath = serverPrefix.relativize(path)
-                val key = relativePath.toString()
-                if(pipelinedRequests > 0) {
-                    ctx.pipeline().addBefore(ExceptionHandler.NAME, null, ResponseCapHandler())
-                }
+                val key : String = relativePath.toString()
+                newRequest()
                val cacheHandler = cacheHandlerSupplier()
-                ctx.pipeline().addBefore(ExceptionHandler.NAME, null, CacheContentHandler(cacheHandler))
                ctx.pipeline().addBefore(ExceptionHandler.NAME, null, cacheHandler)
-                pipelinedRequests += 1
                key.let(::CacheGetRequest)
                    .let(ctx::fireChannelRead)
                    ?: ctx.channel().write(CacheValueNotFoundResponse())
@@ -176,18 +203,15 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
        } else if (method === HttpMethod.PUT) {
            val path = Path.of(msg.uri()).normalize()
            if (path.startsWith(serverPrefix)) {
+                cacheRequestInProgress = true
                val relativePath = serverPrefix.relativize(path)
                val key = relativePath.toString()
                log.debug(ctx) {
                    "Added value for key '$key' to build cache"
                }
-                if(pipelinedRequests > 0) {
-                    ctx.pipeline().addBefore(ExceptionHandler.NAME, null, ResponseCapHandler())
-                }
+                newRequest()
                val cacheHandler = cacheHandlerSupplier()
-                ctx.pipeline().addBefore(ExceptionHandler.NAME, null, CacheContentHandler(cacheHandler))
                ctx.pipeline().addBefore(ExceptionHandler.NAME, null, cacheHandler)
-                pipelinedRequests += 1

                path.fileName?.toString()
                    ?.let {
@@ -205,11 +229,8 @@ class ServerHandler(private val serverPrefix: Path, private val cacheHandlerSupp
                ctx.writeAndFlush(response)
            }
        } else if (method == HttpMethod.TRACE) {
-            if(pipelinedRequests > 0) {
-                ctx.pipeline().addBefore(ExceptionHandler.NAME, null, ResponseCapHandler())
-            }
+            newRequest()
            ctx.pipeline().addBefore(ExceptionHandler.NAME, null, TraceHandler)
-            pipelinedRequests += 1
            super.channelRead(ctx, msg)
        } else {
            log.warn(ctx) {
--- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/throttling/ThrottlingHandler.kt
+++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/throttling/ThrottlingHandler.kt
@@ -94,6 +94,9 @@ class ThrottlingHandler(private val bucketManager : BucketManager,
                    handleBuckets(buckets, ctx, msg, false)
                }, waitDuration.toMillis(), TimeUnit.MILLISECONDS)
            } else {
+                queuedContent?.let { qc ->
+                    qc.forEach { it.release() }
+                }
                this.queuedContent = null
                sendThrottledResponse(ctx, waitDuration)
            }
--- a/rbcs-server/src/test/java/net/woggioni/rbcs/server/test/utils/CertificateUtils.java
+++ b/rbcs-server/src/test/java/net/woggioni/rbcs/server/test/utils/CertificateUtils.java
@@ -1,5 +1,14 @@
 package net.woggioni.rbcs.server.test.utils;

+import java.math.BigInteger;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Date;
 import org.bouncycastle.asn1.DERSequence;
 import org.bouncycastle.asn1.x500.X500Name;
 import org.bouncycastle.asn1.x509.BasicConstraints;
@@ -15,16 +24,6 @@ import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
 import org.bouncycastle.operator.ContentSigner;
 import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;

-import java.math.BigInteger;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.PrivateKey;
-import java.security.SecureRandom;
-import java.security.cert.X509Certificate;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.Date;
-
 public class CertificateUtils {

    public record X509Credentials(
--- a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/BasicAuthServerTest.kt
+++ b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/BasicAuthServerTest.kt
@@ -154,7 +154,7 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
    }

    @Test
-    @Order(6)
+    @Order(8)
    fun getAsAThrottledUser() {
        val client: HttpClient = HttpClient.newHttpClient()

@@ -172,7 +172,7 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
    }

    @Test
-    @Order(7)
+    @Order(9)
    fun getAsAThrottledUser2() {
        val client: HttpClient = HttpClient.newHttpClient()

--- a/rbcs-servlet/conf/server.xml
+++ b/rbcs-servlet/conf/server.xml
@@ -53,7 +53,9 @@
 <!--        <Connector port="8080" protocol="HTTP/1.1" executor="tomcatThreadPool"-->
 <!--                   connectionTimeout="20000"-->
 <!--                   redirectPort="8443" />-->
-        <Connector port="8080" protocol="HTTP/1.1"
+        <Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"
+                   maxKeepAliveRequests="1000000"
+                   keepAliveTimeout="-1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        <!-- A "Connector" using the shared thread pool-->
Author	SHA1	Message	Date
Walter Oggioni	303828392e	updated Netty to 4.2.1 All checks were successful CI / build (push) Successful in 26m57s Details	2025-05-07 14:46:02 +08:00
Walter Oggioni	5d8cbe34ef	updated tomcat configuration	2025-05-01 03:42:37 +08:00
Walter Oggioni	85c0d4a384	update Netty to 4.2.0	2025-04-16 01:06:28 +08:00
Walter Oggioni	ae8817ad2a	updated benchmarks	2025-03-24 15:01:56 +08:00
Walter Oggioni	69f215e68f	tuned GC parameters in Docker images All checks were successful CI / build (push) Successful in 16m35s Details	2025-03-24 14:42:04 +08:00
Walter Oggioni	222b475223	ensured in-memory-cache is allocated to heap memory All checks were successful CI / build (push) Successful in 12m29s Details	2025-03-11 12:29:43 +08:00
Walter Oggioni	ede515e2ca	rebuild native image with wider ISA compatibility All checks were successful CI / build (push) Successful in 14m13s Details	2025-03-10 22:28:55 +08:00
Walter Oggioni	974fdb7a91	added k8s benchmark files All checks were successful CI / build (push) Successful in 15m39s Details	2025-03-10 10:09:30 +08:00
Walter Oggioni	a294229ff0	fixed memory leak in MemcachedCacheHandler	2025-03-09 22:16:03 +08:00
Walter Oggioni	9600dd7e4f	solved issue with ignored `HttpContent` and `HttpCacheContent` messages in the Netty pipeline All checks were successful CI / build (push) Successful in 12m48s Details	2025-03-09 13:57:52 +08:00
Walter Oggioni	729276a2b1	fixed native image configuration All checks were successful CI / build (push) Successful in 14m12s Details	2025-03-08 14:35:50 +08:00
Walter Oggioni	7ba7070693	fixed server support for request pipelining All checks were successful CI / build (push) Successful in 15m33s Details	2025-03-08 11:07:21 +08:00