added Docker image build to Gitea

.gitea/workflows/build.yaml

@@ -5,10 +5,17 @@ on:
       - '*'
 jobs:
   build:
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
     runs-on: hostinger
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: graalvm
+          java-version: 21
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v3
       - name: Execute Gradle build

Dockerfile

@@ -0,0 +1,2 @@
+FROM gitea.woggioni.net/woggioni/gbcs:memcached
+COPY --chown=luser:luser conf/gbcs-memcached.xml /home/luser/.config/gbcs/gbcs.xml

build.gradle

@@ -1,12 +1,14 @@
 plugins {
-    alias catalog.plugins.kotlin.jvm apply false
+    id 'java-library'
+    alias catalog.plugins.kotlin.jvm
     alias catalog.plugins.sambal
-    alias catalog.plugins.lombok apply false
+    alias catalog.plugins.lombok
+    id 'maven-publish'
 }
 
-
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 
 allprojects { subproject ->
     group = 'net.woggioni'
@@ -66,15 +68,6 @@ allprojects { subproject ->
         }
     }
 
-    pluginManager.withPlugin('jacoco') {
-        test {
-            finalizedBy jacocoTestReport
-        }
-        jacocoTestReport {
-            dependsOn test
-        }
-    }
-
     pluginManager.withPlugin(catalog.plugins.kotlin.jvm.get().pluginId) {
         tasks.withType(KotlinCompile.class) {
             compilerOptions.jvmTarget = JvmTarget.JVM_21
@@ -109,6 +102,34 @@ allprojects { subproject ->
     }
 }
 
+dependencies {
+    implementation catalog.jwo
+    implementation catalog.slf4j.api
+    implementation catalog.netty.codec.http
+
+    api project('gbcs-base')
+    api project('gbcs-api')
+
+//    runtimeOnly catalog.slf4j.jdk14
+    testRuntimeOnly catalog.logback.classic
+
+    testImplementation catalog.bcprov.jdk18on
+    testImplementation catalog.bcpkix.jdk18on
+    testImplementation catalog.junit.jupiter.api
+    testImplementation catalog.junit.jupiter.params
+    testRuntimeOnly catalog.junit.jupiter.engine
+
+    testRuntimeOnly project("gbcs-memcached")
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from(components["java"])
+        }
+    }
+}
+
 tasks.register('version') {
     doLast {
         println("VERSION=$version")

conf/gbcs-memcached.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<gbcs:server useVirtualThreads="true" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+             xmlns:gbcs="urn:net.woggioni.gbcs"
+             xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
+             xs:schemaLocation="urn:net.woggioni.gbcs-memcached jpms://net.woggioni.gbcs.memcached/net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
+    <bind host="0.0.0.0" port="13080" />
+    <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="16777216" compression-mode="zip">
+        <server host="memcached" port="11211"/>
+    </cache>
+    <authentication>
+        <none/>
+    </authentication>
+</gbcs:server>

docker-compose.yml

@@ -0,0 +1,36 @@
+networks:
+  default:
+    external: false
+    ipam:
+      driver: default
+      config:
+        - subnet: 172.118.0.0/16
+          ip_range: 172.118.0.0/16
+          gateway: 172.118.0.254
+services:
+  gbcs:
+    build:
+      context: .
+    container_name: gbcs
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:8080:13080"
+      - "[::1]:8080:13080"
+    depends_on:
+      memcached:
+        condition: service_started
+    deploy:
+      resources:
+        limits:
+          cpus: "2.00"
+          memory: 256M
+  memcached:
+    image: memcached
+    container_name: memcached
+    restart: unless-stopped
+    command: -I 64m -m 900m
+    deploy:
+      resources:
+        limits:
+          cpus: "1.00"
+          memory: 1G

docker/Dockerfile

@@ -1,16 +1,21 @@
-FROM eclipse-temurin:21-jre-alpine AS base-release
+FROM alpine:latest AS base-release
+RUN --mount=type=cache,target=/var/cache/apk apk update
+RUN --mount=type=cache,target=/var/cache/apk apk add openjdk21-jre
 RUN adduser -D luser
 USER luser
 WORKDIR /home/luser
 
 FROM base-release AS release
 ADD gbcs-cli-envelope-*.jar gbcs.jar
-ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]
+ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar"]
 
 FROM base-release AS release-memcached
 ADD --chown=luser:luser gbcs-cli-envelope-*.jar gbcs.jar
 RUN mkdir plugins
 WORKDIR /home/luser/plugins
-RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-server-memcached*.tar
+RUN --mount=type=bind,source=.,target=/build/distributions tar -xf /build/distributions/gbcs-memcached*.tar
 WORKDIR /home/luser
-ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar", "server"]
+ENTRYPOINT ["java", "-jar", "/home/luser/gbcs.jar"]
+
+FROM release-memcached as compose
+COPY --chown=luser:luser conf/gbcs-memcached.xml /home/luser/.config/gbcs/gbcs.xml

docker/build.gradle

@@ -19,7 +19,7 @@ configurations {
 
 dependencies {
     docker project(path: ':gbcs-cli', configuration: 'release')
-    docker project(path: ':gbcs-server-memcached', configuration: 'release')
+    docker project(path: ':gbcs-memcached', configuration: 'release')
 }
 
 Provider<Task> cleanTaskProvider = tasks.named(BasePlugin.CLEAN_TASK_NAME) {}

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

@@ -2,12 +2,10 @@ package net.woggioni.gbcs.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;
@@ -16,32 +14,13 @@ import java.util.stream.Collectors;
 public class Configuration {
     String host;
     int port;
-    int incomingConnectionsBacklogSize;
     String serverPath;
-    @NonNull
-    EventExecutor eventExecutor;
-    @NonNull
-    Connection connection;
     Map<String, User> users;
     Map<String, Group> groups;
     Cache cache;
     Authentication authentication;
     Tls tls;
-
+    boolean useVirtualThread;
-    @Value
-    public static class EventExecutor {
-        boolean useVirtualThreads;
-    }
-
-    @Value
-    public static class Connection {
-        Duration readTimeout;
-        Duration writeTimeout;
-        Duration idleTimeout;
-        Duration readIdleTimeout;
-        Duration writeIdleTimeout;
-        int maxRequestSize;
-    }
 
     @Value
     public static class Group {
@@ -122,28 +101,24 @@ public class Configuration {
     public static Configuration of(
             String host,
             int port,
-            int incomingConnectionsBacklogSize,
             String serverPath,
-            EventExecutor eventExecutor,
-            Connection connection,
             Map<String, User> users,
             Map<String, Group> groups,
             Cache cache,
             Authentication authentication,
-            Tls tls
+            Tls tls,
+            boolean useVirtualThread
     ) {
         return new Configuration(
                 host,
                 port,
-                incomingConnectionsBacklogSize,
                 serverPath != null && !serverPath.isEmpty() && !serverPath.equals("/") ? serverPath : null,
-                eventExecutor,
-                connection,
                 users,
                 groups,
                 cache,
                 authentication,
-                tls
+                tls,
+                useVirtualThread
         );
     }
 }

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

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

gbcs-base/build.gradle

@@ -6,9 +6,8 @@ plugins {
 }
 
 dependencies {
-    implementation project(':gbcs-api')
+    compileOnly project(':gbcs-api')
-    implementation catalog.slf4j.api
+    compileOnly catalog.slf4j.api
-    implementation catalog.jwo
 }
 
 publishing {

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

@@ -1,9 +1,8 @@
-module net.woggioni.gbcs.common {
+module net.woggioni.gbcs.base {
     requires java.xml;
     requires java.logging;
     requires org.slf4j;
     requires kotlin.stdlib;
-    requires net.woggioni.jwo;
 
-    exports net.woggioni.gbcs.common;
+    exports net.woggioni.gbcs.base;
 }

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import java.net.URI
 import java.net.URL
@@ -6,7 +6,7 @@ import java.net.URL
 object GBCS {
     fun String.toUrl() : URL = URL.of(URI(this), null)
 
-    const val GBCS_NAMESPACE_URI: String = "urn:net.woggioni.gbcs.server"
+    const val GBCS_NAMESPACE_URI: String = "urn:net.woggioni.gbcs"
     const val GBCS_PREFIX: String = "gbcs"
     const val XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"
 }

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import java.io.IOException
 import java.io.InputStream

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

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

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

@@ -1,8 +1,7 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import org.slf4j.event.Level
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.logging.LogManager
@@ -53,12 +52,6 @@ inline fun log(log : Logger,
     }
 }
 
-inline fun Logger.log(level : Level, messageBuilder : () -> String) {
-    if(isEnabledForLevel(level)) {
-        makeLoggingEventBuilder(level).log(messageBuilder())
-    }
-}
-
 inline fun Logger.trace(messageBuilder : () -> String) {
     if(isTraceEnabled) {
         trace(messageBuilder())

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
 import java.security.SecureRandom
 import java.security.spec.KeySpec

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

@@ -1,8 +1,6 @@
-package net.woggioni.gbcs.common
+package net.woggioni.gbcs.base
 
-import net.woggioni.jwo.JWO
 import org.slf4j.LoggerFactory
-import org.slf4j.event.Level
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 import org.w3c.dom.Node
@@ -82,36 +80,31 @@ class Xml(val doc: Document, val element: Element) {
             private val log = LoggerFactory.getLogger(ErrorHandler::class.java)
         }
 
-         override fun warning(ex: SAXParseException)= err(ex, Level.WARN)
+        override fun warning(ex: SAXParseException) {
-
+            log.warn(
-        private fun err(ex: SAXParseException, level: Level) {
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
-            log.log(level) {
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
-                "Problem at ${fileURL}:${ex.lineNumber}:${ex.columnNumber} parsing deployment configuration: ${ex.message}"
+            )
         }
+
+        override fun error(ex: SAXParseException) {
+            log.error(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
             throw ex
         }
 
-        override fun error(ex: SAXParseException) = err(ex, Level.ERROR)
+        override fun fatalError(ex: SAXParseException) {
-        override fun fatalError(ex: SAXParseException) = err(ex, Level.ERROR)
+            log.error(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+            throw ex
+        }
     }
 
     companion object {
-        private val dictMap: Map<String, Map<String, Any>> = sequenceOf(
-            "env" to System.getenv().asSequence().map { (k, v) -> k to (v as Any) }.toMap(),
-            "sys" to System.getProperties().asSequence().map { (k, v) -> k as String to (v as Any) }.toMap()
-        ).toMap()
-
-        private fun renderConfigurationTemplate(template: String): String {
-            return JWO.renderTemplate(template, emptyMap(), dictMap).replace("$$", "$")
-        }
-
-        fun Element.renderAttribute(name : String, namespaceURI: String? = null) = if(namespaceURI == null) {
-            getAttribute(name)
-        } else {
-            getAttributeNS(name, namespaceURI)
-        }.takeIf(String::isNotEmpty)?.let(Companion::renderConfigurationTemplate)
-
-
         fun Element.asIterable() = Iterable { ElementIterator(this, null) }
         fun NodeList.asIterable() = Iterable { NodeListIterator(this) }
 
@@ -153,8 +146,8 @@ class Xml(val doc: Document, val element: Element) {
             dbf.isExpandEntityReferences = true
             dbf.isIgnoringComments = true
             dbf.isNamespaceAware = true
-            dbf.isValidating = schemaResourceURL == null
+            dbf.isValidating = false
-            dbf.setFeature("http://apache.org/xml/features/validation/schema", true)
+            dbf.setFeature("http://apache.org/xml/features/validation/schema", true);
             schemaResourceURL?.let {
                 dbf.schema = getSchema(it)
             }
@@ -190,12 +183,7 @@ class Xml(val doc: Document, val element: Element) {
             transformer.transform(source, result)
         }
 
-        fun of(
+        fun of(namespaceURI: String, qualifiedName: String, schemaResourceURL: URL? = null, cb: Xml.(el: Element) -> Unit): Document {
-            namespaceURI: String,
-            qualifiedName: String,
-            schemaResourceURL: URL? = null,
-            cb: Xml.(el: Element) -> Unit
-        ): Document {
             val dbf = newDocumentBuilderFactory(schemaResourceURL)
             val db = dbf.newDocumentBuilder()
             val doc = db.newDocument()

gbcs-cli/build.gradle

@@ -4,17 +4,15 @@ plugins {
     alias catalog.plugins.envelope
     alias catalog.plugins.sambal
     alias catalog.plugins.graalvm.native.image
-    alias catalog.plugins.graalvm.jlink
-    alias catalog.plugins.jpms.check
     id 'maven-publish'
 }
 
 import net.woggioni.gradle.envelope.EnvelopeJarTask
-import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
 import net.woggioni.gradle.graalvm.NativeImagePlugin
 import net.woggioni.gradle.graalvm.NativeImageTask
-import net.woggioni.gradle.graalvm.JlinkPlugin
+import net.woggioni.gradle.graalvm.NativeImageConfigurationTask
-import net.woggioni.gradle.graalvm.JlinkTask
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 Property<String> mainClassName = objects.property(String.class)
 mainClassName.set('net.woggioni.gbcs.cli.GradleBuildCacheServerCli')
@@ -45,8 +43,7 @@ dependencies {
     implementation catalog.netty.codec.http
     implementation catalog.picocli
 
-    implementation project(':gbcs-client')
+    implementation rootProject
-    implementation project(':gbcs-server')
 
 //    runtimeOnly catalog.slf4j.jdk14
     runtimeOnly catalog.logback.classic
@@ -59,20 +56,15 @@ Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named('envelopeJar', E
 }
 
 tasks.named(NativeImagePlugin.CONFIGURE_NATIVE_IMAGE_TASK_NAME, NativeImageConfigurationTask) {
-    mainClass = mainClassName
+    mainClass = 'net.woggioni.gbcs.GraalNativeImageConfiguration'
 }
 
 tasks.named(NativeImagePlugin.NATIVE_IMAGE_TASK_NAME, NativeImageTask) {
-    mainClass = mainClassName
+    mainClass = 'net.woggioni.gbcs.GradleBuildCacheServer'
     useMusl = true
     buildStaticImage = true
 }
 
-tasks.named(JlinkPlugin.JLINK_TASK_NAME, JlinkTask) {
-    mainClass = mainClassName
-    mainModule = 'net.woggioni.gbcs.cli'
-}
-
 artifacts {
     release(envelopeJarTaskProvider)
 }

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

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

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

@@ -1,24 +1,28 @@
 package net.woggioni.gbcs.cli
 
-import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
+import net.woggioni.gbcs.GradleBuildCacheServer
-import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.gbcs.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
+import net.woggioni.gbcs.base.GbcsUrlStreamHandlerFactory
+import net.woggioni.gbcs.base.contextLogger
+import net.woggioni.gbcs.base.debug
+import net.woggioni.gbcs.base.info
 import net.woggioni.gbcs.cli.impl.AbstractVersionProvider
 import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.cli.impl.commands.BenchmarkCommand
-import net.woggioni.gbcs.cli.impl.commands.ClientCommand
-import net.woggioni.gbcs.cli.impl.commands.GetCommand
 import net.woggioni.gbcs.cli.impl.commands.PasswordHashCommand
-import net.woggioni.gbcs.cli.impl.commands.PutCommand
-import net.woggioni.gbcs.cli.impl.commands.ServerCommand
 import net.woggioni.jwo.Application
+import net.woggioni.jwo.JWO
+import org.slf4j.Logger
 import picocli.CommandLine
 import picocli.CommandLine.Model.CommandSpec
+import java.io.ByteArrayOutputStream
+import java.nio.file.Files
+import java.nio.file.Path
 
 
 @CommandLine.Command(
     name = "gbcs", versionProvider = GradleBuildCacheServerCli.VersionProvider::class
 )
-class GradleBuildCacheServerCli : GbcsCommand() {
+class GradleBuildCacheServerCli(application : Application, private val log : Logger) : GbcsCommand() {
 
     class VersionProvider : AbstractVersionProvider()
     companion object {
@@ -31,24 +35,24 @@ class GradleBuildCacheServerCli : GbcsCommand() {
                 .configurationDirectoryEnvVar("GBCS_CONFIGURATION_DIR")
                 .configurationDirectoryPropertyKey("net.woggioni.gbcs.conf.dir")
                 .build()
-            val gbcsCli = GradleBuildCacheServerCli()
+            val gbcsCli = GradleBuildCacheServerCli(app, log)
             val commandLine = CommandLine(gbcsCli)
             commandLine.setExecutionExceptionHandler { ex, cl, parseResult ->
                 log.error(ex.message, ex)
                 CommandLine.ExitCode.SOFTWARE
             }
-            commandLine.addSubcommand(ServerCommand(app))
             commandLine.addSubcommand(PasswordHashCommand())
-            commandLine.addSubcommand(
-                CommandLine(ClientCommand(app)).apply {
-                    addSubcommand(BenchmarkCommand())
-                    addSubcommand(PutCommand())
-                    addSubcommand(GetCommand())
-                })
             System.exit(commandLine.execute(*args))
         }
     }
 
+    @CommandLine.Option(
+        names = ["-c", "--config-file"],
+        description = ["Read the application configuration from this file"],
+        paramLabel = "CONFIG_FILE"
+    )
+    private var configurationFile: Path = findConfigurationFile(application)
+
     @CommandLine.Option(names = ["-V", "--version"], versionHelp = true)
     var versionHelp = false
         private set
@@ -56,8 +60,40 @@ class GradleBuildCacheServerCli : GbcsCommand() {
     @CommandLine.Spec
     private lateinit var spec: CommandSpec
 
+    private fun findConfigurationFile(app : Application): Path {
+        val confDir = app.computeConfigurationDirectory()
+        val configurationFile = confDir.resolve("gbcs.xml")
+        return configurationFile
+    }
+
+    private fun createDefaultConfigurationFile(configurationFile : Path) {
+        log.info {
+            "Creating default configuration file at '$configurationFile'"
+        }
+        val defaultConfigurationFileResource = DEFAULT_CONFIGURATION_URL
+        Files.newOutputStream(configurationFile).use { outputStream ->
+            defaultConfigurationFileResource.openStream().use { inputStream ->
+                JWO.copy(inputStream, outputStream)
+            }
+        }
+    }
 
     override fun run() {
-        spec.commandLine().usage(System.out);
+        if (!Files.exists(configurationFile)) {
+            Files.createDirectories(configurationFile.parent)
+            createDefaultConfigurationFile(configurationFile)
+        }
+
+        val configuration = GradleBuildCacheServer.loadConfiguration(configurationFile)
+        log.debug {
+            ByteArrayOutputStream().also {
+                GradleBuildCacheServer.dumpConfiguration(configuration, it)
+            }.let {
+                "Server configuration:\n${String(it.toByteArray())}"
+            }
+        }
+        val server = GradleBuildCacheServer(configuration)
+        server.run().use {
+        }
     }
 }

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

@@ -1,6 +1,8 @@
 package net.woggioni.gbcs.cli.impl
 
 import picocli.CommandLine
+import java.net.URL
+import java.util.Enumeration
 import java.util.jar.Attributes
 import java.util.jar.JarFile
 import java.util.jar.Manifest

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

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

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

@@ -1,133 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.error
-import net.woggioni.gbcs.common.info
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GbcsClient
-import picocli.CommandLine
-import java.security.SecureRandom
-import java.time.Duration
-import java.time.Instant
-import java.util.Base64
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.Future
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.atomic.AtomicLong
-import kotlin.random.Random
-
-@CommandLine.Command(
-    name = "benchmark",
-    description = ["Run a load test against the server"],
-    showDefaultValues = true
-)
-class BenchmarkCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    @CommandLine.Option(
-        names = ["-e", "--entries"],
-        description = ["Total number of elements to be added to the cache"],
-        paramLabel = "NUMBER_OF_ENTRIES"
-    )
-    private var numberOfEntries = 1000
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        val client = GbcsClient(profile)
-
-        val entryGenerator = sequence {
-            val random = Random(SecureRandom.getInstance("NativePRNGNonBlocking").nextLong())
-            while (true) {
-                val key = Base64.getUrlEncoder().encode(random.nextBytes(16)).toString(Charsets.UTF_8)
-                val content = random.nextInt().toByte()
-                val value = ByteArray(0x1000, { _ -> content })
-                yield(key to value)
-            }
-        }
-
-        val entries = let {
-            val completionQueue = LinkedBlockingQueue<Future<Pair<String, ByteArray>>>(numberOfEntries)
-            val start = Instant.now()
-            val totalElapsedTime = AtomicLong(0)
-            entryGenerator.take(numberOfEntries).forEach { entry ->
-                val requestStart = System.nanoTime()
-                val future = client.put(entry.first, entry.second).thenApply { entry }
-                future.whenComplete { _, _ ->
-                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
-                    completionQueue.put(future)
-                }
-            }
-
-            val inserted = sequence<Pair<String, ByteArray>> {
-                var completionCounter = 0
-                while (completionCounter < numberOfEntries) {
-                    val future = completionQueue.take()
-                    try {
-                        yield(future.get())
-                    } catch (ee: ExecutionException) {
-                        val cause = ee.cause ?: ee
-                        log.error(cause.message, cause)
-                    }
-                    completionCounter += 1
-                }
-            }.toList()
-            val end = Instant.now()
-            log.info {
-                val elapsed = Duration.between(start, end).toMillis()
-                "Insertion rate: ${numberOfEntries.toDouble() / elapsed * 1000} ops/s"
-            }
-            log.info {
-                "Average time per insertion: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1000} ms"
-            }
-            inserted
-        }
-        log.info {
-            "Inserted ${entries.size} entries"
-        }
-        if (entries.isNotEmpty()) {
-            val completionQueue = LinkedBlockingQueue<Future<Unit>>(entries.size)
-            val start = Instant.now()
-            val totalElapsedTime = AtomicLong(0)
-            entries.forEach { entry ->
-                val requestStart = System.nanoTime()
-                val future = client.get(entry.first).thenApply {
-                    totalElapsedTime.addAndGet((System.nanoTime() - requestStart))
-                    if (it == null) {
-                        log.error {
-                            "Missing entry for key '${entry.first}'"
-                        }
-                    } else if (!entry.second.contentEquals(it)) {
-                        log.error {
-                            "Retrieved a value different from what was inserted for key '${entry.first}'"
-                        }
-                    }
-                }
-                future.whenComplete { _, _ ->
-                    completionQueue.put(future)
-                }
-            }
-            var completionCounter = 0
-            while (completionCounter < entries.size) {
-                completionQueue.take()
-                completionCounter += 1
-            }
-            val end = Instant.now()
-            log.info {
-                val elapsed = Duration.between(start, end).toMillis()
-                "Retrieval rate: ${entries.size.toDouble() / elapsed * 1000} ops/s"
-            }
-            log.info {
-                "Average time per retrieval: ${totalElapsedTime.get() / numberOfEntries.toDouble() * 1e6} ms"
-            }
-        } else {
-            log.error("Skipping retrieval benchmark as it was not possible to insert any entry in the cache")
-        }
-    }
-}

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

@@ -1,41 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GbcsClient
-import net.woggioni.jwo.Application
-import picocli.CommandLine
-import java.nio.file.Path
-
-@CommandLine.Command(
-    name = "client",
-    description = ["GBCS client"],
-    showDefaultValues = true
-)
-class ClientCommand(app : Application) : GbcsCommand() {
-
-    @CommandLine.Option(
-        names = ["-c", "--configuration"],
-        description = ["Path to the client configuration file"],
-        paramLabel = "CONFIGURATION_FILE"
-    )
-    private var configurationFile : Path = findConfigurationFile(app, "gbcs-client.xml")
-
-    @CommandLine.Option(
-        names = ["-p", "--profile"],
-        description = ["Name of the client profile to be used"],
-        paramLabel = "PROFILE",
-        required = true
-    )
-    var profileName : String? = null
-
-    val configuration : GbcsClient.Configuration by lazy {
-        GbcsClient.Configuration.parse(configurationFile)
-    }
-
-    override fun run() {
-        println("Available profiles:")
-        configuration.profiles.forEach { (profileName, _) ->
-            println(profileName)
-        }
-    }
-}

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

@@ -1,51 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.gbcs.client.GbcsClient
-import picocli.CommandLine
-import java.nio.file.Files
-import java.nio.file.Path
-
-@CommandLine.Command(
-    name = "get",
-    description = ["Fetch a value from the cache with the specified key"],
-    showDefaultValues = true
-)
-class GetCommand : GbcsCommand() {
-    private val log = contextLogger()
-
-    @CommandLine.Spec
-    private lateinit var spec: CommandLine.Model.CommandSpec
-
-    @CommandLine.Option(
-        names = ["-k", "--key"],
-        description = ["The key for the new value"],
-        paramLabel = "KEY"
-    )
-    private var key : String = ""
-
-    @CommandLine.Option(
-        names = ["-v", "--value"],
-        description = ["Path to a file where the retrieved value will be written (defaults to stdout)"],
-        paramLabel = "VALUE_FILE",
-    )
-    private var output : Path? = null
-
-    override fun run() {
-        val clientCommand = spec.parent().userObject() as ClientCommand
-        val profile = clientCommand.profileName.let { profileName ->
-            clientCommand.configuration.profiles[profileName]
-                ?: throw IllegalArgumentException("Profile $profileName does not exist in configuration")
-        }
-        GbcsClient(profile).use { client ->
-            client.get(key).thenApply { value ->
-                value?.let {
-                    (output?.let(Files::newOutputStream) ?: System.out).use {
-                        it.write(value)
-                    }
-                } ?: throw NoSuchElementException("No value found for key $key")
-            }.get()
-        }
-    }
-}

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

@@ -1,13 +1,13 @@
 package net.woggioni.gbcs.cli.impl.commands
 
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
 import net.woggioni.gbcs.cli.impl.GbcsCommand
 import net.woggioni.gbcs.cli.impl.converters.OutputStreamConverter
 import net.woggioni.jwo.UncloseableOutputStream
 import picocli.CommandLine
+import java.io.BufferedWriter
 import java.io.OutputStream
 import java.io.OutputStreamWriter
-import java.io.PrintWriter
 
 
 @CommandLine.Command(
@@ -20,7 +20,7 @@ class PasswordHashCommand : GbcsCommand() {
         names = ["-o", "--output-file"],
         description = ["Write the output to a file instead of stdout"],
         converter = [OutputStreamConverter::class],
-        showDefaultValue = CommandLine.Help.Visibility.NEVER,
+        defaultValue = "stdout",
         paramLabel = "OUTPUT_FILE"
     )
     private var outputStream: OutputStream = UncloseableOutputStream(System.out)
@@ -30,8 +30,9 @@ class PasswordHashCommand : GbcsCommand() {
         val password2 = String(System.console().readPassword("Type your password again for confirmation:"))
         if(password1 != password2) throw IllegalArgumentException("Passwords do not match")
 
-        PrintWriter(OutputStreamWriter(outputStream, Charsets.UTF_8)).use {
+        BufferedWriter(OutputStreamWriter(outputStream, Charsets.UTF_8)).use {
-            it.println(hashPassword(password1))
+            it.write(hashPassword(password1))
+            it.newLine()
         }
     }
 }

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

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

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

@@ -1,67 +0,0 @@
-package net.woggioni.gbcs.cli.impl.commands
-
-import net.woggioni.gbcs.server.GradleBuildCacheServer
-import net.woggioni.gbcs.server.GradleBuildCacheServer.Companion.DEFAULT_CONFIGURATION_URL
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import net.woggioni.gbcs.common.info
-import net.woggioni.gbcs.cli.impl.GbcsCommand
-import net.woggioni.jwo.Application
-import net.woggioni.jwo.JWO
-import picocli.CommandLine
-import java.io.ByteArrayOutputStream
-import java.nio.file.Files
-import java.nio.file.Path
-
-@CommandLine.Command(
-    name = "server",
-    description = ["GBCS server"],
-    showDefaultValues = true
-)
-class ServerCommand(app : Application) : GbcsCommand() {
-
-    private val log = contextLogger()
-
-    private fun createDefaultConfigurationFile(configurationFile: Path) {
-        log.info {
-            "Creating default configuration file at '$configurationFile'"
-        }
-        val defaultConfigurationFileResource = DEFAULT_CONFIGURATION_URL
-        Files.newOutputStream(configurationFile).use { outputStream ->
-            defaultConfigurationFileResource.openStream().use { inputStream ->
-                JWO.copy(inputStream, outputStream)
-            }
-        }
-    }
-
-    @CommandLine.Option(
-        names = ["-c", "--config-file"],
-        description = ["Read the application configuration from this file"],
-        paramLabel = "CONFIG_FILE"
-    )
-    private var configurationFile: Path = findConfigurationFile(app, "gbcs-server.xml")
-
-    val configuration : Configuration by lazy {
-        GradleBuildCacheServer.loadConfiguration(configurationFile)
-    }
-
-    override fun run() {
-        if (!Files.exists(configurationFile)) {
-            Files.createDirectories(configurationFile.parent)
-            createDefaultConfigurationFile(configurationFile)
-        }
-
-        val configuration = GradleBuildCacheServer.loadConfiguration(configurationFile)
-        log.debug {
-            ByteArrayOutputStream().also {
-                GradleBuildCacheServer.dumpConfiguration(configuration, it)
-            }.let {
-                "Server configuration:\n${String(it.toByteArray())}"
-            }
-        }
-        val server = GradleBuildCacheServer(configuration)
-        server.run().use {
-        }
-    }
-}

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

@@ -1,13 +0,0 @@
-package net.woggioni.gbcs.cli.impl.converters
-
-import picocli.CommandLine
-import java.io.InputStream
-import java.nio.file.Files
-import java.nio.file.Paths
-
-
-class InputStreamConverter : CommandLine.ITypeConverter<InputStream> {
-    override fun convert(value: String): InputStream {
-        return Files.newInputStream(Paths.get(value))
-    }
-}

gbcs-cli/src/main/resources/net/woggioni/gbcs/cli/logback.xml

@@ -12,9 +12,10 @@
         </encoder>
     </appender>
 
-    <root level="info">
+    <root level="debug">
         <appender-ref ref="console"/>
     </root>
+    <logger name="io.netty" level="debug"/>
     <logger name="com.google.code.yanf4j" level="warn"/>
     <logger name="net.rubyeye.xmemcached" level="warn"/>
 </configuration>

gbcs-client/build.gradle

@@ -1,15 +0,0 @@
-plugins {
-    id 'java-library'
-    alias catalog.plugins.kotlin.jvm
-}
-
-dependencies {
-    implementation project(':gbcs-api')
-    implementation project(':gbcs-common')
-    implementation catalog.picocli
-    implementation catalog.slf4j.api
-    implementation catalog.netty.buffer
-    implementation catalog.netty.codec.http
-}
-
-

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

@@ -1,17 +0,0 @@
-module net.woggioni.gbcs.client {
-    requires io.netty.handler;
-    requires io.netty.codec.http;
-    requires io.netty.transport;
-    requires kotlin.stdlib;
-    requires io.netty.common;
-    requires io.netty.buffer;
-    requires java.xml;
-    requires net.woggioni.gbcs.common;
-    requires net.woggioni.gbcs.api;
-    requires io.netty.codec;
-    requires org.slf4j;
-
-    exports net.woggioni.gbcs.client;
-
-    opens net.woggioni.gbcs.client.schema;
-}

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

@@ -1,271 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.bootstrap.Bootstrap
-import io.netty.buffer.ByteBuf
-import io.netty.buffer.Unpooled
-import io.netty.channel.Channel
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelOption
-import io.netty.channel.ChannelPipeline
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.pool.AbstractChannelPoolHandler
-import io.netty.channel.pool.ChannelPool
-import io.netty.channel.pool.FixedChannelPool
-import io.netty.channel.socket.nio.NioSocketChannel
-import io.netty.handler.codec.DecoderException
-import io.netty.handler.codec.http.DefaultFullHttpRequest
-import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.FullHttpResponse
-import io.netty.handler.codec.http.HttpClientCodec
-import io.netty.handler.codec.http.HttpContentDecompressor
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpMethod
-import io.netty.handler.codec.http.HttpObjectAggregator
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpVersion
-import io.netty.handler.ssl.SslContext
-import io.netty.handler.ssl.SslContextBuilder
-import io.netty.handler.stream.ChunkedWriteHandler
-import io.netty.util.concurrent.Future
-import io.netty.util.concurrent.GenericFutureListener
-import net.woggioni.gbcs.client.impl.Parser
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.common.debug
-import net.woggioni.gbcs.common.trace
-import java.net.InetSocketAddress
-import java.net.URI
-import java.nio.file.Files
-import java.nio.file.Path
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-import java.time.Duration
-import java.util.Base64
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.atomic.AtomicInteger
-import io.netty.util.concurrent.Future as NettyFuture
-
-
-class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
-    private val group: NioEventLoopGroup
-    private var sslContext: SslContext
-    private val log = contextLogger()
-    private val pool: ChannelPool
-
-    data class Configuration(
-        val profiles: Map<String, Profile>
-    ) {
-        sealed class Authentication {
-            data class TlsClientAuthenticationCredentials(
-                val key: PrivateKey,
-                val certificateChain: Array<X509Certificate>
-            ) : Authentication()
-
-            data class BasicAuthenticationCredentials(val username: String, val password: String) : Authentication()
-        }
-
-        data class Profile(
-            val serverURI: URI,
-            val authentication: Authentication?,
-            val connectionTimeout : Duration?,
-            val maxConnections : Int
-        )
-
-        companion object {
-            fun parse(path: Path): Configuration {
-                return Files.newInputStream(path).use {
-                    Xml.parseXml(path.toUri().toURL(), it)
-                }.let(Parser::parse)
-            }
-        }
-    }
-
-    init {
-        group = NioEventLoopGroup()
-        sslContext = SslContextBuilder.forClient().also { builder ->
-            (profile.authentication as? Configuration.Authentication.TlsClientAuthenticationCredentials)?.let { tlsClientAuthenticationCredentials ->
-                builder.keyManager(
-                    tlsClientAuthenticationCredentials.key,
-                    *tlsClientAuthenticationCredentials.certificateChain
-                )
-            }
-        }.build()
-
-        val (scheme, host, port) = profile.serverURI.run {
-            Triple(
-                if (scheme == null) "http" else profile.serverURI.scheme,
-                host,
-                port.takeIf { it > 0 } ?: if ("https" == scheme.lowercase()) 443 else 80
-            )
-        }
-
-        val bootstrap = Bootstrap().apply {
-            group(group)
-            channel(NioSocketChannel::class.java)
-            option(ChannelOption.TCP_NODELAY, true)
-            option(ChannelOption.SO_KEEPALIVE, true)
-            remoteAddress(InetSocketAddress(host, port))
-            profile.connectionTimeout?.let {
-                option(ChannelOption.CONNECT_TIMEOUT_MILLIS, it.toMillis().toInt())
-            }
-        }
-        val channelPoolHandler = object : AbstractChannelPoolHandler() {
-
-            @Volatile
-            private var connectionCount = AtomicInteger()
-
-            @Volatile
-            private var leaseCount = AtomicInteger()
-
-            override fun channelReleased(ch: Channel) {
-                val activeLeases = leaseCount.decrementAndGet()
-                log.trace {
-                    "Released channel ${ch.id().asShortText()}, number of active leases: $activeLeases"
-                }
-            }
-
-            override fun channelAcquired(ch: Channel) {
-                val activeLeases = leaseCount.getAndIncrement()
-                log.trace {
-                    "Acquired channel ${ch.id().asShortText()}, number of active leases: $activeLeases"
-                }
-            }
-
-            override fun channelCreated(ch: Channel) {
-                val connectionId = connectionCount.getAndIncrement()
-                log.debug {
-                    "Created connection $connectionId, total number of active connections: $connectionId"
-                }
-                ch.closeFuture().addListener {
-                    val activeConnections = connectionCount.decrementAndGet()
-                    log.debug {
-                        "Closed connection $connectionId, total number of active connections: $activeConnections"
-                    }
-                }
-                val pipeline: ChannelPipeline = ch.pipeline()
-
-                // Add SSL handler if needed
-                if ("https".equals(scheme, ignoreCase = true)) {
-                    pipeline.addLast("ssl", sslContext.newHandler(ch.alloc(), host, port))
-                }
-
-                // HTTP handlers
-                pipeline.addLast("codec", HttpClientCodec())
-                pipeline.addLast("decompressor", HttpContentDecompressor())
-                pipeline.addLast("aggregator", HttpObjectAggregator(1048576))
-                pipeline.addLast("chunked", ChunkedWriteHandler())
-            }
-        }
-        pool = FixedChannelPool(bootstrap, channelPoolHandler, profile.maxConnections)
-    }
-
-    fun get(key: String): CompletableFuture<ByteArray?> {
-        return sendRequest(profile.serverURI.resolve(key), HttpMethod.GET, null)
-            .thenApply {
-                val status = it.status()
-                if (it.status() == HttpResponseStatus.NOT_FOUND) {
-                    null
-                } else if (it.status() != HttpResponseStatus.OK) {
-                    throw HttpException(status)
-                } else {
-                    it.content()
-                }
-            }.thenApply { maybeByteBuf ->
-                maybeByteBuf?.let {
-                    val result = ByteArray(it.readableBytes())
-                    it.getBytes(0, result)
-                    result
-                }
-            }
-    }
-
-    fun put(key: String, content: ByteArray): CompletableFuture<Unit> {
-        return sendRequest(profile.serverURI.resolve(key), HttpMethod.PUT, content).thenApply {
-            val status = it.status()
-            if (it.status() != HttpResponseStatus.CREATED) {
-                throw HttpException(status)
-            }
-        }
-    }
-
-    private fun sendRequest(uri: URI, method: HttpMethod, body: ByteArray?): CompletableFuture<FullHttpResponse> {
-        val responseFuture = CompletableFuture<FullHttpResponse>()
-        // Custom handler for processing responses
-        pool.acquire().addListener(object : GenericFutureListener<NettyFuture<Channel>> {
-            override fun operationComplete(channelFuture: Future<Channel>) {
-                if (channelFuture.isSuccess) {
-                    val channel = channelFuture.now
-                    val pipeline = channel.pipeline()
-                    channel.pipeline().addLast("handler", object : SimpleChannelInboundHandler<FullHttpResponse>() {
-                        override fun channelRead0(
-                            ctx: ChannelHandlerContext,
-                            response: FullHttpResponse
-                        ) {
-                            responseFuture.complete(response)
-                            pipeline.removeLast()
-                            pool.release(channel)
-                        }
-
-                        override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
-                            val ex = when (cause) {
-                                is DecoderException -> cause.cause
-                                else -> cause
-                            }
-                            responseFuture.completeExceptionally(ex)
-                            ctx.close()
-                            pipeline.removeLast()
-                            pool.release(channel)
-                            super.exceptionCaught(ctx, cause)
-                        }
-                    })
-                    // Prepare the HTTP request
-                    val request: FullHttpRequest = let {
-                        val content: ByteBuf? = body?.takeIf(ByteArray::isNotEmpty)?.let(Unpooled::wrappedBuffer)
-                        DefaultFullHttpRequest(
-                            HttpVersion.HTTP_1_1,
-                            method,
-                            uri.rawPath,
-                            content ?: Unpooled.buffer(0)
-                        ).apply {
-                            headers().apply {
-                                if (content != null) {
-                                    set(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_OCTET_STREAM)
-                                    set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes())
-                                }
-                                set(HttpHeaderNames.HOST, profile.serverURI.host)
-                                set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                                set(
-                                    HttpHeaderNames.ACCEPT_ENCODING,
-                                    HttpHeaderValues.GZIP.toString() + "," + HttpHeaderValues.DEFLATE.toString()
-                                )
-                                // Add basic auth if configured
-                                (profile.authentication as? Configuration.Authentication.BasicAuthenticationCredentials)?.let { credentials ->
-                                    val auth = "${credentials.username}:${credentials.password}"
-                                    val encodedAuth = Base64.getEncoder().encodeToString(auth.toByteArray())
-                                    set(HttpHeaderNames.AUTHORIZATION, "Basic $encodedAuth")
-                                }
-                            }
-                        }
-                    }
-
-                    // Set headers
-                    // Send the request
-                    channel.writeAndFlush(request)
-                } else {
-                    responseFuture.completeExceptionally(channelFuture.cause())
-                }
-            }
-        })
-        return responseFuture
-    }
-
-    fun shutDown(): NettyFuture<*> {
-        return group.shutdownGracefully()
-    }
-
-    override fun close() {
-        shutDown().sync()
-    }
-}

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

@@ -1,9 +0,0 @@
-package net.woggioni.gbcs.client
-
-import io.netty.handler.codec.http.HttpResponseStatus
-
-class HttpException(private val status : HttpResponseStatus) : RuntimeException(status.reasonPhrase()) {
-
-    override val message: String
-        get() = "Http status ${status.code()}: ${status.reasonPhrase()}"
-}

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

@@ -1,72 +0,0 @@
-package net.woggioni.gbcs.client.impl
-
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import net.woggioni.gbcs.client.GbcsClient
-import org.w3c.dom.Document
-import java.net.URI
-import java.nio.file.Files
-import java.nio.file.Path
-import java.security.KeyStore
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-import java.time.Duration
-
-object Parser {
-
-    fun parse(document: Document): GbcsClient.Configuration {
-        val root = document.documentElement
-
-        val profiles = mutableMapOf<String, GbcsClient.Configuration.Profile>()
-
-        for (child in root.asIterable()) {
-            val tagName = child.localName
-            when (tagName) {
-                "profile" -> {
-                    val name = child.renderAttribute("name") ?: throw ConfigurationException("name attribute is required")
-                    val uri = child.renderAttribute("base-url")?.let(::URI) ?: throw ConfigurationException("base-url attribute is required")
-                    var authentication: GbcsClient.Configuration.Authentication? = null
-                    for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
-                            "tls-client-auth" -> {
-                                val keyStoreFile = gchild.renderAttribute("key-store-file")
-                                val keyStorePassword =
-                                    gchild.renderAttribute("key-store-password")
-                                val keyAlias = gchild.renderAttribute("key-alias")
-                                val keyPassword = gchild.renderAttribute("key-password")
-
-                                val keystore = KeyStore.getInstance("PKCS12").apply {
-                                    Files.newInputStream(Path.of(keyStoreFile)).use {
-                                        load(it, keyStorePassword?.toCharArray())
-                                    }
-                                }
-                                val key = keystore.getKey(keyAlias, keyPassword?.toCharArray()) as PrivateKey
-                                val certChain = keystore.getCertificateChain(keyAlias).asSequence()
-                                    .map { it as X509Certificate }
-                                    .toList()
-                                    .toTypedArray()
-                                authentication =
-                                    GbcsClient.Configuration.Authentication.TlsClientAuthenticationCredentials(key, certChain)
-                            }
-
-                            "basic-auth" -> {
-                                val username = gchild.renderAttribute("user") ?: throw ConfigurationException("username attribute is required")
-                                val password = gchild.renderAttribute("password") ?: throw ConfigurationException("password attribute is required")
-                                authentication =
-                                    GbcsClient.Configuration.Authentication.BasicAuthenticationCredentials(username, password)
-                            }
-                        }
-                    }
-                    val maxConnections = child.renderAttribute("max-connections")
-                        ?.let(String::toInt)
-                        ?: 50
-                    val connectionTimeout = child.renderAttribute("connection-timeout")
-                        ?.let(Duration::parse)
-                    profiles[name] = GbcsClient.Configuration.Profile(uri, authentication, connectionTimeout, maxConnections)
-                }
-            }
-        }
-        return GbcsClient.Configuration(profiles)
-    }
-}

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

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

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

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

gbcs-memcached/build.gradle

@@ -1,3 +1,6 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
     id 'java-library'
     id 'maven-publish'
@@ -29,7 +32,7 @@ configurations {
 }
 
 dependencies {
-    compileOnly project(':gbcs-common')
+    compileOnly project(':gbcs-base')
     compileOnly project(':gbcs-api')
     compileOnly catalog.jwo
     implementation catalog.xmemcached

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

@@ -0,0 +1,14 @@
+import net.woggioni.gbcs.api.CacheProvider;
+
+module net.woggioni.gbcs.memcached {
+    requires net.woggioni.gbcs.base;
+    requires net.woggioni.gbcs.api;
+    requires com.googlecode.xmemcached;
+    requires net.woggioni.jwo;
+    requires java.xml;
+    requires kotlin.stdlib;
+
+    provides CacheProvider with net.woggioni.gbcs.memcached.MemcachedCacheProvider;
+
+    opens net.woggioni.gbcs.memcached.schema;
+}

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

@@ -1,12 +1,13 @@
-package net.woggioni.gbcs.server.memcached
+package net.woggioni.gbcs.memcached
 
+import net.rubyeye.xmemcached.MemcachedClient
 import net.rubyeye.xmemcached.XMemcachedClientBuilder
 import net.rubyeye.xmemcached.command.BinaryCommandFactory
 import net.rubyeye.xmemcached.transcoders.CompressionMode
 import net.rubyeye.xmemcached.transcoders.SerializingTranscoder
 import net.woggioni.gbcs.api.Cache
 import net.woggioni.gbcs.api.exception.ContentTooLargeException
-import net.woggioni.gbcs.common.HostAndPort
+import net.woggioni.gbcs.base.HostAndPort
 import net.woggioni.jwo.JWO
 import java.io.ByteArrayInputStream
 import java.net.InetSocketAddress

gbcs-memcached/src/main/kotlin/net/woggioni/gbcs/memcached/MemcachedCacheConfiguration.kt

@@ -1,8 +1,8 @@
-package net.woggioni.gbcs.server.memcached
+package net.woggioni.gbcs.memcached
 
 import net.rubyeye.xmemcached.transcoders.CompressionMode
 import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.HostAndPort
+import net.woggioni.gbcs.base.HostAndPort
 import java.time.Duration
 
 data class MemcachedCacheConfiguration(
@@ -20,7 +20,7 @@ data class MemcachedCacheConfiguration(
         compressionMode
     )
 
-    override fun getNamespaceURI() = "urn:net.woggioni.gbcs.server.memcached"
+    override fun getNamespaceURI() = "urn:net.woggioni.gbcs-memcached"
 
     override fun getTypeName() = "memcachedCacheType"
 }

gbcs-memcached/src/main/kotlin/net/woggioni/gbcs/memcached/MemcachedCacheProvider.kt

@@ -0,0 +1,85 @@
+package net.woggioni.gbcs.memcached
+
+import net.rubyeye.xmemcached.transcoders.CompressionMode
+import net.woggioni.gbcs.api.CacheProvider
+import net.woggioni.gbcs.base.GBCS
+import net.woggioni.gbcs.base.HostAndPort
+import net.woggioni.gbcs.base.Xml
+import net.woggioni.gbcs.base.Xml.Companion.asIterable
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import java.time.Duration
+import java.util.zip.Deflater
+
+class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
+    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd"
+
+    override fun getXmlType() = "memcachedCacheType"
+
+    override fun getXmlNamespace()= "urn:net.woggioni.gbcs-memcached"
+
+    override fun deserialize(el: Element): MemcachedCacheConfiguration {
+        val servers = mutableListOf<HostAndPort>()
+        val maxAge = el.getAttribute("max-age")
+            .takeIf(String::isNotEmpty)
+            ?.let(Duration::parse)
+            ?: Duration.ofDays(1)
+        val maxSize = el.getAttribute("max-size")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toInt)
+            ?: 0x100000
+        val enableCompression = el.getAttribute("enable-compression")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toBoolean)
+            ?: false
+        val compressionMode = el.getAttribute("compression-mode")
+            .takeIf(String::isNotEmpty)
+            ?.let {
+                when(it) {
+                    "gzip" -> CompressionMode.GZIP
+                    "zip" -> CompressionMode.ZIP
+                    else -> CompressionMode.ZIP
+                }
+            }
+            ?: CompressionMode.ZIP
+        val digestAlgorithm = el.getAttribute("digest").takeIf(String::isNotEmpty)
+        for (child in el.asIterable()) {
+            when (child.nodeName) {
+                "server" -> {
+                    servers.add(HostAndPort(child.getAttribute("host"), child.getAttribute("port").toInt()))
+                }
+            }
+        }
+
+        return MemcachedCacheConfiguration(
+            servers,
+            maxAge,
+            maxSize,
+            digestAlgorithm,
+            compressionMode,
+        )
+    }
+
+    override fun serialize(doc: Document, cache : MemcachedCacheConfiguration) = cache.run {
+        val result = doc.createElementNS(xmlNamespace,"cache")
+        Xml.of(doc, result) {
+            attr("xs:type", xmlType, GBCS.XML_SCHEMA_NAMESPACE_URI)
+            for (server in servers) {
+                node("server", xmlNamespace) {
+                    attr("host", server.host)
+                    attr("port", server.port.toString())
+                }
+            }
+            attr("max-age", maxAge.toString())
+            attr("max-size", maxSize.toString())
+            digestAlgorithm?.let { digestAlgorithm ->
+                attr("digest", digestAlgorithm)
+            }
+            attr("compression-mode", when(compressionMode) {
+                CompressionMode.GZIP -> "gzip"
+                CompressionMode.ZIP -> "zip"
+            })
+        }
+        result
+    }
+}

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

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

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

@@ -1,13 +1,13 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xs:schema targetNamespace="urn:net.woggioni.gbcs.server.memcached"
+<xs:schema targetNamespace="urn:net.woggioni.gbcs-memcached"
-           xmlns:gbcs-memcached="urn:net.woggioni.gbcs.server.memcached"
+           xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
-           xmlns:gbcs="urn:net.woggioni.gbcs.server"
+           xmlns:gbcs="urn:net.woggioni.gbcs"
            xmlns:xs="http://www.w3.org/2001/XMLSchema">
 
-    <xs:import schemaLocation="jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd" namespace="urn:net.woggioni.gbcs.server"/>
+    <xs:import schemaLocation="classpath:net/woggioni/gbcs/schema/gbcs.xsd" namespace="urn:net.woggioni.gbcs"/>
 
     <xs:complexType name="memcachedServerType">
-        <xs:attribute name="host" type="xs:token" use="required"/>
+        <xs:attribute name="host" type="xs:string" use="required"/>
         <xs:attribute name="port" type="xs:positiveInteger" use="required"/>
     </xs:complexType>
 
@@ -20,14 +20,14 @@
                 <xs:attribute name="max-age" type="xs:duration" default="P1D"/>
                 <xs:attribute name="max-size" type="xs:unsignedInt" default="1048576"/>
                 <xs:attribute name="digest" type="xs:token" />
-                <xs:attribute name="compression-mode" type="gbcs-memcached:compressionType" default="zip"/>
+                <xs:attribute name="compression-type" type="gbcs-memcached:compressionType" default="deflate"/>
             </xs:extension>
         </xs:complexContent>
     </xs:complexType>
 
     <xs:simpleType name="compressionType">
         <xs:restriction base="xs:token">
-            <xs:enumeration value="zip"/>
+            <xs:enumeration value="deflate"/>
             <xs:enumeration value="gzip"/>
         </xs:restriction>
     </xs:simpleType>

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

@@ -1,14 +0,0 @@
-import net.woggioni.gbcs.api.CacheProvider;
-
-module net.woggioni.gbcs.server.memcached {
-    requires net.woggioni.gbcs.common;
-    requires net.woggioni.gbcs.api;
-    requires com.googlecode.xmemcached;
-    requires net.woggioni.jwo;
-    requires java.xml;
-    requires kotlin.stdlib;
-
-    provides CacheProvider with net.woggioni.gbcs.server.memcached.MemcachedCacheProvider;
-
-    opens net.woggioni.gbcs.server.memcached.schema;
-}

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

@@ -1,88 +0,0 @@
-package net.woggioni.gbcs.server.memcached
-
-import net.rubyeye.xmemcached.transcoders.CompressionMode
-import net.woggioni.gbcs.api.CacheProvider
-import net.woggioni.gbcs.api.exception.ConfigurationException
-import net.woggioni.gbcs.common.GBCS
-import net.woggioni.gbcs.common.HostAndPort
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
-import org.w3c.dom.Document
-import org.w3c.dom.Element
-import java.time.Duration
-
-class MemcachedCacheProvider : CacheProvider<MemcachedCacheConfiguration> {
-    override fun getXmlSchemaLocation() = "jpms://net.woggioni.gbcs.server.memcached/net/woggioni/gbcs/server/memcached/schema/gbcs-memcached.xsd"
-
-    override fun getXmlType() = "memcachedCacheType"
-
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server.memcached"
-
-    val xmlNamespacePrefix : String
-        get() = "gbcs-memcached"
-
-    override fun deserialize(el: Element): MemcachedCacheConfiguration {
-        val servers = mutableListOf<HostAndPort>()
-        val maxAge = el.renderAttribute("max-age")
-            ?.let(Duration::parse)
-            ?: Duration.ofDays(1)
-        val maxSize = el.renderAttribute("max-size")
-            ?.let(String::toInt)
-            ?: 0x100000
-        val compressionMode = el.renderAttribute("compression-mode")
-            ?.let {
-                when (it) {
-                    "gzip" -> CompressionMode.GZIP
-                    "zip" -> CompressionMode.ZIP
-                    else -> CompressionMode.ZIP
-                }
-            }
-            ?: CompressionMode.ZIP
-        val digestAlgorithm = el.renderAttribute("digest")
-        for (child in el.asIterable()) {
-            when (child.nodeName) {
-                "server" -> {
-                    val host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
-                    val port = child.renderAttribute("port")?.toInt() ?: throw ConfigurationException("port attribute is required")
-                    servers.add(HostAndPort(host, port))
-                }
-            }
-        }
-
-        return MemcachedCacheConfiguration(
-            servers,
-            maxAge,
-            maxSize,
-            digestAlgorithm,
-            compressionMode,
-        )
-    }
-
-    override fun serialize(doc: Document, cache: MemcachedCacheConfiguration) = cache.run {
-        val result = doc.createElement("cache")
-        Xml.of(doc, result) {
-            attr("xmlns:${xmlNamespacePrefix}", xmlNamespace, namespaceURI = "http://www.w3.org/2000/xmlns/")
-
-            attr("xs:type", "${xmlNamespacePrefix}:$xmlType", GBCS.XML_SCHEMA_NAMESPACE_URI)
-            for (server in servers) {
-                node("server") {
-                    attr("host", server.host)
-                    attr("port", server.port.toString())
-                }
-            }
-            attr("max-age", maxAge.toString())
-            attr("max-size", maxSize.toString())
-            digestAlgorithm?.let { digestAlgorithm ->
-                attr("digest", digestAlgorithm)
-            }
-            attr(
-                "compression-mode", when (compressionMode) {
-                    CompressionMode.GZIP -> "gzip"
-                    CompressionMode.ZIP -> "zip"
-                }
-            )
-        }
-        result
-    }
-}

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

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

gbcs-server/build.gradle

@@ -1,36 +0,0 @@
-plugins {
-    id 'java-library'
-    alias catalog.plugins.kotlin.jvm
-    id 'jacoco'
-    id 'maven-publish'
-}
-
-dependencies {
-    implementation catalog.jwo
-    implementation catalog.slf4j.api
-    implementation catalog.netty.codec.http
-
-    api project(':gbcs-common')
-    api project(':gbcs-api')
-
-//    runtimeOnly catalog.slf4j.jdk14
-    testRuntimeOnly catalog.logback.classic
-
-    testImplementation catalog.bcprov.jdk18on
-    testImplementation catalog.bcpkix.jdk18on
-    testImplementation catalog.junit.jupiter.api
-    testImplementation catalog.junit.jupiter.params
-    testRuntimeOnly catalog.junit.jupiter.engine
-
-    testRuntimeOnly project(":gbcs-server-memcached")
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from(components["java"])
-        }
-    }
-}
-
-

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

@@ -1,129 +0,0 @@
-package net.woggioni.gbcs.server.handler
-
-import io.netty.buffer.Unpooled
-import io.netty.channel.ChannelFutureListener
-import io.netty.channel.ChannelHandler
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.DefaultFileRegion
-import io.netty.channel.SimpleChannelInboundHandler
-import io.netty.handler.codec.http.DefaultFullHttpResponse
-import io.netty.handler.codec.http.DefaultHttpResponse
-import io.netty.handler.codec.http.FullHttpRequest
-import io.netty.handler.codec.http.HttpHeaderNames
-import io.netty.handler.codec.http.HttpHeaderValues
-import io.netty.handler.codec.http.HttpMethod
-import io.netty.handler.codec.http.HttpResponseStatus
-import io.netty.handler.codec.http.HttpUtil
-import io.netty.handler.codec.http.LastHttpContent
-import io.netty.handler.stream.ChunkedNioFile
-import io.netty.handler.stream.ChunkedNioStream
-import net.woggioni.gbcs.api.Cache
-import net.woggioni.gbcs.common.contextLogger
-import net.woggioni.gbcs.server.debug
-import net.woggioni.gbcs.server.warn
-import java.nio.channels.FileChannel
-import java.nio.file.Path
-
-@ChannelHandler.Sharable
-class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
-    SimpleChannelInboundHandler<FullHttpRequest>() {
-
-    private val log = contextLogger()
-
-    override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
-        val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
-        val method = msg.method()
-        if (method === HttpMethod.GET) {
-            val path = Path.of(msg.uri())
-            val prefix = path.parent
-            val key = path.fileName.toString()
-            if (serverPrefix == prefix) {
-                cache.get(key)?.let { channel ->
-                    log.debug(ctx) {
-                        "Cache hit for key '$key'"
-                    }
-                    val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
-                    response.headers()[HttpHeaderNames.CONTENT_TYPE] = HttpHeaderValues.APPLICATION_OCTET_STREAM
-                    if (!keepAlive) {
-                        response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
-                        response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
-                    } else {
-                        response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
-                        response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
-                    }
-                    ctx.write(response)
-                    when (channel) {
-                        is FileChannel -> {
-                            if (keepAlive) {
-                                ctx.write(ChunkedNioFile(channel))
-                                ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                            } else {
-                                ctx.writeAndFlush(DefaultFileRegion(channel, 0, channel.size()))
-                                    .addListener(ChannelFutureListener.CLOSE)
-                            }
-                        }
-
-                        else -> {
-                            ctx.write(ChunkedNioStream(channel))
-                            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                        }
-                    }
-                } ?: let {
-                    log.debug(ctx) {
-                        "Cache miss for key '$key'"
-                    }
-                    val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
-                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                    ctx.writeAndFlush(response)
-                }
-            } else {
-                log.warn(ctx) {
-                    "Got request for unhandled path '${msg.uri()}'"
-                }
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
-                ctx.writeAndFlush(response)
-            }
-        } else if (method === HttpMethod.PUT) {
-            val path = Path.of(msg.uri())
-            val prefix = path.parent
-            val key = path.fileName.toString()
-
-            if (serverPrefix == prefix) {
-                log.debug(ctx) {
-                    "Added value for key '$key' to build cache"
-                }
-                val bodyBytes = msg.content().run {
-                    if (isDirect) {
-                        ByteArray(readableBytes()).also {
-                            readBytes(it)
-                        }
-                    } else {
-                        array()
-                    }
-                }
-                cache.put(key, bodyBytes)
-                val response = DefaultFullHttpResponse(
-                    msg.protocolVersion(), HttpResponseStatus.CREATED,
-                    Unpooled.copiedBuffer(key.toByteArray())
-                )
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
-                ctx.writeAndFlush(response)
-            } else {
-                log.warn(ctx) {
-                    "Got request for unhandled path '${msg.uri()}'"
-                }
-                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-                ctx.writeAndFlush(response)
-            }
-        } else {
-            log.warn(ctx) {
-                "Got request with unhandled method '${msg.method().name()}'"
-            }
-            val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
-            response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
-            ctx.writeAndFlush(response)
-        }
-    }
-}

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

@@ -1 +0,0 @@
-net.woggioni.gbcs.server.cache.FileSystemCacheProvider

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

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server
-             xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="8080" incoming-connections-backlog-size="1024"/>
-    <connection
-            max-request-size="67108864"
-            idle-timeout="PT30S"
-            read-timeout="PT10S"
-            write-timeout="PT10S"
-            read-idle-timeout="PT60S"
-            write-idle-timeout="PT60S"/>
-    <event-executor use-virtual-threads="true"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

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

@@ -1,86 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.common.Xml
-import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
-import net.woggioni.gbcs.server.configuration.Serializer
-import net.woggioni.gbcs.server.test.utils.NetworkUtils
-import java.net.URI
-import java.net.http.HttpRequest
-import java.nio.charset.StandardCharsets
-import java.nio.file.Path
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-import java.util.Base64
-import java.util.zip.Deflater
-import kotlin.random.Random
-
-
-abstract class AbstractBasicAuthServerTest : AbstractServerTest() {
-
-    private lateinit var cacheDir : Path
-
-    protected val random = Random(101325)
-    protected val keyValuePair = newEntry(random)
-    protected val serverPath = "gbcs"
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
-
-    abstract protected val users : List<Configuration.User>
-
-    override fun setUp() {
-        this.cacheDir = testDir.resolve("cache")
-        cfg = Configuration.of(
-            "127.0.0.1",
-            NetworkUtils.getFreePort(),
-            50,
-            serverPath,
-            Configuration.EventExecutor(false),
-            Configuration.Connection(
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(60, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                0x1000
-            ),
-            users.asSequence().map { it.name to it}.toMap(),
-            sequenceOf(writersGroup, readersGroup).map { it.name to it}.toMap(),
-            FileSystemCacheConfiguration(this.cacheDir,
-                maxAge = Duration.ofSeconds(3600 * 24),
-                digestAlgorithm = "MD5",
-                compressionLevel = Deflater.DEFAULT_COMPRESSION,
-                compressionEnabled = false
-            ),
-            Configuration.BasicAuthentication(),
-            null,
-        )
-        Xml.write(Serializer.serialize(cfg), System.out)
-    }
-
-    override fun tearDown() {
-    }
-
-    protected fun buildAuthorizationHeader(user : Configuration.User, password : String) : String {
-        val b64 = Base64.getEncoder().encode("${user.name}:${password}".toByteArray(Charsets.UTF_8)).let{
-            String(it, StandardCharsets.UTF_8)
-        }
-        return "Basic $b64"
-    }
-
-    protected fun newRequestBuilder(key : String) = HttpRequest.newBuilder()
-        .uri(URI.create("http://${cfg.host}:${cfg.port}/$serverPath/$key"))
-
-
-    protected fun newEntry(random : Random) : Pair<String, ByteArray> {
-        val key = ByteArray(0x10).let {
-            random.nextBytes(it)
-            Base64.getUrlEncoder().encodeToString(it)
-        }
-        val value = ByteArray(0x1000).also {
-            random.nextBytes(it)
-        }
-        return key to value
-    }
-}

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

@@ -1,52 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-
-class NoAnonymousUserBasicAuthServerTest : AbstractBasicAuthServerTest() {
-
-    companion object {
-        private const val PASSWORD = "anotherPassword"
-    }
-
-    override val users = listOf(
-        Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup)),
-        Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup)),
-        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup)),
-    )
-
-    @Test
-    @Order(1)
-    fun putWithNoAuthorizationHeader() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun getWithNoAuthorizationHeader() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-}

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

@@ -1,47 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-class NoAnonymousUserTlsServerTest : AbstractTlsServerTest() {
-
-    override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup)),
-        Configuration.User("user2", null, setOf(writersGroup)),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup)),
-    )
-
-    @Test
-    @Order(1)
-    fun getAsAnonymousUser() {
-        val (key, _) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun putAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
-    }
-}

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

@@ -1,136 +0,0 @@
-package net.woggioni.gbcs.server.test
-
-import io.netty.handler.codec.http.HttpResponseStatus
-import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.api.Role
-import org.bouncycastle.asn1.x500.X500Name
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Order
-import org.junit.jupiter.api.Test
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-
-
-class TlsServerTest : AbstractTlsServerTest() {
-
-    override val users = listOf(
-        Configuration.User("user1", null, setOf(readersGroup)),
-        Configuration.User("user2", null, setOf(writersGroup)),
-        Configuration.User("user3", null, setOf(readersGroup, writersGroup)),
-        Configuration.User("", null, setOf(readersGroup))
-    )
-
-    @Test
-    @Order(1)
-    fun putAsAReaderUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles && Role.Writer !in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(2)
-    fun getAsAWriterUser() {
-        val (key, _) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Writer in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(3)
-    fun putAsAWriterUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Writer in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.CREATED.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(4)
-    fun getAsAReaderUser() {
-        val (key, value) = keyValuePair
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(5)
-    fun getMissingKeyAsAReaderUser() {
-        val (key, _) = newEntry(random)
-        val user = cfg.users.values.find {
-            Role.Reader in it.roles
-        } ?: throw RuntimeException("Reader user not found")
-        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> =
-            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
-    }
-
-    @Test
-    @Order(6)
-    fun getAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(7)
-    fun putAsAnonymousUser() {
-        val (key, value) = keyValuePair
-        val client: HttpClient = getHttpClient(null)
-
-        val requestBuilder = newRequestBuilder(key)
-            .header("Content-Type", "application/octet-stream")
-            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
-
-        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
-    }
-}

gbcs-server/src/test/resources/net/woggioni/gbcs/server/test/gbcs-default.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="22"/>
-    <connection
-            write-timeout="PT25M"
-            read-timeout="PT20M"
-            read-idle-timeout="PT10M"
-            write-idle-timeout="PT11M"
-            idle-timeout="PT30M"
-            max-request-size="101325"/>
-    <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authentication>
-        <none/>
-    </authentication>
-</gbcs:server>

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

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

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

@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<gbcs:server xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:gbcs="urn:net.woggioni.gbcs.server"
-             xs:schemaLocation="urn:net.woggioni.gbcs.server jpms://net.woggioni.gbcs.server/net/woggioni/gbcs/server/schema/gbcs.xsd">
-    <bind host="127.0.0.1" port="11443" incoming-connections-backlog-size="180"/>
-    <connection
-            write-timeout="PT25M"
-            read-timeout="PT20M"
-            read-idle-timeout="PT10M"
-            write-idle-timeout="PT11M"
-            idle-timeout="PT30M"
-            max-request-size="4096"/>
-    <event-executor use-virtual-threads="false"/>
-    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
-    <authorization>
-        <users>
-            <user name="user1" password="password1"/>
-            <user name="user2" password="password2"/>
-            <user name="user3" password="password3"/>
-        </users>
-        <groups>
-            <group name="readers">
-                <users>
-                    <user ref="user1"/>
-<!--                    <user ref="user5"/>-->
-                    <anonymous/>
-                </users>
-                <roles>
-                    <reader/>
-                </roles>
-            </group>
-            <group name="writers">
-                <users>
-                    <user ref="user2"/>
-                </users>
-                <roles>
-                    <writer/>
-                </roles>
-            </group>
-            <group name="readers-writers">
-                <users>
-                    <user ref="user3"/>
-                </users>
-                <roles>
-                    <reader/>
-                    <writer/>
-                </roles>
-            </group>
-        </groups>
-    </authorization>
-    <authentication>
-        <client-certificate>
-            <group-extractor pattern="group-pattern" attribute-name="O"/>
-            <user-extractor pattern="user-pattern" attribute-name="CN"/>
-        </client-certificate>
-    </authentication>
-    <tls>
-        <keystore file="keystore.pfx" key-alias="key1" password="password" key-password="key-password"/>
-        <truststore file="truststore.pfx" password="password" check-certificate-status="true" />
-    </tls>
-</gbcs:server>

gradle.properties

@@ -2,11 +2,9 @@ org.gradle.configuration-cache=false
 org.gradle.parallel=true
 org.gradle.caching=true
 
-gbcs.version = 0.0.8
+gbcs.version = 0.0.1
 
-lys.version = 2025.01.17
+lys.version = 2025.01.10
 
 gitea.maven.url = https://gitea.woggioni.net/api/packages/woggioni/maven
 docker.registry.url=gitea.woggioni.net
-
-jpms-check.configurationName = runtimeClasspath

settings.gradle

@@ -27,9 +27,9 @@ dependencyResolutionManagement {
 rootProject.name = 'gbcs'
 
 include 'gbcs-api'
-include 'gbcs-common'
+include 'gbcs-base'
-include 'gbcs-server-memcached'
+include 'gbcs-memcached'
 include 'gbcs-cli'
 include 'docker'
-include 'gbcs-client'
+
-include 'gbcs-server'
+

src/main/java/module-info.java

@@ -1,7 +1,7 @@
 import net.woggioni.gbcs.api.CacheProvider;
-import net.woggioni.gbcs.server.cache.FileSystemCacheProvider;
+import net.woggioni.gbcs.cache.FileSystemCacheProvider;
 
-module net.woggioni.gbcs.server {
+module net.woggioni.gbcs {
     requires java.sql;
     requires java.xml;
     requires java.logging;
@@ -15,13 +15,13 @@ module net.woggioni.gbcs.server {
     requires io.netty.codec;
     requires org.slf4j;
     requires net.woggioni.jwo;
-    requires net.woggioni.gbcs.common;
+    requires net.woggioni.gbcs.base;
     requires net.woggioni.gbcs.api;
 
-    exports net.woggioni.gbcs.server;
+    exports net.woggioni.gbcs;
 
-    opens net.woggioni.gbcs.server;
+    opens net.woggioni.gbcs;
-    opens net.woggioni.gbcs.server.schema;
+    opens net.woggioni.gbcs.schema;
 
     uses CacheProvider;
     provides CacheProvider with FileSystemCacheProvider;

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server
+package net.woggioni.gbcs
 
 import io.netty.bootstrap.ServerBootstrap
 import io.netty.buffer.ByteBuf
@@ -7,61 +7,61 @@ import io.netty.channel.Channel
 import io.netty.channel.ChannelDuplexHandler
 import io.netty.channel.ChannelFuture
 import io.netty.channel.ChannelFutureListener
-import io.netty.channel.ChannelHandler.Sharable
 import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
 import io.netty.channel.ChannelInitializer
 import io.netty.channel.ChannelOption
 import io.netty.channel.ChannelPromise
+import io.netty.channel.DefaultFileRegion
+import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.channel.nio.NioEventLoopGroup
 import io.netty.channel.socket.nio.NioServerSocketChannel
 import io.netty.handler.codec.DecoderException
 import io.netty.handler.codec.compression.CompressionOptions
 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.FullHttpRequest
 import io.netty.handler.codec.http.FullHttpResponse
 import io.netty.handler.codec.http.HttpContentCompressor
 import io.netty.handler.codec.http.HttpHeaderNames
+import io.netty.handler.codec.http.HttpHeaderValues
+import io.netty.handler.codec.http.HttpMethod
 import io.netty.handler.codec.http.HttpObjectAggregator
 import io.netty.handler.codec.http.HttpRequest
 import io.netty.handler.codec.http.HttpResponseStatus
 import io.netty.handler.codec.http.HttpServerCodec
+import io.netty.handler.codec.http.HttpUtil
 import io.netty.handler.codec.http.HttpVersion
+import io.netty.handler.codec.http.LastHttpContent
 import io.netty.handler.ssl.ClientAuth
 import io.netty.handler.ssl.SslContext
 import io.netty.handler.ssl.SslContextBuilder
-import io.netty.handler.ssl.SslHandler
+import io.netty.handler.stream.ChunkedNioFile
+import io.netty.handler.stream.ChunkedNioStream
 import io.netty.handler.stream.ChunkedWriteHandler
-import io.netty.handler.timeout.IdleStateEvent
-import io.netty.handler.timeout.IdleStateHandler
-import io.netty.handler.timeout.ReadTimeoutException
-import io.netty.handler.timeout.ReadTimeoutHandler
-import io.netty.handler.timeout.WriteTimeoutException
-import io.netty.handler.timeout.WriteTimeoutHandler
 import io.netty.util.concurrent.DefaultEventExecutorGroup
 import io.netty.util.concurrent.EventExecutorGroup
+import net.woggioni.gbcs.api.Cache
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.api.exception.ConfigurationException
 import net.woggioni.gbcs.api.exception.ContentTooLargeException
-import net.woggioni.gbcs.common.GBCS.toUrl
+import net.woggioni.gbcs.auth.AbstractNettyHttpAuthenticator
-import net.woggioni.gbcs.common.PasswordSecurity.decodePasswordHash
+import net.woggioni.gbcs.auth.Authorizer
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.auth.ClientCertificateValidator
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.auth.RoleAuthorizer
-import net.woggioni.gbcs.common.contextLogger
+import net.woggioni.gbcs.base.GBCS.toUrl
-import net.woggioni.gbcs.common.debug
+import net.woggioni.gbcs.base.PasswordSecurity.decodePasswordHash
-import net.woggioni.gbcs.common.info
+import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
-import net.woggioni.gbcs.server.auth.AbstractNettyHttpAuthenticator
+import net.woggioni.gbcs.base.Xml
-import net.woggioni.gbcs.server.auth.Authorizer
+import net.woggioni.gbcs.base.contextLogger
-import net.woggioni.gbcs.server.auth.ClientCertificateValidator
+import net.woggioni.gbcs.base.info
-import net.woggioni.gbcs.server.auth.RoleAuthorizer
+import net.woggioni.gbcs.configuration.Parser
-import net.woggioni.gbcs.server.configuration.Parser
+import net.woggioni.gbcs.configuration.Serializer
-import net.woggioni.gbcs.server.configuration.Serializer
-import net.woggioni.gbcs.server.handler.ServerHandler
 import net.woggioni.jwo.JWO
 import net.woggioni.jwo.Tuple2
 import java.io.OutputStream
 import java.net.InetSocketAddress
+import java.nio.channels.FileChannel
 import java.nio.file.Files
 import java.nio.file.Path
 import java.security.KeyStore
@@ -69,32 +69,14 @@ import java.security.PrivateKey
 import java.security.cert.X509Certificate
 import java.util.Arrays
 import java.util.Base64
-import java.util.concurrent.TimeUnit
 import java.util.regex.Matcher
 import java.util.regex.Pattern
 import javax.naming.ldap.LdapName
+import javax.net.ssl.SSLEngine
 import javax.net.ssl.SSLPeerUnverifiedException
 
 
 class GradleBuildCacheServer(private val cfg: Configuration) {
-    private val log = contextLogger()
-
-    companion object {
-
-        val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
-        private const val SSL_HANDLER_NAME = "sslHandler"
-
-        fun loadConfiguration(configurationFile: Path): Configuration {
-            val doc = Files.newInputStream(configurationFile).use {
-                Xml.parseXml(configurationFile.toUri().toURL(), it)
-            }
-            return Parser.parse(doc)
-        }
-
-        fun dumpConfiguration(conf: Configuration, outputStream: OutputStream) {
-            Xml.write(Serializer.serialize(conf), outputStream)
-        }
-    }
 
     private class HttpChunkContentCompressor(
         threshold: Int,
@@ -117,59 +99,61 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         }
     }
 
-    @Sharable
     private class ClientCertificateAuthenticator(
         authorizer: Authorizer,
-        private val anonymousUserRoles: Set<Role>?,
+        private val sslEngine: SSLEngine,
         private val userExtractor: Configuration.UserExtractor?,
         private val groupExtractor: Configuration.GroupExtractor?,
     ) : AbstractNettyHttpAuthenticator(authorizer) {
 
+        companion object {
+            private val log = contextLogger()
+        }
+
         override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): Set<Role>? {
             return try {
-                val sslHandler = (ctx.pipeline().get(SSL_HANDLER_NAME) as? SslHandler)
+                sslEngine.session.peerCertificates
-                    ?: throw ConfigurationException("Client certificate authentication cannot be used when TLS is disabled")
+            } catch (es: SSLPeerUnverifiedException) {
-                val sslEngine = sslHandler.engine()
+                null
-                sslEngine.session.peerCertificates.takeIf {
+            }?.takeIf {
                 it.isNotEmpty()
             }?.let { peerCertificates ->
                 val clientCertificate = peerCertificates.first() as X509Certificate
                 val user = userExtractor?.extract(clientCertificate)
                 val group = groupExtractor?.extract(clientCertificate)
                 (group?.roles ?: emptySet()) + (user?.roles ?: emptySet())
-                } ?: anonymousUserRoles
-            } catch (es: SSLPeerUnverifiedException) {
-                anonymousUserRoles
             }
         }
     }
 
-    @Sharable
     private class NettyHttpBasicAuthenticator(
         private val users: Map<String, Configuration.User>, authorizer: Authorizer
     ) : AbstractNettyHttpAuthenticator(authorizer) {
+
+        companion object {
             private val log = contextLogger()
+        }
 
         override fun authenticate(ctx: ChannelHandlerContext, req: HttpRequest): Set<Role>? {
             val authorizationHeader = req.headers()[HttpHeaderNames.AUTHORIZATION] ?: let {
                 log.debug(ctx) {
                     "Missing Authorization header"
                 }
-                return users[""]?.roles
+                return null
             }
             val cursor = authorizationHeader.indexOf(' ')
             if (cursor < 0) {
                 log.debug(ctx) {
                     "Invalid Authorization header: '$authorizationHeader'"
                 }
-                return users[""]?.roles
+                return null
             }
             val authenticationType = authorizationHeader.substring(0, cursor)
             if ("Basic" != authenticationType) {
                 log.debug(ctx) {
                     "Invalid authentication type header: '$authenticationType'"
                 }
-                return users[""]?.roles
+                return null
             }
             val (username, password) = Base64.getDecoder().decode(authorizationHeader.substring(cursor + 1))
                 .let(::String)
@@ -206,7 +190,7 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                 } else {
                     val javaKeyStore = loadKeystore(keyStore.file, keyStore.password)
                     val serverKey = javaKeyStore.getKey(
-                        keyStore.keyAlias, (keyStore.keyPassword ?: "").let(String::toCharArray)
+                        keyStore.keyAlias, keyStore.keyPassword?.let(String::toCharArray)
                     ) as PrivateKey
                     val serverCert: Array<X509Certificate> =
                         Arrays.stream(javaKeyStore.getCertificateChain(keyStore.keyAlias))
@@ -215,7 +199,8 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                     SslContextBuilder.forServer(serverKey, *serverCert).apply {
                         if (tls.isVerifyClients) {
                             clientAuth(ClientAuth.OPTIONAL)
-                            tls.trustStore?.let { trustStore ->
+                            val trustStore = tls.trustStore
+                            if (trustStore != null) {
                                 val ts = loadKeystore(trustStore.file, trustStore.password)
                                 trustManager(
                                     ClientCertificateValidator.getTrustManager(ts, trustStore.isCheckCertificateStatus)
@@ -248,30 +233,6 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
         }
 
-        private val log = contextLogger()
-
-        private val serverHandler = let {
-            val cacheImplementation = cfg.cache.materialize()
-            val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
-            ServerHandler(cacheImplementation, prefix)
-        }
-
-        private val exceptionHandler = ExceptionHandler()
-
-        private val authenticator = when (val auth = cfg.authentication) {
-            is Configuration.BasicAuthentication -> NettyHttpBasicAuthenticator(cfg.users, RoleAuthorizer())
-            is Configuration.ClientCertificateAuthentication -> {
-                ClientCertificateAuthenticator(
-                    RoleAuthorizer(),
-                    cfg.users[""]?.roles,
-                    userExtractor(auth),
-                    groupExtractor(auth)
-                )
-            }
-
-            else -> null
-        }
-
         private val sslContext: SslContext? = cfg.tls?.let(Companion::createSslCtx)
 
         private fun userExtractor(authentication: Configuration.ClientCertificateAuthentication) =
@@ -303,46 +264,41 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             }
 
         override fun initChannel(ch: Channel) {
-            log.debug {
-                "Created connection ${ch.id().asShortText()}"
-            }
-            ch.closeFuture().addListener {
-                log.debug {
-                    "Closed connection ${ch.id().asShortText()}"
-                }
-            }
             val pipeline = ch.pipeline()
-            cfg.connection.apply {
+            val auth = cfg.authentication
-                pipeline.addLast(ReadTimeoutHandler(readTimeout.toMillis(), TimeUnit.MILLISECONDS))
+            var authenticator: AbstractNettyHttpAuthenticator? = null
-                pipeline.addLast(WriteTimeoutHandler(writeTimeout.toMillis(), TimeUnit.MILLISECONDS))
+            if (auth is Configuration.BasicAuthentication) {
-                pipeline.addLast(IdleStateHandler(false, 0, 0, idleTimeout.toMillis(), TimeUnit.MILLISECONDS))
+                val roleAuthorizer = RoleAuthorizer()
+                authenticator = (NettyHttpBasicAuthenticator(cfg.users, roleAuthorizer))
             }
-            pipeline.addLast(object : ChannelInboundHandlerAdapter() {
+            if (sslContext != null) {
-                override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
+                val sslHandler = sslContext.newHandler(ch.alloc())
-                    if (evt is IdleStateEvent) {
+                pipeline.addLast(sslHandler)
-                        log.debug {
+
-                            "Idle timeout reached on channel ${ch.id().asShortText()}, closing the connection"
+                if (auth is Configuration.ClientCertificateAuthentication) {
+                    val roleAuthorizer = RoleAuthorizer()
+                    authenticator = ClientCertificateAuthenticator(
+                        roleAuthorizer,
+                        sslHandler.engine(),
+                        userExtractor(auth),
+                        groupExtractor(auth)
+                    )
                 }
-                        ctx.close()
-                    }
-                }
-            })
-            sslContext?.newHandler(ch.alloc())?.also {
-                pipeline.addLast(SSL_HANDLER_NAME, it)
             }
             pipeline.addLast(HttpServerCodec())
             pipeline.addLast(HttpChunkContentCompressor(1024))
             pipeline.addLast(ChunkedWriteHandler())
-            pipeline.addLast(HttpObjectAggregator(cfg.connection.maxRequestSize))
+            pipeline.addLast(HttpObjectAggregator(Int.MAX_VALUE))
             authenticator?.let {
                 pipeline.addLast(it)
             }
-            pipeline.addLast(eventExecutorGroup, serverHandler)
+            val cacheImplementation = cfg.cache.materialize()
-            pipeline.addLast(exceptionHandler)
+            val prefix = Path.of("/").resolve(Path.of(cfg.serverPath ?: "/"))
+            pipeline.addLast(eventExecutorGroup, ServerHandler(cacheImplementation, prefix))
+            pipeline.addLast(ExceptionHandler())
         }
     }
 
-    @Sharable
     private class ExceptionHandler : ChannelDuplexHandler() {
         private val log = contextLogger()
 
@@ -374,20 +330,7 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
                     ctx.writeAndFlush(TOO_BIG.retainedDuplicate())
                         .addListener(ChannelFutureListener.CLOSE_ON_FAILURE)
                 }
-                is ReadTimeoutException -> {
+
-                    log.debug {
-                        val channelId = ctx.channel().id().asShortText()
-                        "Read timeout on channel $channelId, closing the connection"
-                    }
-                    ctx.close()
-                }
-                is WriteTimeoutException -> {
-                    log.debug {
-                        val channelId = ctx.channel().id().asShortText()
-                        "Write timeout on channel $channelId, closing the connection"
-                    }
-                    ctx.close()
-                }
                 else -> {
                     log.error(cause.message, cause)
                     ctx.close()
@@ -396,13 +339,118 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         }
     }
 
+    private class ServerHandler(private val cache: Cache, private val serverPrefix: Path) :
+        SimpleChannelInboundHandler<FullHttpRequest>() {
+
+        companion object {
+            private val log = contextLogger()
+        }
+
+        override fun channelRead0(ctx: ChannelHandlerContext, msg: FullHttpRequest) {
+            val keepAlive: Boolean = HttpUtil.isKeepAlive(msg)
+            val method = msg.method()
+            if (method === HttpMethod.GET) {
+                val path = Path.of(msg.uri())
+                val prefix = path.parent
+                val key = path.fileName.toString()
+                if (serverPrefix == prefix) {
+                    cache.get(key)?.let { channel ->
+                        log.debug(ctx) {
+                            "Cache hit for key '$key'"
+                        }
+                        val response = DefaultHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK)
+                        response.headers()[HttpHeaderNames.CONTENT_TYPE] = HttpHeaderValues.APPLICATION_OCTET_STREAM
+                        if (!keepAlive) {
+                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.IDENTITY)
+                        } else {
+                            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE)
+                            response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED)
+                        }
+                        ctx.write(response)
+                        when (channel) {
+                            is FileChannel -> {
+                                if (keepAlive) {
+                                    ctx.write(ChunkedNioFile(channel))
+                                    ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
+                                } else {
+                                    ctx.writeAndFlush(DefaultFileRegion(channel, 0, channel.size()))
+                                        .addListener(ChannelFutureListener.CLOSE)
+                                }
+                            }
+
+                            else -> {
+                                ctx.write(ChunkedNioStream(channel))
+                                ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
+                            }
+                        }
+                    } ?: let {
+                        log.debug(ctx) {
+                            "Cache miss for key '$key'"
+                        }
+                        val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.NOT_FOUND)
+                        response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
+                        ctx.writeAndFlush(response)
+                    }
+                } else {
+                    log.warn(ctx) {
+                        "Got request for unhandled path '${msg.uri()}'"
+                    }
+                    val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
+                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = 0
+                    ctx.writeAndFlush(response)
+                }
+            } else if (method === HttpMethod.PUT) {
+                val path = Path.of(msg.uri())
+                val prefix = path.parent
+                val key = path.fileName.toString()
+
+                if (serverPrefix == prefix) {
+                    log.debug(ctx) {
+                        "Added value for key '$key' to build cache"
+                    }
+                    val bodyBytes = msg.content().run {
+                        if (isDirect) {
+                            ByteArray(readableBytes()).also {
+                                readBytes(it)
+                            }
+                        } else {
+                            array()
+                        }
+                    }
+                    cache.put(key, bodyBytes)
+                    val response = DefaultFullHttpResponse(
+                        msg.protocolVersion(), HttpResponseStatus.CREATED,
+                        Unpooled.copiedBuffer(key.toByteArray())
+                    )
+                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = response.content().readableBytes()
+                    ctx.writeAndFlush(response)
+                } else {
+                    log.warn(ctx) {
+                        "Got request for unhandled path '${msg.uri()}'"
+                    }
+                    val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
+                    response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
+                    ctx.writeAndFlush(response)
+                }
+            } else {
+                log.warn(ctx) {
+                    "Got request with unhandled method '${msg.method().name()}'"
+                }
+                val response = DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.BAD_REQUEST)
+                response.headers()[HttpHeaderNames.CONTENT_LENGTH] = "0"
+                ctx.writeAndFlush(response)
+            }
+        }
+    }
+
     class ServerHandle(
         httpChannelFuture: ChannelFuture,
         private val executorGroups : Iterable<EventExecutorGroup>
     ) : AutoCloseable {
         private val httpChannel: Channel = httpChannelFuture.channel()
+
         private val closeFuture: ChannelFuture = httpChannel.closeFuture()
-        private val log = contextLogger()
 
         fun shutdown(): ChannelFuture {
             return httpChannel.close()
@@ -428,7 +476,7 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         val serverSocketChannel = NioServerSocketChannel::class.java
         val workerGroup = bossGroup
         val eventExecutorGroup = run {
-            val threadFactory = if (cfg.eventExecutor.isUseVirtualThreads) {
+            val threadFactory = if(cfg.isUseVirtualThread) {
                 Thread.ofVirtual().factory()
             } else {
                 null
@@ -441,7 +489,7 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
             group(bossGroup, workerGroup)
             channel(serverSocketChannel)
             childHandler(ServerInitializer(cfg, eventExecutorGroup))
-            option(ChannelOption.SO_BACKLOG, cfg.incomingConnectionsBacklogSize)
+            option(ChannelOption.SO_BACKLOG, 128)
             childOption(ChannelOption.SO_KEEPALIVE, true)
         }
 
@@ -454,4 +502,22 @@ class GradleBuildCacheServer(private val cfg: Configuration) {
         }
         return ServerHandle(httpChannel, setOf(bossGroup, workerGroup, eventExecutorGroup))
     }
+
+    companion object {
+
+        val DEFAULT_CONFIGURATION_URL by lazy { "classpath:net/woggioni/gbcs/gbcs-default.xml".toUrl() }
+
+        fun loadConfiguration(configurationFile: Path): Configuration {
+            val dbf = Xml.newDocumentBuilderFactory(null)
+            val db = dbf.newDocumentBuilder()
+            val doc = Files.newInputStream(configurationFile).use(db::parse)
+            return Parser.parse(doc)
+        }
+
+        fun dumpConfiguration(conf: Configuration, outputStream: OutputStream) {
+            Xml.write(Serializer.serialize(conf), outputStream)
+        }
+
+        private val log = contextLogger()
+    }
 }

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server
+package net.woggioni.gbcs
 
 import io.netty.channel.ChannelHandlerContext
 import org.slf4j.Logger

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.auth
+package net.woggioni.gbcs.auth
 
 import io.netty.buffer.Unpooled
 import io.netty.channel.ChannelFutureListener

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.auth
+package net.woggioni.gbcs.auth
 
 import io.netty.handler.codec.http.HttpRequest
 import net.woggioni.gbcs.api.Role

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

@@ -1,18 +1,16 @@
-package net.woggioni.gbcs.server.auth
+package net.woggioni.gbcs.auth
 
-import io.netty.channel.ChannelHandlerContext
-import io.netty.channel.ChannelInboundHandlerAdapter
-import io.netty.handler.ssl.SslHandler
-import io.netty.handler.ssl.SslHandshakeCompletionEvent
 import java.security.KeyStore
 import java.security.cert.CertPathValidator
-import java.security.cert.CertPathValidatorException
-import java.security.cert.CertificateException
 import java.security.cert.CertificateFactory
 import java.security.cert.PKIXParameters
 import java.security.cert.PKIXRevocationChecker
 import java.security.cert.X509Certificate
 import java.util.EnumSet
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.ChannelInboundHandlerAdapter
+import io.netty.handler.ssl.SslHandler
+import io.netty.handler.ssl.SslHandshakeCompletionEvent
 import javax.net.ssl.SSLSession
 import javax.net.ssl.TrustManagerFactory
 import javax.net.ssl.X509TrustManager
@@ -20,8 +18,7 @@ import javax.net.ssl.X509TrustManager
 
 class ClientCertificateValidator private constructor(
     private val sslHandler : SslHandler,
-    private val x509TrustManager: X509TrustManager
+    private val x509TrustManager: X509TrustManager) : ChannelInboundHandlerAdapter() {
-) : ChannelInboundHandlerAdapter() {
     override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
         if (evt is SslHandshakeCompletionEvent) {
             if (evt.isSuccess) {
@@ -43,8 +40,7 @@ class ClientCertificateValidator private constructor(
                 val validator = CertPathValidator.getInstance("PKIX").apply {
                     val rc = revocationChecker as PKIXRevocationChecker
                     rc.options = EnumSet.of(
-                        PKIXRevocationChecker.Option.NO_FALLBACK
+                        PKIXRevocationChecker.Option.NO_FALLBACK)
-                    )
                 }
                 val params = PKIXParameters(trustStore).apply {
                     isRevocationEnabled = certificateRevocationEnabled
@@ -52,11 +48,7 @@ class ClientCertificateValidator private constructor(
                 object : X509TrustManager {
                     override fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String) {
                         val clientCertificateChain = certificateFactory.generateCertPath(chain.toList())
-                        try {
                         validator.validate(clientCertificateChain, params)
-                        } catch (ex: CertPathValidatorException) {
-                            throw CertificateException(ex)
-                        }
                     }
 
                     override fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String) {
@@ -74,16 +66,11 @@ class ClientCertificateValidator private constructor(
                 }
             } else {
                 val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
-                trustManagerFactory.trustManagers.asSequence().filter { it is X509TrustManager }
+                trustManagerFactory.trustManagers.asSequence().filter { it is X509TrustManager }.single() as X509TrustManager
-                    .single() as X509TrustManager
             }
         }
 
-        fun of(
+        fun of(sslHandler : SslHandler, trustStore : KeyStore?, certificateRevocationEnabled : Boolean) : ClientCertificateValidator {
-            sslHandler: SslHandler,
-            trustStore: KeyStore?,
-            certificateRevocationEnabled: Boolean
-        ): ClientCertificateValidator {
             return ClientCertificateValidator(sslHandler, getTrustManager(trustStore, certificateRevocationEnabled))
         }
     }

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.auth
+package net.woggioni.gbcs.auth
 
 import io.netty.handler.codec.http.HttpMethod
 import io.netty.handler.codec.http.HttpRequest

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.cache
+package net.woggioni.gbcs.cache
 
 import net.woggioni.gbcs.api.Cache
 import net.woggioni.jwo.JWO

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

@@ -1,7 +1,7 @@
-package net.woggioni.gbcs.server.cache
+package net.woggioni.gbcs.cache
 
 import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.GBCS
+import net.woggioni.gbcs.base.GBCS
 import net.woggioni.jwo.Application
 import java.nio.file.Path
 import java.time.Duration

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

@@ -1,9 +1,8 @@
-package net.woggioni.gbcs.server.cache
+package net.woggioni.gbcs.cache
 
 import net.woggioni.gbcs.api.CacheProvider
-import net.woggioni.gbcs.common.GBCS
+import net.woggioni.gbcs.base.GBCS
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.base.Xml
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 import java.nio.file.Path
@@ -12,25 +11,29 @@ import java.util.zip.Deflater
 
 class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
 
-    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/server/schema/gbcs.xsd"
+    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/schema/gbcs.xsd"
 
     override fun getXmlType() = "fileSystemCacheType"
 
-    override fun getXmlNamespace() = "urn:net.woggioni.gbcs.server"
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs"
 
     override fun deserialize(el: Element): FileSystemCacheConfiguration {
-        val path = el.renderAttribute("path")
+        val path = el.getAttribute("path")
+            .takeIf(String::isNotEmpty)
             ?.let(Path::of)
-        val maxAge = el.renderAttribute("max-age")
+        val maxAge = el.getAttribute("max-age")
+            .takeIf(String::isNotEmpty)
             ?.let(Duration::parse)
             ?: Duration.ofDays(1)
-        val enableCompression = el.renderAttribute("enable-compression")
+        val enableCompression = el.getAttribute("enable-compression")
+            .takeIf(String::isNotEmpty)
             ?.let(String::toBoolean)
             ?: true
-        val compressionLevel = el.renderAttribute("compression-level")
+        val compressionLevel = el.getAttribute("compression-level")
+            .takeIf(String::isNotEmpty)
             ?.let(String::toInt)
             ?: Deflater.DEFAULT_COMPRESSION
-        val digestAlgorithm = el.renderAttribute("digest") ?: "MD5"
+        val digestAlgorithm = el.getAttribute("digest").takeIf(String::isNotEmpty) ?: "MD5"
 
         return FileSystemCacheConfiguration(
             path,

src/main/kotlin/net/woggioni/gbcs/configuration/CacheSerializers.kt

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.configuration
+package net.woggioni.gbcs.configuration
 
 import net.woggioni.gbcs.api.CacheProvider
 import net.woggioni.gbcs.api.Configuration

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

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.configuration
+package net.woggioni.gbcs.configuration
 
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.api.Configuration.Authentication
@@ -12,81 +12,39 @@ import net.woggioni.gbcs.api.Configuration.TlsCertificateExtractor
 import net.woggioni.gbcs.api.Configuration.TrustStore
 import net.woggioni.gbcs.api.Configuration.User
 import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.api.exception.ConfigurationException
+import net.woggioni.gbcs.base.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.asIterable
-import net.woggioni.gbcs.common.Xml.Companion.renderAttribute
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 import org.w3c.dom.TypeInfo
+import java.lang.IllegalArgumentException
 import java.nio.file.Paths
-import java.time.Duration
-import java.time.temporal.ChronoUnit
 
 object Parser {
+
     fun parse(document: Document): Configuration {
         val root = document.documentElement
-        val anonymousUser = User("", null, emptySet())
-        var connection: Configuration.Connection = Configuration.Connection(
-            Duration.of(10, ChronoUnit.SECONDS),
-            Duration.of(10, ChronoUnit.SECONDS),
-            Duration.of(60, ChronoUnit.SECONDS),
-            Duration.of(30, ChronoUnit.SECONDS),
-            Duration.of(30, ChronoUnit.SECONDS),
-            67108864
-        )
-        var eventExecutor: Configuration.EventExecutor = Configuration.EventExecutor(true)
         var cache: Cache? = null
         var host = "127.0.0.1"
         var port = 11080
-        var users : Map<String, User> = mapOf(anonymousUser.name to anonymousUser)
+        var users = emptyMap<String, User>()
         var groups = emptyMap<String, Group>()
         var tls: Tls? = null
-        val serverPath = root.renderAttribute("path")
+        val serverPath = root.getAttribute("path")
-        var incomingConnectionsBacklogSize = 1024
+        val useVirtualThread = root.getAttribute("useVirtualThreads")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toBoolean) ?: true
         var authentication: Authentication? = null
         for (child in root.asIterable()) {
-            val tagName = child.localName
+            when (child.localName) {
-            when (tagName) {
-                "authentication" -> {
-                    for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
-                            "basic" -> {
-                                authentication = BasicAuthentication()
-                            }
-
-                            "client-certificate" -> {
-                                var tlsExtractorUser: TlsCertificateExtractor? = null
-                                var tlsExtractorGroup: TlsCertificateExtractor? = null
-                                for (ggchild in gchild.asIterable()) {
-                                    when (ggchild.localName) {
-                                        "group-extractor" -> {
-                                            val attrName = ggchild.renderAttribute("attribute-name")
-                                            val pattern = ggchild.renderAttribute("pattern")
-                                            tlsExtractorGroup = TlsCertificateExtractor(attrName, pattern)
-                                        }
-
-                                        "user-extractor" -> {
-                                            val attrName = ggchild.renderAttribute("attribute-name")
-                                            val pattern = ggchild.renderAttribute("pattern")
-                                            tlsExtractorUser = TlsCertificateExtractor(attrName, pattern)
-                                        }
-                                    }
-                                }
-                                authentication = ClientCertificateAuthentication(tlsExtractorUser, tlsExtractorGroup)
-                            }
-                        }
-                    }
-                }
-
                 "authorization" -> {
-                    var knownUsers = sequenceOf(anonymousUser)
                     for (gchild in child.asIterable()) {
-                        when (gchild.localName) {
+                        when (child.localName) {
                             "users" -> {
-                                knownUsers += parseUsers(gchild)
+                                users = parseUsers(child)
                             }
+
                             "groups" -> {
-                                val pair = parseGroups(gchild, knownUsers)
+                                val pair = parseGroups(child, users)
                                 users = pair.first
                                 groups = pair.second
                             }
@@ -95,11 +53,8 @@ object Parser {
                 }
 
                 "bind" -> {
-                    host = child.renderAttribute("host") ?: throw ConfigurationException("host attribute is required")
+                    host = child.getAttribute("host")
-                    port = Integer.parseInt(child.renderAttribute("port"))
+                    port = Integer.parseInt(child.getAttribute("port"))
-                    incomingConnectionsBacklogSize = child.renderAttribute("incoming-connections-backlog-size")
-                        ?.let(Integer::parseInt)
-                        ?: 1024
                 }
 
                 "cache" -> {
@@ -111,45 +66,52 @@ object Parser {
                     }.deserialize(child)
                 }
 
-                "connection" -> {
+                "authentication" -> {
-                    val writeTimeout = child.renderAttribute("write-timeout")
+                    for (gchild in child.asIterable()) {
-                        ?.let(Duration::parse) ?: Duration.of(10, ChronoUnit.SECONDS)
+                        when (gchild.localName) {
-                    val readTimeout = child.renderAttribute("read-timeout")
+                            "basic" -> {
-                        ?.let(Duration::parse) ?: Duration.of(10, ChronoUnit.SECONDS)
+                                authentication = BasicAuthentication()
-                    val idleTimeout = child.renderAttribute("idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS)
-                    val readIdleTimeout = child.renderAttribute("read-idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                    val writeIdleTimeout = child.renderAttribute("write-idle-timeout")
-                        ?.let(Duration::parse) ?: Duration.of(60, ChronoUnit.SECONDS)
-                    val maxRequestSize = child.renderAttribute("max-request-size")
-                        ?.let(String::toInt) ?: 67108864
-                    connection = Configuration.Connection(
-                        readTimeout,
-                        writeTimeout,
-                        idleTimeout,
-                        readIdleTimeout,
-                        writeIdleTimeout,
-                        maxRequestSize
-                    )
                             }
-                "event-executor" -> {
+
-                    val useVirtualThread = root.renderAttribute("use-virtual-threads")
+                            "client-certificate" -> {
-                        ?.let(String::toBoolean) ?: true
+                                var tlsExtractorUser: TlsCertificateExtractor? = null
-                    eventExecutor = Configuration.EventExecutor(useVirtualThread)
+                                var tlsExtractorGroup: TlsCertificateExtractor? = null
+                                for (gchild in child.asIterable()) {
+                                    when (gchild.localName) {
+                                        "group-extractor" -> {
+                                            val attrName = gchild.getAttribute("attribute-name")
+                                            val pattern = gchild.getAttribute("pattern")
+                                            tlsExtractorGroup = TlsCertificateExtractor(attrName, pattern)
                                         }
+
+                                        "user-extractor" -> {
+                                            val attrName = gchild.getAttribute("attribute-name")
+                                            val pattern = gchild.getAttribute("pattern")
+                                            tlsExtractorUser = TlsCertificateExtractor(attrName, pattern)
+                                        }
+                                    }
+                                }
+                                authentication = ClientCertificateAuthentication(tlsExtractorUser, tlsExtractorGroup)
+                            }
+                        }
+                    }
+                }
+
                 "tls" -> {
-                    val verifyClients = child.renderAttribute("verify-clients")
+                    val verifyClients = child.getAttribute("verify-clients")
+                        .takeIf(String::isNotEmpty)
                         ?.let(String::toBoolean) ?: false
                     var keyStore: KeyStore? = null
                     var trustStore: TrustStore? = null
                     for (granChild in child.asIterable()) {
                         when (granChild.localName) {
                             "keystore" -> {
-                                val keyStoreFile = Paths.get(granChild.renderAttribute("file"))
+                                val keyStoreFile = Paths.get(granChild.getAttribute("file"))
-                                val keyStorePassword = granChild.renderAttribute("password")
+                                val keyStorePassword = granChild.getAttribute("password")
-                                val keyAlias = granChild.renderAttribute("key-alias")
+                                    .takeIf(String::isNotEmpty)
-                                val keyPassword = granChild.renderAttribute("key-password")
+                                val keyAlias = granChild.getAttribute("key-alias")
+                                val keyPassword = granChild.getAttribute("key-password")
+                                    .takeIf(String::isNotEmpty)
                                 keyStore = KeyStore(
                                     keyStoreFile,
                                     keyStorePassword,
@@ -159,9 +121,11 @@ object Parser {
                             }
 
                             "truststore" -> {
-                                val trustStoreFile = Paths.get(granChild.renderAttribute("file"))
+                                val trustStoreFile = Paths.get(granChild.getAttribute("file"))
-                                val trustStorePassword = granChild.renderAttribute("password")
+                                val trustStorePassword = granChild.getAttribute("password")
-                                val checkCertificateStatus = granChild.renderAttribute("check-certificate-status")
+                                    .takeIf(String::isNotEmpty)
+                                val checkCertificateStatus = granChild.getAttribute("check-certificate-status")
+                                    .takeIf(String::isNotEmpty)
                                     ?.let(String::toBoolean)
                                     ?: false
                                 trustStore = TrustStore(
@@ -176,19 +140,7 @@ object Parser {
                 }
             }
         }
-        return Configuration.of(
+        return Configuration(host, port, serverPath, users, groups, cache!!, authentication, tls, useVirtualThread)
-            host,
-            port,
-            incomingConnectionsBacklogSize,
-            serverPath,
-            eventExecutor,
-            connection,
-            users,
-            groups,
-            cache!!,
-            authentication,
-            tls,
-        )
     }
 
     private fun parseRoles(root: Element) = root.asIterable().asSequence().map {
@@ -199,36 +151,33 @@ object Parser {
         }
     }.toSet()
 
-    private fun parseUserRefs(root: Element) = root.asIterable().asSequence().map {
+    private fun parseUserRefs(root: Element) = root.asIterable().asSequence().filter {
-        when(it.localName) {
+        it.localName == "user"
-            "user" -> it.renderAttribute("ref")
+    }.map {
-            "anonymous" -> ""
+        it.getAttribute("ref")
-            else -> ConfigurationException("Unrecognized tag '${it.localName}'")
+    }.toSet()
-        }
-    }
 
-    private fun parseUsers(root: Element): Sequence<User> {
+    private fun parseUsers(root: Element): Map<String, User> {
         return root.asIterable().asSequence().filter {
             it.localName == "user"
         }.map { el ->
-            val username = el.renderAttribute("name")
+            val username = el.getAttribute("name")
-            val password = el.renderAttribute("password")
+            val password = el.getAttribute("password").takeIf(String::isNotEmpty)
-            User(username, password, emptySet())
+            username to User(username, password, emptySet())
-        }
+        }.toMap()
     }
 
-    private fun parseGroups(root: Element, knownUsers: Sequence<User>): Pair<Map<String, User>, Map<String, Group>> {
+    private fun parseGroups(root: Element, knownUsers: Map<String, User>): Pair<Map<String, User>, Map<String, Group>> {
-        val knownUsersMap = knownUsers.associateBy(User::getName)
         val userGroups = mutableMapOf<String, MutableSet<String>>()
         val groups = root.asIterable().asSequence().filter {
             it.localName == "group"
         }.map { el ->
-            val groupName = el.renderAttribute("name") ?: throw ConfigurationException("Group name is required")
+            val groupName = el.getAttribute("name")
             var roles = emptySet<Role>()
             for (child in el.asIterable()) {
                 when (child.localName) {
                     "users" -> {
-                        parseUserRefs(child).mapNotNull(knownUsersMap::get).forEach { user ->
+                        parseUserRefs(child).mapNotNull(knownUsers::get).forEach { user ->
                             userGroups.computeIfAbsent(user.name) {
                                 mutableSetOf()
                             }.add(groupName)
@@ -242,7 +191,7 @@ object Parser {
             }
             groupName to Group(groupName, roles)
         }.toMap()
-        val users = knownUsersMap.map { (name, user) ->
+        val users = knownUsers.map { (name, user) ->
             name to User(name, user.password, userGroups[name]?.mapNotNull { groups[it] }?.toSet() ?: emptySet())
         }.toMap()
         return users to groups

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

@@ -1,9 +1,9 @@
-package net.woggioni.gbcs.server.configuration
+package net.woggioni.gbcs.configuration
 
 import net.woggioni.gbcs.api.CacheProvider
 import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.GBCS
+import net.woggioni.gbcs.base.GBCS
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.base.Xml
 import org.w3c.dom.Document
 
 object Serializer {
@@ -14,6 +14,7 @@ object Serializer {
             it.xmlNamespace to it.xmlSchemaLocation
         }.toMap()
         return Xml.of(GBCS.GBCS_NAMESPACE_URI, GBCS.GBCS_PREFIX + ":server") {
+            attr("useVirtualThreads", conf.isUseVirtualThread.toString())
 //            attr("xmlns:xs", GradleBuildCacheServer.XML_SCHEMA_NAMESPACE_URI)
             val value = schemaLocations.asSequence().map { (k, v) -> "$k $v" }.joinToString(" ")
             attr("xs:schemaLocation",value , namespaceURI = GBCS.XML_SCHEMA_NAMESPACE_URI)
@@ -26,20 +27,6 @@ object Serializer {
             node("bind") {
                 attr("host", conf.host)
                 attr("port", conf.port.toString())
-                attr("incoming-connections-backlog-size", conf.incomingConnectionsBacklogSize.toString())
-            }
-            node("connection") {
-                conf.connection.let { connection ->
-                    attr("read-timeout", connection.readTimeout.toString())
-                    attr("write-timeout", connection.writeTimeout.toString())
-                    attr("idle-timeout", connection.idleTimeout.toString())
-                    attr("read-idle-timeout", connection.readIdleTimeout.toString())
-                    attr("write-idle-timeout", connection.writeIdleTimeout.toString())
-                    attr("max-request-size", connection.maxRequestSize.toString())
-                }
-            }
-            node("event-executor") {
-                attr("use-virtual-threads", conf.eventExecutor.isUseVirtualThreads.toString())
             }
             val cache = conf.cache
             val serializer : CacheProvider<Configuration.Cache> =
@@ -48,7 +35,6 @@ object Serializer {
             node("authorization") {
                 node("users") {
                     for(user in conf.users.values) {
-                        if(user.name.isNotEmpty()) {
                         node("user") {
                             attr("name", user.name)
                             user.password?.let { password ->
@@ -57,7 +43,6 @@ object Serializer {
                         }
                     }
                 }
-                }
                 node("groups") {
                     val groups = conf.users.values.asSequence()
                         .flatMap {
@@ -70,18 +55,10 @@ object Serializer {
                             attr("name", group.name)
                             if(users.isNotEmpty()) {
                                 node("users") {
-                                    var anonymousUser : Configuration.User? = null
                                     for(user in users) {
-                                        if(user.name.isNotEmpty()) {
                                         node("user") {
                                             attr("ref", user.name)
                                         }
-                                        } else {
-                                            anonymousUser = user
-                                        }
-                                    }
-                                    if(anonymousUser != null) {
-                                        node("anonymous")
                                     }
                                 }
                             }
@@ -105,12 +82,6 @@ object Serializer {
                         }
                         is Configuration.ClientCertificateAuthentication -> {
                             node("client-certificate") {
-                                authentication.groupExtractor?.let { extractor ->
-                                    node("group-extractor") {
-                                        attr("attribute-name", extractor.rdnType)
-                                        attr("pattern", extractor.pattern)
-                                    }
-                                }
                                 authentication.userExtractor?.let { extractor ->
                                     node("user-extractor") {
                                         attr("attribute-name", extractor.rdnType)

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

@@ -0,0 +1 @@
+net.woggioni.gbcs.cache.FileSystemCacheProvider

src/main/resources/net/woggioni/gbcs/gbcs-default.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+             xmlns:gbcs="urn:net.woggioni.gbcs"
+             xs:schemaLocation="urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
+    <bind host="127.0.0.1" port="8080"/>
+    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
+    <authentication>
+        <none/>
+    </authentication>
+</gbcs:server>

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

@@ -1,15 +1,14 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xs:schema targetNamespace="urn:net.woggioni.gbcs.server"
+<xs:schema targetNamespace="urn:net.woggioni.gbcs"
            xmlns:xs="http://www.w3.org/2001/XMLSchema"
-           xmlns:gbcs="urn:net.woggioni.gbcs.server"
+           xmlns:gbcs="urn:net.woggioni.gbcs"
-           elementFormDefault="unqualified">
+           elementFormDefault="unqualified"
+>
     <xs:element name="server" type="gbcs:serverType"/>
 
     <xs:complexType name="serverType">
         <xs:sequence minOccurs="0">
             <xs:element name="bind" type="gbcs:bindType" maxOccurs="1"/>
-            <xs:element name="connection" type="gbcs:connectionType" minOccurs="0" maxOccurs="1"/>
-            <xs:element name="event-executor" type="gbcs:eventExecutorType" minOccurs="0" maxOccurs="1"/>
             <xs:element name="cache" type="gbcs:cacheType" maxOccurs="1"/>
             <xs:element name="authorization" type="gbcs:authorizationType" minOccurs="0">
                 <xs:key name="userId">
@@ -22,28 +21,16 @@
                 </xs:keyref>
             </xs:element>
             <xs:element name="authentication" type="gbcs:authenticationType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="tls-certificate-authorization" type="gbcs:tlsCertificateAuthorizationType" minOccurs="0" maxOccurs="1"/>
             <xs:element name="tls" type="gbcs:tlsType" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
         <xs:attribute name="path" type="xs:string" use="optional"/>
+        <xs:attribute name="useVirtualThreads" type="xs:boolean" use="optional" default="true"/>
     </xs:complexType>
 
     <xs:complexType name="bindType">
-        <xs:attribute name="host" type="xs:token" use="required"/>
+        <xs:attribute name="host" type="xs:string" use="required"/>
         <xs:attribute name="port" type="xs:unsignedShort" use="required"/>
-        <xs:attribute name="incoming-connections-backlog-size" type="xs:unsignedInt" use="optional" default="1024"/>
-    </xs:complexType>
-
-    <xs:complexType name="connectionType">
-        <xs:attribute name="read-timeout" type="xs:duration" use="optional" default="PT10S"/>
-        <xs:attribute name="write-timeout" type="xs:duration" use="optional" default="PT10S"/>
-        <xs:attribute name="idle-timeout" type="xs:duration" use="optional" default="PT30S"/>
-        <xs:attribute name="read-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
-        <xs:attribute name="write-idle-timeout" type="xs:duration" use="optional" default="PT60S"/>
-        <xs:attribute name="max-request-size" type="xs:unsignedInt" use="optional" default="67108864"/>
-    </xs:complexType>
-
-    <xs:complexType name="eventExecutorType">
-        <xs:attribute name="use-virtual-threads" type="xs:boolean" use="optional" default="true"/>
     </xs:complexType>
 
     <xs:complexType name="cacheType" abstract="true"/>
@@ -62,14 +49,14 @@
 
     <xs:complexType name="tlsCertificateAuthorizationType">
         <xs:sequence>
-            <xs:element name="group-extractor" type="gbcs:X500NameExtractorType" minOccurs="0"/>
+            <xs:element name="group-extractor" type="gbcs:X500NameExtractorType"/>
-            <xs:element name="user-extractor" type="gbcs:X500NameExtractorType" minOccurs="0"/>
+            <xs:element name="user-extractor" type="gbcs:X500NameExtractorType"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="X500NameExtractorType">
-        <xs:attribute name="attribute-name" type="xs:token"/>
+        <xs:attribute name="attribute-name" type="xs:string"/>
-        <xs:attribute name="pattern" type="xs:token"/>
+        <xs:attribute name="pattern" type="xs:string"/>
     </xs:complexType>
 
     <xs:complexType name="authorizationType">
@@ -99,7 +86,7 @@
     </xs:complexType>
 
     <xs:complexType name="userType">
-        <xs:attribute name="name" type="xs:token" use="required"/>
+        <xs:attribute name="name" type="xs:string" use="required"/>
         <xs:attribute name="password" type="xs:string" use="optional"/>
     </xs:complexType>
 
@@ -119,11 +106,11 @@
             </xs:element>
             <xs:element name="roles" type="gbcs:rolesType" maxOccurs="1" minOccurs="0"/>
         </xs:sequence>
-        <xs:attribute name="name" type="xs:token"/>
+        <xs:attribute name="name" type="xs:string"/>
     </xs:complexType>
 
     <xs:simpleType name="role" final="restriction" >
-        <xs:restriction base="xs:token">
+        <xs:restriction base="xs:string">
             <xs:enumeration value="READER" />
             <xs:enumeration value="WRITER" />
         </xs:restriction>
@@ -141,7 +128,6 @@
     <xs:complexType name="userRefsType">
         <xs:sequence>
             <xs:element name="user" type="gbcs:userRefType" maxOccurs="unbounded" minOccurs="0"/>
-                <xs:element name="anonymous" minOccurs="0" maxOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 

src/test/java/net/woggioni/gbcs/utils/CertificateUtils.java

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.test.utils;
+package net.woggioni.gbcs.utils;
 
 import org.bouncycastle.asn1.DERSequence;
 import org.bouncycastle.asn1.x500.X500Name;

src/test/java/net/woggioni/gbcs/utils/NetworkUtils.java

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.test.utils;
+package net.woggioni.gbcs.utils;
 
 import net.woggioni.jwo.JWO;
 

src/test/kotlin/net/woggioni/gbcs/test/AbstractServerTest.kt

@@ -1,6 +1,6 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
-import net.woggioni.gbcs.server.GradleBuildCacheServer
+import net.woggioni.gbcs.GradleBuildCacheServer
 import net.woggioni.gbcs.api.Configuration
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll

src/test/kotlin/net/woggioni/gbcs/test/BasicAuthServerTest.kt

@@ -1,29 +1,93 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
 import io.netty.handler.codec.http.HttpResponseStatus
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.common.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.base.PasswordSecurity.hashPassword
+import net.woggioni.gbcs.base.Xml
+import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
+import net.woggioni.gbcs.configuration.Serializer
+import net.woggioni.gbcs.utils.NetworkUtils
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
+import java.io.IOException
+import java.net.ServerSocket
+import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
+import java.nio.charset.StandardCharsets
+import java.nio.file.Path
+import java.time.Duration
+import java.util.Base64
+import java.util.zip.Deflater
+import kotlin.random.Random
 
 
-class BasicAuthServerTest : AbstractBasicAuthServerTest() {
+class BasicAuthServerTest : AbstractServerTest() {
 
     companion object {
         private const val PASSWORD = "password"
     }
 
-    override val users = listOf(
+    private lateinit var cacheDir : Path
+
+    private val random = Random(101325)
+    private val keyValuePair = newEntry(random)
+    private val serverPath = "gbcs"
+
+    override fun setUp() {
+        this.cacheDir = testDir.resolve("cache")
+        val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
+        val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
+        cfg = Configuration(
+            "127.0.0.1",
+            NetworkUtils.getFreePort(),
+            serverPath,
+            listOf(
                 Configuration.User("user1", hashPassword(PASSWORD), setOf(readersGroup)),
                 Configuration.User("user2", hashPassword(PASSWORD), setOf(writersGroup)),
-        Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup)),
+                Configuration.User("user3", hashPassword(PASSWORD), setOf(readersGroup, writersGroup))
-        Configuration.User("", null, setOf(readersGroup))
+            ).asSequence().map { it.name to it}.toMap(),
+            sequenceOf(writersGroup, readersGroup).map { it.name to it}.toMap(),
+            FileSystemCacheConfiguration(this.cacheDir,
+                maxAge = Duration.ofSeconds(3600 * 24),
+                digestAlgorithm = "MD5",
+                compressionLevel = Deflater.DEFAULT_COMPRESSION,
+                compressionEnabled = false
+            ),
+            Configuration.BasicAuthentication(),
+            null,
+            true,
         )
+        Xml.write(Serializer.serialize(cfg), System.out)
+    }
+
+    override fun tearDown() {
+    }
+
+    fun buildAuthorizationHeader(user : Configuration.User, password : String) : String {
+        val b64 = Base64.getEncoder().encode("${user.name}:${password}".toByteArray(Charsets.UTF_8)).let{
+            String(it, StandardCharsets.UTF_8)
+        }
+        return "Basic $b64"
+    }
+
+    fun newRequestBuilder(key : String) = HttpRequest.newBuilder()
+        .uri(URI.create("http://${cfg.host}:${cfg.port}/$serverPath/$key"))
+
+
+    fun newEntry(random : Random) : Pair<String, ByteArray> {
+        val key = ByteArray(0x10).let {
+            random.nextBytes(it)
+            Base64.getUrlEncoder().encodeToString(it)
+        }
+        val value = ByteArray(0x1000).also {
+            random.nextBytes(it)
+        }
+        return key to value
+    }
 
     @Test
     @Order(1)
@@ -36,7 +100,7 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
             .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
 
         val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
-        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
+        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
     }
 
     @Test
@@ -115,20 +179,6 @@ class BasicAuthServerTest : AbstractBasicAuthServerTest() {
 
     @Test
     @Order(6)
-    fun getAsAnonymousUser() {
-        val client: HttpClient = HttpClient.newHttpClient()
-        val (key, value) = keyValuePair
-
-        val requestBuilder = newRequestBuilder(key)
-            .GET()
-
-        val response: HttpResponse<ByteArray> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
-        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
-        Assertions.assertArrayEquals(value, response.body())
-    }
-
-    @Test
-    @Order(7)
     fun getMissingKeyAsAReaderUser() {
         val client: HttpClient = HttpClient.newHttpClient()
 

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

@@ -1,10 +1,10 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
-import net.woggioni.gbcs.common.GBCS.toUrl
+import net.woggioni.gbcs.base.GbcsUrlStreamHandlerFactory
-import net.woggioni.gbcs.common.GbcsUrlStreamHandlerFactory
+import net.woggioni.gbcs.base.GBCS.toUrl
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.base.Xml
-import net.woggioni.gbcs.server.configuration.Parser
+import net.woggioni.gbcs.configuration.Parser
-import net.woggioni.gbcs.server.configuration.Serializer
+import net.woggioni.gbcs.configuration.Serializer
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.io.TempDir
 import org.junit.jupiter.params.ParameterizedTest
@@ -16,9 +16,8 @@ class ConfigurationTest {
 
     @ValueSource(
         strings = [
-            "classpath:net/woggioni/gbcs/server/test/gbcs-default.xml",
+            "classpath:net/woggioni/gbcs/test/gbcs-default.xml",
-            "classpath:net/woggioni/gbcs/server/test/gbcs-memcached.xml",
+            "classpath:net/woggioni/gbcs/test/gbcs-memcached.xml",
-            "classpath:net/woggioni/gbcs/server/test/gbcs-tls.xml",
         ]
     )
     @ParameterizedTest

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

@@ -1,21 +1,21 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
 import io.netty.handler.codec.http.HttpResponseStatus
+import net.woggioni.gbcs.base.Xml
 import net.woggioni.gbcs.api.Configuration
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
-import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
+import net.woggioni.gbcs.configuration.Serializer
-import net.woggioni.gbcs.server.configuration.Serializer
+import net.woggioni.gbcs.utils.NetworkUtils
-import net.woggioni.gbcs.server.test.utils.NetworkUtils
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
+import java.net.ServerSocket
 import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
 import java.nio.file.Path
 import java.time.Duration
-import java.time.temporal.ChronoUnit
 import java.util.Base64
 import java.util.zip.Deflater
 import kotlin.random.Random
@@ -34,17 +34,7 @@ class NoAuthServerTest : AbstractServerTest() {
         cfg = Configuration(
             "127.0.0.1",
             NetworkUtils.getFreePort(),
-            100,
             serverPath,
-            Configuration.EventExecutor(false),
-            Configuration.Connection(
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(60, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                0x1000
-            ),
             emptyMap(),
             emptyMap(),
             FileSystemCacheConfiguration(
@@ -56,6 +46,7 @@ class NoAuthServerTest : AbstractServerTest() {
             ),
             null,
             null,
+            true,
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }

src/test/kotlin/net/woggioni/gbcs/test/TlsServerTest.kt

@@ -1,24 +1,29 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
+import io.netty.handler.codec.http.HttpResponseStatus
 import net.woggioni.gbcs.api.Configuration
 import net.woggioni.gbcs.api.Role
-import net.woggioni.gbcs.common.Xml
+import net.woggioni.gbcs.base.Xml
-import net.woggioni.gbcs.server.cache.FileSystemCacheConfiguration
+import net.woggioni.gbcs.cache.FileSystemCacheConfiguration
-import net.woggioni.gbcs.server.configuration.Serializer
+import net.woggioni.gbcs.configuration.Serializer
-import net.woggioni.gbcs.server.test.utils.CertificateUtils
+import net.woggioni.gbcs.utils.CertificateUtils
-import net.woggioni.gbcs.server.test.utils.CertificateUtils.X509Credentials
+import net.woggioni.gbcs.utils.CertificateUtils.X509Credentials
-import net.woggioni.gbcs.server.test.utils.NetworkUtils
+import net.woggioni.gbcs.utils.NetworkUtils
 import org.bouncycastle.asn1.x500.X500Name
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Order
+import org.junit.jupiter.api.Test
+import java.net.ServerSocket
 import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
+import java.net.http.HttpResponse
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
 import java.nio.file.Path
 import java.security.KeyStore
 import java.security.KeyStore.PasswordProtection
 import java.time.Duration
-import java.time.temporal.ChronoUnit
 import java.util.Base64
 import java.util.zip.Deflater
 import javax.net.ssl.KeyManagerFactory
@@ -27,7 +32,7 @@ import javax.net.ssl.TrustManagerFactory
 import kotlin.random.Random
 
 
-abstract class AbstractTlsServerTest : AbstractServerTest() {
+class TlsServerTest : AbstractServerTest() {
 
     companion object {
         private const val CA_CERTIFICATE_ENTRY = "gbcs-ca"
@@ -43,17 +48,21 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
     private lateinit var serverKeyStore: KeyStore
     private lateinit var clientKeyStore: KeyStore
     private lateinit var trustStore: KeyStore
-    protected lateinit var ca: X509Credentials
+    private lateinit var ca: X509Credentials
 
-    protected val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
+    private val readersGroup = Configuration.Group("readers", setOf(Role.Reader))
-    protected val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
+    private val writersGroup = Configuration.Group("writers", setOf(Role.Writer))
-    protected val random = Random(101325)
+    private val random = Random(101325)
-    protected val keyValuePair = newEntry(random)
+    private val keyValuePair = newEntry(random)
     private val serverPath : String? = null
 
-    protected abstract val users : List<Configuration.User>
+    private val users = listOf(
+        Configuration.User("user1", null, setOf(readersGroup)),
+        Configuration.User("user2", null, setOf(writersGroup)),
+        Configuration.User("user3", null, setOf(readersGroup, writersGroup))
+    )
 
-    protected fun createKeyStoreAndTrustStore() {
+    fun createKeyStoreAndTrustStore() {
         ca = CertificateUtils.createCertificateAuthority(CA_CERTIFICATE_ENTRY, 30)
         val serverCert = CertificateUtils.createServerCertificate(ca, X500Name("CN=$SERVER_CERTIFICATE_ENTRY"), 30)
         val clientCert = CertificateUtils.createClientCertificate(ca, X500Name("CN=$CLIENT_CERTIFICATE_ENTRY"), 30)
@@ -99,7 +108,7 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
         }
     }
 
-    protected fun getClientKeyStore(ca: X509Credentials, subject: X500Name) = KeyStore.getInstance("PKCS12").apply {
+    fun getClientKeyStore(ca: X509Credentials, subject: X500Name) = KeyStore.getInstance("PKCS12").apply {
         val clientCert = CertificateUtils.createClientCertificate(ca, subject, 30)
 
         load(null, null)
@@ -111,7 +120,7 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
         )
     }
 
-    protected fun getHttpClient(clientKeyStore: KeyStore?): HttpClient {
+    fun getHttpClient(clientKeyStore: KeyStore?): HttpClient {
         val kmf = clientKeyStore?.let {
             KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()).apply {
                 init(it, PASSWORD.toCharArray())
@@ -139,17 +148,7 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
         cfg = Configuration(
             "127.0.0.1",
             NetworkUtils.getFreePort(),
-            100,
             serverPath,
-            Configuration.EventExecutor(false),
-            Configuration.Connection(
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(10, ChronoUnit.SECONDS),
-                Duration.of(60, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                Duration.of(30, ChronoUnit.SECONDS),
-                0x1000
-            ),
             users.asSequence().map { it.name to it }.toMap(),
             sequenceOf(writersGroup, readersGroup).map { it.name to it }.toMap(),
             FileSystemCacheConfiguration(this.cacheDir,
@@ -167,6 +166,7 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
                 Configuration.TrustStore(this.trustStoreFile, null, false),
                 true
             ),
+            false,
         )
         Xml.write(Serializer.serialize(cfg), System.out)
     }
@@ -174,17 +174,17 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
     override fun tearDown() {
     }
 
-    protected fun newRequestBuilder(key: String) = HttpRequest.newBuilder()
+    fun newRequestBuilder(key: String) = HttpRequest.newBuilder()
         .uri(URI.create("https://${cfg.host}:${cfg.port}/${serverPath ?: ""}/$key"))
 
-    private fun buildAuthorizationHeader(user: Configuration.User, password: String): String {
+    fun buildAuthorizationHeader(user: Configuration.User, password: String): String {
         val b64 = Base64.getEncoder().encode("${user.name}:${password}".toByteArray(Charsets.UTF_8)).let {
             String(it, StandardCharsets.UTF_8)
         }
         return "Basic $b64"
     }
 
-    protected fun newEntry(random: Random): Pair<String, ByteArray> {
+    fun newEntry(random: Random): Pair<String, ByteArray> {
         val key = ByteArray(0x10).let {
             random.nextBytes(it)
             Base64.getUrlEncoder().encodeToString(it)
@@ -194,4 +194,106 @@ abstract class AbstractTlsServerTest : AbstractServerTest() {
         }
         return key to value
     }
+
+    @Test
+    @Order(1)
+    fun putWithNoClientCertificate() {
+        val client: HttpClient = getHttpClient(null)
+        val (key, value) = keyValuePair
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Content-Type", "application/octet-stream")
+            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
+
+        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
+        Assertions.assertEquals(HttpResponseStatus.UNAUTHORIZED.code(), response.statusCode())
+    }
+
+    @Test
+    @Order(2)
+    fun putAsAReaderUser() {
+        val (key, value) = keyValuePair
+        val user = cfg.users.values.find {
+            Role.Reader in it.roles && Role.Writer !in it.roles
+        } ?: throw RuntimeException("Reader user not found")
+        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
+        val requestBuilder = newRequestBuilder(key)
+            .header("Content-Type", "application/octet-stream")
+            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
+
+        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
+        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
+    }
+
+    @Test
+    @Order(3)
+    fun getAsAWriterUser() {
+        val (key, _) = keyValuePair
+        val user = cfg.users.values.find {
+            Role.Writer in it.roles
+        } ?: throw RuntimeException("Reader user not found")
+        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .GET()
+
+        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
+        Assertions.assertEquals(HttpResponseStatus.FORBIDDEN.code(), response.statusCode())
+    }
+
+    @Test
+    @Order(4)
+    fun putAsAWriterUser() {
+        val (key, value) = keyValuePair
+        val user = cfg.users.values.find {
+            Role.Writer in it.roles
+        } ?: throw RuntimeException("Reader user not found")
+        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Content-Type", "application/octet-stream")
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .PUT(HttpRequest.BodyPublishers.ofByteArray(value))
+
+        val response: HttpResponse<String> = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
+        Assertions.assertEquals(HttpResponseStatus.CREATED.code(), response.statusCode())
+    }
+
+    @Test
+    @Order(5)
+    fun getAsAReaderUser() {
+        val (key, value) = keyValuePair
+        val user = cfg.users.values.find {
+            Role.Reader in it.roles
+        } ?: throw RuntimeException("Reader user not found")
+        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .GET()
+
+        val response: HttpResponse<ByteArray> =
+            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        Assertions.assertEquals(HttpResponseStatus.OK.code(), response.statusCode())
+        Assertions.assertArrayEquals(value, response.body())
+    }
+
+    @Test
+    @Order(6)
+    fun getMissingKeyAsAReaderUser() {
+        val (key, _) = newEntry(random)
+        val user = cfg.users.values.find {
+            Role.Reader in it.roles
+        } ?: throw RuntimeException("Reader user not found")
+        val client: HttpClient = getHttpClient(getClientKeyStore(ca, X500Name("CN=${user.name}")))
+
+        val requestBuilder = newRequestBuilder(key)
+            .header("Authorization", buildAuthorizationHeader(user, PASSWORD))
+            .GET()
+
+        val response: HttpResponse<ByteArray> =
+            client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray())
+        Assertions.assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode())
+    }
 }

src/test/kotlin/net/woggioni/gbcs/test/X500NameTest.kt

@@ -1,4 +1,4 @@
-package net.woggioni.gbcs.server.test
+package net.woggioni.gbcs.test
 
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test

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

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+             xmlns:gbcs="urn:net.woggioni.gbcs"
+             xs:schemaLocation="urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
+    <bind host="127.0.0.1" port="11443"/>
+    <cache xs:type="gbcs:fileSystemCacheType" path="/tmp/gbcs" max-age="P7D"/>
+    <authentication>
+        <none/>
+    </authentication>
+</gbcs:server>

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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<gbcs:server useVirtualThreads="false" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+             xmlns:gbcs="urn:net.woggioni.gbcs"
+             xmlns:gbcs-memcached="urn:net.woggioni.gbcs-memcached"
+             xs:schemaLocation="urn:net.woggioni.gbcs-memcached jpms://net.woggioni.gbcs.memcached/net/woggioni/gbcs/memcached/schema/gbcs-memcached.xsd urn:net.woggioni.gbcs jpms://net.woggioni.gbcs/net/woggioni/gbcs/schema/gbcs.xsd">
+    <bind host="127.0.0.1" port="11443" />
+    <cache xs:type="gbcs-memcached:memcachedCacheType" max-age="P7D" max-size="101325" compression-mode="gzip" digest="SHA-256">
+        <server host="127.0.0.1" port="11211"/>
+    </cache>
+    <authentication>
+        <none/>
+    </authentication>
+</gbcs:server>