From 619873c4a914a1cc67a4118919b2c24b14e0b3d0 Mon Sep 17 00:00:00 2001 From: Walter Oggioni Date: Fri, 7 Feb 2025 10:18:54 +0800 Subject: [PATCH] removed `readTimeout` and `writeTimeout` from server configuration added Markdown documentation --- LICENSE | 20 + README.md | 165 ++++++ .../net/woggioni/rbcs/api/Configuration.java | 2 - .../rbcs/cli/impl/commands/ServerCommand.kt | 3 + rbcs-server-memcache/README.md | 46 ++ .../rbcs/server/RemoteBuildCacheServer.kt | 13 - .../rbcs/server/configuration/Parser.kt | 8 - .../rbcs/server/configuration/Serializer.kt | 2 - .../net/woggioni/rbcs/server/rbcs-default.xml | 13 +- .../net/woggioni/rbcs/server/schema/rbcs.xsd | 544 ++++++++++++++++-- .../test/AbstractBasicAuthServerTest.kt | 2 - .../rbcs/server/test/AbstractTlsServerTest.kt | 2 - .../rbcs/server/test/NoAuthServerTest.kt | 2 - .../rbcs/server/test/valid/rbcs-default.xml | 2 - .../server/test/valid/rbcs-memcached-tls.xml | 4 +- .../rbcs/server/test/valid/rbcs-memcached.xml | 2 - .../rbcs/server/test/valid/rbcs-tls.xml | 2 - 17 files changed, 721 insertions(+), 111 deletions(-) create mode 100644 LICENSE create mode 100644 rbcs-server-memcache/README.md diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..879f678 --- /dev/null +++ b/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2017 Y. T. CHUNG + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md index e69de29..b3f4366 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,165 @@ +# Remote Build Cache Server +Remote Build Cache Server (shortened to RBCS) allows you to share and reuse unchanged build +and test outputs across the team. This speeds up local and CI builds since cycles are not wasted +re-building components that are unaffected by new code changes. RBCS supports both Gradle and +Maven build tool environments. + +It comes with pluggable storage backends, the core application offers in-memory storage or disk-backed storage, +in addition to this there is an official plugin to use memcached as the storage backend. + +It supports HTTP basic authentication or, alternatively, TLS certificate authentication, role-based access control (RBAC), +and throttling. + +## Quickstart + +### Downloading the jar file +You can download the latest version from [this link](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni:rbcs-cli/) + +Assuming you have Java 21 or later installed, you can launch the server directly with + +```bash +java -jar rbcs-cli.jar server +``` + +By default it will start an HTTP server bound to localhost and listening on port 8080 with no authentication, +writing data to the disk, that you can use for testing + +### Using the Docker image +You can pull the latest Docker image with +```bash +docker pull gitea.woggioni.net/woggioni/rbcs:latest +``` + +By default it will start an HTTP server bound to localhost and listening on port 8080 with no authentication, +writing data to the disk, that you can use for testing + +## Usage + +### Configuration +The location of the `rbcs.xml` configuration file depends on the operating system, +Alternatively it can be changed setting the `RBCS_CONFIGURATION_DIR` environmental variable or `net.woggioni.rbcs.conf.dir` Java system property +to the directory that contain the `rbcs.xml` file. + +The server configuration file follows the XML format and uses XML schema for validation +(you can find the schema for the main configuration file [here](https://gitea.woggioni.net/woggioni/rbcs/src/branch/master/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd)). + +The configuration values are enclosed inside XML attribute and support system property / environmental variable interpolation. +As an example, you can configure RBCS to read the server port number from the `RBCS_SERVER_PORT` environmental variable +and the bind address from the `rbc.bind.address` JVM system property with. + +Full documentation for all tags and attributes is available [here](doc/server_configuration.md). + +### Plugins +If you want to use memcache as a storage backend you'll also need to download [the memcache plugin](https://gitea.woggioni.net/woggioni/-/packages/maven/net.woggioni:rbcs-server-memcache/) + +Plugins need to be stored in a folder named `plugins` in the located server's working directory +(the directory where the server process is started). They are shipped as TAR archives, so you need to extract +the content of the archive into the `plugins` directory for the server to pick them up. + +### Using RBCS with Gradle + +Add this to the `settings.gradle` file of your project + +```groovy +buildCache { + remote(HttpBuildCache) { + url = 'https://rbcs.example.com/' + push = true + allowInsecureProtocol = false + } +} +``` + +alternatively you can add this to `${GRADLE_HOME}/init.gradle` + +```groovy +gradle.settingsEvaluated { settings -> + settings.buildCache { + remote(HttpBuildCache) { + url = 'https://rbcs.example.com/' + push = true + allowInsecureProtocol = false + } + } +} +``` + +### Using RBCS with Maven + +Read [here](https://maven.apache.org/extensions/maven-build-cache-extension/remote-cache.html) + +## FAQ +### Why should I use a build cache? + +#### Build Caches Improve Build & Test Performance + +Building software consists of a number of steps, like compiling sources, executing tests, and linking binaries. We’ve seen that a binary artifact repository helps when such a step requires an external component by downloading the artifact from the repository rather than building it locally. +However, there are many additional steps in this build process which can be optimized to reduce the build time. An obvious strategy is to avoid executing build steps which dominate the total build time when these build steps are not needed. +Most build times are dominated by the testing step. + +While binary repositories cannot capture the outcome of a test build step (only the test reports +when included in binary artifacts), build caches are designed to eliminate redundant executions +for every build step. Moreover, it generalizes the concept of avoiding work associated with any +incremental step of the build, including test execution, compilation and resource processing. +The mechanism itself is comparable to a pure function. That is, given some inputs such as source +files and environment parameters we know that the output is always going to be the same. +As a result, we can cache it and retrieve it based on a simple cryptographic hash of the inputs. +Build caching is supported natively by some build tools. + +#### Improve CI builds with a remote build cache + +When analyzing the role of a build cache it is important to take into account the granularity +of the changes that it caches. Imagine a full build for a project with 40 to 50 modules +which fails at the last step (deployment) because the staging environment is temporarily unavailable. +Although the vast majority of the build steps (potentially thousands) succeed, +the change can not be deployed to the staging environment. +Without a build cache one typically relies on a very complex CI configuration to reuse build step outputs +or would have to repeat the full build once the environment is available. + +Some build tools don’t support incremental builds properly. For example, outputs of a build started +from scratch may vary when compared to subsequent builds that rely on the initial build’s output. +As a result, to preserve build integrity, it’s crucial to rebuild from scratch, or ‘cleanly,’ in this +scenario. + +With a build cache, only the last step needs to be executed and the build can be re-triggered +when the environment is back online. This automatically saves all of the time and +resources required across the different build steps which were successfully executed. +Instead of executing the intermediate steps, the build tool pulls the outputs from the build cache, +avoiding a lot of redundant work + +#### Share outputs with a remote build cache + +One of the most important advantages of a remote build cache is the ability to share build outputs. +In most CI configurations, for example, a number of pipelines are created. +These may include one for building the sources, one for testing, one for publishing the outcomes +to a remote repository, and other pipelines to test on different platforms. +There are even situations where CI builds partially build a project (i.e. some modules and not others). + +Most of those pipelines share a lot of intermediate build steps. All builds which perform testing +require the binaries to be ready. All publishing builds require all previous steps to be executed. +And because modern CI infrastructure means executing everything in containerized (isolated) environments, +significant resources are wasted by repeatedly building the same intermediate artifacts. + +A remote build cache greatly reduces this overhead by orders of magnitudes because it provides a way +for all those pipelines to share their outputs. After all, there is no point recreating an output that +is already available in the cache. + +Because there are inherent dependencies between software components of a build, +introducing a build cache dramatically reduces the impact of exploding a component into multiple pieces, +allowing for increased modularity without increased overhead. + +#### Make local developers more efficient with remote build caches + +It is common for different teams within a company to work on different modules of a single large +application. In this case, most teams don’t care about building the other parts of the software. +By introducing a remote cache developers immediately benefit from pre-built artifacts when checking out code. +Because it has already been built on CI, they don’t have to do it locally. + +Introducing a remote cache is a huge benefit for those developers. Consider that a typical developer’s +day begins by performing a code checkout. Most likely the checked out code has already been built on CI. +Therefore, no time is wasted running the first build of the day. The remote cache provides all of the +intermediate artifacts needed. And, in the event local changes are made, the remote cache still leverages +partial cache hits for projects which are independent. As other developers in the organization request +CI builds, the remote cache continues to populate, increasing the likelihood of these remote cache hits +across team members. + diff --git a/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java b/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java index 39bce5d..9d7af56 100644 --- a/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java +++ b/rbcs-api/src/main/java/net/woggioni/rbcs/api/Configuration.java @@ -35,8 +35,6 @@ public class Configuration { @Value public static class Connection { - Duration readTimeout; - Duration writeTimeout; Duration idleTimeout; Duration readIdleTimeout; Duration writeIdleTimeout; diff --git a/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ServerCommand.kt b/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ServerCommand.kt index d569a2b..2ad4a07 100644 --- a/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ServerCommand.kt +++ b/rbcs-cli/src/main/kotlin/net/woggioni/rbcs/cli/impl/commands/ServerCommand.kt @@ -59,6 +59,9 @@ class ServerCommand(app : Application) : RbcsCommand() { createDefaultConfigurationFile(configurationFile) } + log.debug { + "Using configuration file '$configurationFile'" + } val configuration = RemoteBuildCacheServer.loadConfiguration(configurationFile) log.debug { ByteArrayOutputStream().also { diff --git a/rbcs-server-memcache/README.md b/rbcs-server-memcache/README.md new file mode 100644 index 0000000..386b021 --- /dev/null +++ b/rbcs-server-memcache/README.md @@ -0,0 +1,46 @@ +# RBCS Memcache plugins + +This plugins allows RBCs to store and retrieve data from a memcache cluster. +The memcache server selection is simply based on the hash of the key, +deflate compression is also supported and performed by the RBCS server + +## Quickstart +The plugin can be built with +```bash +./gradlew rbcs-server-memcache:bundle +``` +which creates a `.tar` archive in the `build/distributions` folder. +The archive is supposed to be extracted inside the RBCS server's `plugins` directory. + +## Configuration + +The plugin can be enabled setting the `xs:type` attribute of the `cache` element +to `memcacheCacheType`. + +The plugins currently supports the following configuration attributes: +- `max-age`: the amount of time cache entries will be retained on memcache +- `digest`: digest algorithm to use on the key before submission + to memcache (optional, no digest is applied if omitted) +- `compression`: compression algorithm to apply to cache values before, + currently only `deflate` is supported (optionla, if omitted compression is disabled) +- `compression-level`: compression level to use, deflate supports compression levels from 1 to 9, + where 1 is for fast compression at the expense of speed (optional, 6 is used if omitted) +```xml + + + ... + + + + + ... +``` \ No newline at end of file diff --git a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt index 018b75a..4c9e77f 100644 --- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt +++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/RemoteBuildCacheServer.kt @@ -314,19 +314,6 @@ class RemoteBuildCacheServer(private val cfg: Configuration) { } val pipeline = ch.pipeline() cfg.connection.also { conn -> - val readTimeout = conn.readTimeout.toMillis() - val writeTimeout = conn.writeTimeout.toMillis() - if (readTimeout > 0 || writeTimeout > 0) { - pipeline.addLast( - IdleStateHandler( - false, - readTimeout, - writeTimeout, - 0, - TimeUnit.MILLISECONDS - ) - ) - } val readIdleTimeout = conn.readIdleTimeout.toMillis() val writeIdleTimeout = conn.writeIdleTimeout.toMillis() val idleTimeout = conn.idleTimeout.toMillis() diff --git a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Parser.kt b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Parser.kt index 9d44d8c..998672c 100644 --- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Parser.kt +++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Parser.kt @@ -27,8 +27,6 @@ object Parser { val root = document.documentElement val anonymousUser = User("", null, emptySet(), null) var connection: Configuration.Connection = Configuration.Connection( - Duration.of(10, ChronoUnit.SECONDS), - Duration.of(10, ChronoUnit.SECONDS), Duration.of(60, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), @@ -113,10 +111,6 @@ object Parser { } "connection" -> { - val writeTimeout = child.renderAttribute("write-timeout") - ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS) - val readTimeout = child.renderAttribute("read-timeout") - ?.let(Duration::parse) ?: Duration.of(0, ChronoUnit.SECONDS) val idleTimeout = child.renderAttribute("idle-timeout") ?.let(Duration::parse) ?: Duration.of(30, ChronoUnit.SECONDS) val readIdleTimeout = child.renderAttribute("read-idle-timeout") @@ -126,8 +120,6 @@ object Parser { val maxRequestSize = child.renderAttribute("max-request-size") ?.let(Integer::decode) ?: 0x4000000 connection = Configuration.Connection( - readTimeout, - writeTimeout, idleTimeout, readIdleTimeout, writeIdleTimeout, diff --git a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Serializer.kt b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Serializer.kt index b20b7e5..11c4821 100644 --- a/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Serializer.kt +++ b/rbcs-server/src/main/kotlin/net/woggioni/rbcs/server/configuration/Serializer.kt @@ -36,8 +36,6 @@ object Serializer { } node("connection") { conf.connection.let { connection -> - attr("read-timeout", connection.readTimeout.toString()) - attr("write-timeout", connection.writeTimeout.toString()) attr("idle-timeout", connection.idleTimeout.toString()) attr("read-idle-timeout", connection.readIdleTimeout.toString()) attr("write-idle-timeout", connection.writeIdleTimeout.toString()) diff --git a/rbcs-server/src/main/resources/net/woggioni/rbcs/server/rbcs-default.xml b/rbcs-server/src/main/resources/net/woggioni/rbcs/server/rbcs-default.xml index fcd9473..561a938 100644 --- a/rbcs-server/src/main/resources/net/woggioni/rbcs/server/rbcs-default.xml +++ b/rbcs-server/src/main/resources/net/woggioni/rbcs/server/rbcs-default.xml @@ -4,16 +4,5 @@ xmlns:rbcs="urn:net.woggioni.rbcs.server" xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd"> - - - - - - + \ No newline at end of file diff --git a/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd b/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd index 16cd8b2..36c2715 100644 --- a/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd +++ b/rbcs-server/src/main/resources/net/woggioni/rbcs/server/schema/rbcs.xsd @@ -3,14 +3,27 @@ xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:rbcs="urn:net.woggioni.rbcs.server" elementFormDefault="unqualified"> - + + + + Root element containing the server configuration + + + - + + + + Cache storage backend implementation to use, more implementations can be added through + the use of plugins + + + @@ -21,75 +34,279 @@ - - + + + + Mechanism to use to assign a username to a specific client + + + + + + + Use TLS to encrypt all the communications + + + - + + + + URI path prefix, if your rbcs is hosted at "http://www.example.com" + and this parameter is set to "cache", then all the requests will need to be sent at + "http://www.example.com/cache/KEY", where "KEY" is the cache entry KEY + + + - - - + + + Server bind address + + + + + Server port number + + + + + + The maximum queue length for incoming connection indications (a request to connect) is set to + the backlog parameter. If a connection indication arrives when the queue is full, + the connection is refused. + + + - - - - - - + + + + The server will close the connection with the client + when neither a read nor a write was performed for the specified period of time. + + + + + + + The server will close the connection with the client + when no read was performed for the specified period of time. + + + + + + + The server will close the connection with the client + when no write was performed for the specified period of time. + + + + + + + The maximum request body size the server will accept from a client + (if exceeded the server returns 413 HTTP status code) + + + - + + + + Whether or not to use virtual threads for the execution of the core server handler + (not for the I/O operations) + + + + + + A simple cache implementation that uses a java.util.ConcurrentHashMap as a storage backend + + - - - - - - + + + + Values will be removed from the cache after this amount of time + + + + + + + The maximum allowed total size of the cache in bytes, old values will be purged from the cache + when the insertion of a new value causes this limit to be exceeded + + + + + + + Hashing algorithm to apply to the key. If omitted, no hashing is performed. + + + + + + + Enable deflate compression for stored cache elements + + + + + + + Deflate compression level to use for cache compression, + use -1 to use the default compression level of java.util.zip.Deflater + + + + + + + Maximum byte size of socket write calls + + + + + + A simple cache implementation that stores data in a folder on the filesystem + + - - - - - - + + + + File system path that will be used to store the cache data files + (it will be created if it doesn't already exist) + + + + + + + Values will be removed from the cache after this amount of time + + + + + + + Hashing algorithm to apply to the key. If omitted, no hashing is performed. + + + + + + + Enable deflate compression for stored cache elements + + + + + + + Deflate compression level to use for cache compression, + use -1 to use the default compression level of java.util.zip.Deflater + + + + + + + Maximum byte size of a cache value that will be stored in memory + (reduce it to reduce memory consumption, increase it for increased throughput) + + + - - + + + + A regex based extractor that will be used to determine which group the client belongs to, + based on the X.500 name of the subject field in the client's TLS certificate. + When this is set RBAC works even if the user isn't listed in the <users/> section as + the client will be assigned role solely based on the group he is found to belong to. + Note that this does not allow for a client to be part of multiple groups. + + + + + + + A regex based extractor that will be used to assign a user to a connected client, + based on the X.500 name of the subject field in the client's TLS certificate. + + + - - + + + Extract informations from a client TLS certificates using + regular expressions applied to the X.500 name "Subject" field + + + + + + X.500 name attribute to apply the regex + + + + + + + Regex that wil be applied to the attribute value, + use regex groups to extract relevant data + (note that only the first group that appears in the regex is used) + + + - + + + + List of users registered in the application + + + + + + List of user groups registered in the application + + @@ -99,48 +316,150 @@ + + + Authentication mechanism to assign usernames and groups to clients + + - - - + + + + Enable HTTP basic authentication + + + + + + + Enable TLS certificate authentication + + + + + + + Disable authentication altogether + + + - - - - + + + Defines a quota for a user or a group + + + + + + Maximum number of allowed calls in a given period + + + + + + + The period length + + + + + + + Maximum number of available calls that can be accumulated + + + + + + + Number of available calls for users at their first call + + + + + + Placeholder for a client that is not authenticated + + - + + + + Calls quota for the user + + + + + + An authenticated user + + - + + + + Calls quota for the user + + + - - + + + + User's name + + + + + + + User's password used in HTTP basic authentication + + + - + + + List of registered users, add an <anonymous> tag to enable authenticated user access + when authentication is enabled + + + + + + List of registered user groups + + + + + The definition of a user group, with the list of its member users + + @@ -148,11 +467,35 @@ - - - + + + + The list of application roles awarded to all the members of this group + + + + + + + The call quota for each user in this group + + + + + + + The cumulative call quota for all users in this group + + + - + + + + The group's name + + + @@ -172,6 +515,11 @@ + + + A list of references to users in the <users> section + + @@ -179,28 +527,106 @@ - + + + A reference to a user in the <users> section + + + + + + Name of the referenced user + + + + + + Enable TLS protocol + + - - + + + + Path to the keystore file that contains the server's key and certificate + + + + + + + Path to the truststore file that contains the trusted CAs + for TLS client certificate verification + + + - - - - + + + + System path to the keystore file + + + + + + + Password to open they keystore file + + + + + + + Alias of the keystore entry containing the private key + + + + + + + Private key entry's encryption password + + + - - - - + + + + Path to the trustore file + + + + + + + Trustore file password + + + + + + + Whether or not check the certificate validity using CRL/OCSP + + + + + + + If true, the server requires a TLS client certificate from the client and simply refuses to connect + when a client certificate isn't provided + + + diff --git a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractBasicAuthServerTest.kt b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractBasicAuthServerTest.kt index 2d947c3..6a599f3 100644 --- a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractBasicAuthServerTest.kt +++ b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractBasicAuthServerTest.kt @@ -38,8 +38,6 @@ abstract class AbstractBasicAuthServerTest : AbstractServerTest() { serverPath, Configuration.EventExecutor(false), Configuration.Connection( - Duration.of(10, ChronoUnit.SECONDS), - Duration.of(10, ChronoUnit.SECONDS), Duration.of(60, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), diff --git a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractTlsServerTest.kt b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractTlsServerTest.kt index 8477b5a..0f3462f 100644 --- a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractTlsServerTest.kt +++ b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/AbstractTlsServerTest.kt @@ -143,8 +143,6 @@ abstract class AbstractTlsServerTest : AbstractServerTest() { serverPath, Configuration.EventExecutor(false), Configuration.Connection( - Duration.of(10, ChronoUnit.SECONDS), - Duration.of(10, ChronoUnit.SECONDS), Duration.of(60, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), diff --git a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/NoAuthServerTest.kt b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/NoAuthServerTest.kt index f2d5f5d..c8ed096 100644 --- a/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/NoAuthServerTest.kt +++ b/rbcs-server/src/test/kotlin/net/woggioni/rbcs/server/test/NoAuthServerTest.kt @@ -38,8 +38,6 @@ class NoAuthServerTest : AbstractServerTest() { serverPath, Configuration.EventExecutor(false), Configuration.Connection( - Duration.of(10, ChronoUnit.SECONDS), - Duration.of(10, ChronoUnit.SECONDS), Duration.of(60, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), Duration.of(30, ChronoUnit.SECONDS), diff --git a/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-default.xml b/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-default.xml index 5b8c866..c6ef1d5 100644 --- a/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-default.xml +++ b/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-default.xml @@ -4,8 +4,6 @@ xs:schemaLocation="urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd"> + write-idle-timeout="PT60S"/> diff --git a/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-memcached.xml b/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-memcached.xml index 0437fe8..b0491de 100644 --- a/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-memcached.xml +++ b/rbcs-server/src/test/resources/net/woggioni/rbcs/server/test/valid/rbcs-memcached.xml @@ -5,8 +5,6 @@ xs:schemaLocation="urn:net.woggioni.rbcs.server.memcache jpms://net.woggioni.rbcs.server.memcache/net/woggioni/rbcs/server/memcache/schema/rbcs-memcache.xsd urn:net.woggioni.rbcs.server jpms://net.woggioni.rbcs.server/net/woggioni/rbcs/server/schema/rbcs.xsd">