added client command

gbcs-client/src/jmh/java/net/woggioni/gbcs/benchmark/Main.java

@@ -0,0 +1,262 @@
+package net.woggioni.gbcs.benchmark;
+
+import lombok.Getter;
+import lombok.SneakyThrows;
+import net.woggioni.jwo.Fun;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+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.util.Arrays;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+
+public class Main {
+
+    @SneakyThrows
+    private static Properties loadProperties() {
+        Properties properties = new Properties();
+        try (final var is = Main.class.getResourceAsStream("/benchmark.properties")) {
+            properties.load(is);
+        }
+        return properties;
+    }
+
+    private static final Properties properties = loadProperties();
+
+    @State(Scope.Thread)
+    public static class ExecutionPlan {
+        private final Random random = new Random(101325);
+
+        @Getter
+        private final HttpClient client = createHttpClient();
+
+        private final Map<String, byte[]> entries = new HashMap<>();
+
+
+        private HttpClient createHttpClient() {
+            final var clientBuilder = HttpClient.newBuilder();
+            getSslContext().ifPresent(clientBuilder::sslContext);
+            return clientBuilder.build();
+        }
+
+        public final Map<String, byte[]> getEntries() {
+            return Collections.unmodifiableMap(entries);
+        }
+
+        public Map.Entry<String, byte[]> newEntry() {
+            final var keyBuffer = new byte[0x20];
+            random.nextBytes(keyBuffer);
+            final var key = Base64.getUrlEncoder().encodeToString(keyBuffer);
+            final var value = new byte[0x1000];
+            random.nextBytes(value);
+            return Map.entry(key, value);
+        }
+
+        @SneakyThrows
+        public HttpRequest.Builder newRequestBuilder(String key) {
+            final var requestBuilder = HttpRequest.newBuilder()
+                    .uri(getServerURI().resolve(key));
+            String user = getUser();
+            if (user != null) {
+                requestBuilder.header("Authorization", buildAuthorizationHeader(user, getPassword()));
+            }
+            return requestBuilder;
+        }
+
+        @SneakyThrows
+        public URI getServerURI() {
+            return new URI(properties.getProperty("gbcs.server.url"));
+        }
+
+        @SneakyThrows
+        public Optional<String> getClientTrustStorePassword() {
+            return Optional.ofNullable(properties.getProperty("gbcs.client.ssl.truststore.password"))
+                    .filter(Predicate.not(String::isEmpty));
+
+        }
+
+        @SneakyThrows
+        public Optional<KeyStore> getClientTrustStore() {
+            return Optional.ofNullable(properties.getProperty("gbcs.client.ssl.truststore.file"))
+                    .filter(Predicate.not(String::isEmpty))
+                    .map(Path::of)
+                    .map((Fun<Path, KeyStore>) keyStoreFile -> {
+                        final var keyStore = KeyStore.getInstance("PKCS12");
+                        try (final var is = Files.newInputStream(keyStoreFile)) {
+                            keyStore.load(is, getClientTrustStorePassword().map(String::toCharArray).orElse(null));
+                        }
+                        return keyStore;
+                    });
+
+        }
+
+        @SneakyThrows
+        public Optional<KeyStore> getClientKeyStore() {
+            return Optional.ofNullable(properties.getProperty("gbcs.client.ssl.keystore.file"))
+                    .filter(Predicate.not(String::isEmpty))
+                    .map(Path::of)
+                    .map((Fun<Path, KeyStore>) keyStoreFile -> {
+                        final var keyStore = KeyStore.getInstance("PKCS12");
+                        try (final var is = Files.newInputStream(keyStoreFile)) {
+                            keyStore.load(is, getClientKeyStorePassword().map(String::toCharArray).orElse(null));
+                        }
+                        return keyStore;
+                    });
+
+        }
+
+        @SneakyThrows
+        public Optional<String> getClientKeyStorePassword() {
+            return Optional.ofNullable(properties.getProperty("gbcs.client.ssl.keystore.password"))
+                    .filter(Predicate.not(String::isEmpty));
+
+        }
+
+        @SneakyThrows
+        public Optional<String> getClientKeyPassword() {
+            return Optional.ofNullable(properties.getProperty("gbcs.client.ssl.key.password"))
+                    .filter(Predicate.not(String::isEmpty));
+
+        }
+
+        @SneakyThrows
+        public String getUser() {
+            return Optional.ofNullable(properties.getProperty("gbcs.server.username"))
+                    .filter(Predicate.not(String::isEmpty))
+                    .orElse(null);
+
+        }
+
+        @SneakyThrows
+        public String getPassword() {
+            return Optional.ofNullable(properties.getProperty("gbcs.server.password"))
+                    .filter(Predicate.not(String::isEmpty))
+                    .orElse(null);
+        }
+
+        private String buildAuthorizationHeader(String user, String password) {
+            final var b64 = Base64.getEncoder().encode(String.format("%s:%s", user, password).getBytes(StandardCharsets.UTF_8));
+            return "Basic " + new String(b64);
+        }
+
+        @SneakyThrows
+        private Optional<SSLContext> getSslContext() {
+            return getClientKeyStore().map((Fun<KeyStore, SSLContext>) clientKeyStore -> {
+                final var kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+                kmf.init(clientKeyStore, getClientKeyStorePassword().map(String::toCharArray).orElse(null));
+
+
+                // Set up trust manager factory with the truststore
+                final var trustManagers = getClientTrustStore().map((Fun<KeyStore, TrustManager[]>) ts -> {
+                    final var tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+                    tmf.init(ts);
+                    return tmf.getTrustManagers();
+                }).orElse(new TrustManager[0]);
+
+                // Create SSL context with the key and trust managers
+                final var sslContext = SSLContext.getInstance("TLS");
+                sslContext.init(kmf.getKeyManagers(), trustManagers, null);
+                return sslContext;
+            });
+        }
+
+        @SneakyThrows
+        @Setup(Level.Trial)
+        public void setUp() {
+            final var client = getClient();
+            for (int i = 0; i < 1000; i++) {
+                final var pair = newEntry();
+                final var requestBuilder = newRequestBuilder(pair.getKey())
+                        .header("Content-Type", "application/octet-stream")
+                        .PUT(HttpRequest.BodyPublishers.ofByteArray(pair.getValue()));
+                final var response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
+                if (201 != response.statusCode()) {
+                    throw new IllegalStateException(Integer.toString(response.statusCode()));
+                } else {
+                    entries.put(pair.getKey(), pair.getValue());
+                }
+            }
+        }
+
+        @TearDown
+        public void tearDown() {
+            client.close();
+        }
+
+
+        private Iterator<Map.Entry<String, byte[]>> it = null;
+
+        private Map.Entry<String, byte[]> nextEntry() {
+            if (it == null || !it.hasNext()) {
+                it = getEntries().entrySet().iterator();
+            }
+            return it.next();
+        }
+    }
+
+    @SneakyThrows
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.SECONDS)
+    public void get(ExecutionPlan plan) {
+        final var client = plan.getClient();
+        final var entry = plan.nextEntry();
+        final var requestBuilder = plan.newRequestBuilder(entry.getKey())
+                .header("Accept", "application/octet-stream")
+                .GET();
+        final var response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray());
+        if (200 != response.statusCode()) {
+            throw new IllegalStateException(Integer.toString(response.statusCode()));
+        } else {
+            if (!Arrays.equals(entry.getValue(), response.body())) {
+                throw new IllegalStateException("Retrieved unexpected value");
+            }
+        }
+    }
+
+
+    @SneakyThrows
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.SECONDS)
+    public void put(Main.ExecutionPlan plan) {
+        final var client = plan.getClient();
+        final var entry = plan.nextEntry();
+
+        final var requestBuilder = plan.newRequestBuilder(entry.getKey())
+                .header("Content-Type", "application/octet-stream")
+                .PUT(HttpRequest.BodyPublishers.ofByteArray(entry.getValue()));
+
+        final var response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofByteArray());
+        if (201 != response.statusCode()) {
+            throw new IllegalStateException(Integer.toString(response.statusCode()));
+        }
+    }
+}

gbcs-client/src/jmh/resources/benchmark.properties

@@ -0,0 +1,6 @@
+gbcs.server.url= https://gbcs.woggioni.net:443
+gbcs.client.ssl.keystore.file=conf/woggioni@c962475fa38.p12
+gbcs.client.ssl.keystore.password=password
+gbcs.client.ssl.key.password=password
+gbcs.client.ssl.truststore.file=conf/truststore.pfx
+gbcs.client.ssl.truststore.password=password

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

@@ -0,0 +1,15 @@
+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.base;
+    requires io.netty.codec;
+
+    exports net.woggioni.gbcs.client;
+
+    opens net.woggioni.gbcs.client.schema;
+}

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

@@ -0,0 +1,209 @@
+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.ChannelInitializer
+import io.netty.channel.ChannelPipeline
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.SocketChannel
+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 net.woggioni.gbcs.base.Xml
+import net.woggioni.gbcs.client.impl.Parser
+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.util.Base64
+import java.util.concurrent.CompletableFuture
+import io.netty.util.concurrent.Future as NettyFuture
+
+
+class GbcsClient(private val profile: Configuration.Profile) : AutoCloseable {
+    private val group: NioEventLoopGroup
+    private var sslContext: SslContext
+
+
+    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?
+        )
+
+        companion object {
+            fun parse(path : Path) : Configuration {
+                return Files.newInputStream(path).use {
+                    Xml.parseXml(path.toUri().toURL(), it)
+                }.let(Parser::parse)
+            }
+        }
+    }
+
+    init {
+        group = NioEventLoopGroup()
+
+        this.sslContext = SslContextBuilder.forClient().also { builder ->
+
+            (profile.authentication as? Configuration.Authentication.TlsClientAuthenticationCredentials)?.let { tlsClientAuthenticationCredentials ->
+                builder.keyManager(
+                    tlsClientAuthenticationCredentials.key,
+                    *tlsClientAuthenticationCredentials.certificateChain
+                )
+            }
+        }.build()
+    }
+
+    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>()
+
+        try {
+            val scheme = if (uri.scheme == null) "http" else uri.scheme
+            val host = uri.host
+            var port = uri.port
+            if (port == -1) {
+                port = if ("https".equals(scheme, ignoreCase = true)) 443 else 80
+            }
+
+            val bootstrap = Bootstrap()
+            bootstrap.group(group)
+                .channel(NioSocketChannel::class.java)
+                .handler(object : ChannelInitializer<SocketChannel>() {
+                    override fun initChannel(ch: SocketChannel) {
+                        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())
+
+
+                        // Custom handler for processing responses
+                        pipeline.addLast("handler", object : SimpleChannelInboundHandler<FullHttpResponse>() {
+                            override fun channelRead0(
+                                ctx: ChannelHandlerContext,
+                                response: FullHttpResponse
+                            ) {
+                                responseFuture.complete(response)
+                                ctx.close()
+                            }
+
+                            override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
+                                val ex = when (cause) {
+                                    is DecoderException -> cause.cause
+                                    else -> cause
+                                }
+                                responseFuture.completeExceptionally(ex)
+                                ctx.close()
+                            }
+                        })
+                    }
+                })
+
+            // Connect to host
+            val channel: Channel = bootstrap.connect(host, port).sync().channel()
+
+            // 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, host)
+                        set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                        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)
+        } catch (e: Exception) {
+            responseFuture.completeExceptionally(e)
+        }
+
+        return responseFuture
+    }
+
+    fun shutDown(): NettyFuture<*> {
+        return group.shutdownGracefully()
+    }
+
+    override fun close() {
+        shutDown().sync()
+    }
+}

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

@@ -0,0 +1,9 @@
+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/Main.kt

@@ -0,0 +1,38 @@
+package net.woggioni.gbcs.client
+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 kotlin.random.Random
+
+
+//object Main {
+//    @JvmStatic
+//    fun main(vararg args : String) {
+//        val pwd = "PO%!*bW9p'Zp#=uu\$fl{Ij`Ad.8}x#ho".toCharArray()
+//        val keystore = KeyStore.getInstance("PKCS12").apply{
+//            Files.newInputStream(Path.of("/home/woggioni/ssl/woggioni@c962475fa38.pfx")).use {
+//                load(it, pwd)
+//            }
+//        }
+//        val key = keystore.getKey("woggioni@c962475fa38", pwd) as PrivateKey
+//        val certChain = keystore.getCertificateChain("woggioni@c962475fa38").asSequence()
+//            .map { it as X509Certificate }
+//            .toList()
+//            .toTypedArray()
+//        GbcsClient.Configuration(
+//            serverURI = URI("https://gbcs.woggioni.net/"),
+//            GbcsClient.TlsClientAuthenticationCredentials(
+//                key, certChain
+//            )
+//        ).let(::GbcsClient).use { client ->
+//            val random = Random(101325)
+//            val entry = "something" to ByteArray(0x1000).also(random::nextBytes)
+//            client.put(entry.first, entry.second)
+//            val retrieved = client.get(entry.first).get()
+//            println(retrieved.contentEquals(entry.second))
+//        }
+//    }
+//}

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

@@ -0,0 +1,64 @@
+package net.woggioni.gbcs.client.impl
+
+import net.woggioni.gbcs.base.Xml.Companion.asIterable
+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
+
+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.getAttribute("name")
+                    val uri = child.getAttribute("base-url").let(::URI)
+                    var authentication: GbcsClient.Configuration.Authentication? = null
+                    for (gchild in child.asIterable()) {
+                        when (gchild.localName) {
+                            "tls-client-auth" -> {
+                                val keyStoreFile = gchild.getAttribute("key-store-file")
+                                val keyStorePassword =
+                                    gchild.getAttribute("key-store-password").takeIf(String::isNotEmpty)
+                                val keyAlias = gchild.getAttribute("key-alias")
+                                val keyPassword = gchild.getAttribute("key-password").takeIf(String::isNotEmpty)
+
+                                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.getAttribute("user")
+                                val password = gchild.getAttribute("password")
+                                authentication =
+                                    GbcsClient.Configuration.Authentication.BasicAuthenticationCredentials(username, password)
+                            }
+                        }
+                    }
+                    profiles[name] = GbcsClient.Configuration.Profile(uri, authentication)
+                }
+            }
+        }
+        return GbcsClient.Configuration(profiles)
+    }
+}

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

@@ -0,0 +1,36 @@
+<?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="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:complexType>
+
+    <xs:complexType name="basicAuthType">
+        <xs:attribute name="user" type="xs:string" 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:string" 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

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