added HTTP/2 window size configuration, increased default values (#616)

Author: rashtao

core/src/main/java/com/arangodb/ArangoDB.java

@@ -562,6 +562,28 @@ public Builder pipelining(final Boolean pipelining) {
             return this;
         }
 
+        /**
+         * Sets the size of the connection window for HTTP/2.
+         *
+         * @param connectionWindowSize size in bytes
+         * @return {@link ArangoDB.Builder}
+         */
+        public Builder connectionWindowSize(final Integer connectionWindowSize) {
+            config.setConnectionWindowSize(connectionWindowSize);
+            return this;
+        }
+
+        /**
+         * Sets the initial window size for HTTP/2 streams.
+         *
+         * @param initialWindowSize size in bytes
+         * @return {@link ArangoDB.Builder}
+         */
+        public Builder initialWindowSize(final Integer initialWindowSize) {
+            config.setInitialWindowSize(initialWindowSize);
+            return this;
+        }
+
         /**
          * Sets the maximum number of connections the built in connection pool will open per host.
          *

core/src/main/java/com/arangodb/config/ArangoConfigProperties.java

@@ -25,6 +25,8 @@ public interface ArangoConfigProperties {
     String KEY_VERIFY_HOST = "verifyHost";
     String KEY_CHUNK_SIZE = "chunkSize";
     String KEY_PIPELINING = "pipelining";
+    String KEY_CONNECTION_WINDOW_SIZE = "connectionWindowSize";
+    String KEY_INITIAL_WINDOW_SIZE = "initialWindowSize";
     String KEY_MAX_CONNECTIONS = "maxConnections";
     String KEY_CONNECTION_TTL = "connectionTtl";
     String KEY_KEEP_ALIVE_INTERVAL = "keepAliveInterval";
@@ -130,6 +132,14 @@ default Optional<Boolean> getPipelining() {
         return Optional.empty();
     }
 
+    default Optional<Integer> getConnectionWindowSize() {
+        return Optional.empty();
+    }
+
+    default Optional<Integer> getInitialWindowSize() {
+        return Optional.empty();
+    }
+
     default Optional<Integer> getMaxConnections() {
         return Optional.empty();
     }

core/src/main/java/com/arangodb/internal/ArangoDefaults.java

@@ -30,9 +30,12 @@
 
 /**
  * @author Mark Vollmary
+ * @author Michele Rastelli
  */
 public final class ArangoDefaults {
 
+    private static final int MB = 1024 * 1024;
+
     public static final int INTEGER_BYTES = Integer.SIZE / Byte.SIZE;
     public static final int LONG_BYTES = Long.SIZE / Byte.SIZE;
     public static final int CHUNK_MIN_HEADER_SIZE = INTEGER_BYTES + INTEGER_BYTES + LONG_BYTES;
@@ -52,6 +55,8 @@ public final class ArangoDefaults {
     public static final Boolean DEFAULT_VERIFY_HOST = true;
     public static final Integer DEFAULT_CHUNK_SIZE = 30_000;
     public static final Boolean DEFAULT_PIPELINING = false;
+    public static final Integer DEFAULT_CONNECTION_WINDOW_SIZE = 32 * MB;
+    public static final Integer DEFAULT_INITIAL_WINDOW_SIZE = 2 * MB;
     public static final Boolean DEFAULT_ACQUIRE_HOST_LIST = false;
     public static final Integer DEFAULT_ACQUIRE_HOST_LIST_INTERVAL = 60 * 60 * 1000; // hour
     public static final LoadBalancingStrategy DEFAULT_LOAD_BALANCING_STRATEGY = LoadBalancingStrategy.NONE;

core/src/main/java/com/arangodb/internal/config/ArangoConfig.java

@@ -42,6 +42,8 @@ public class ArangoConfig {
     private Boolean verifyHost;
     private Integer chunkSize;
     private Boolean pipelining;
+    private Integer connectionWindowSize;
+    private Integer initialWindowSize;
     private Integer maxConnections;
     private Long connectionTtl;
     private Integer keepAliveInterval;
@@ -83,6 +85,8 @@ public void loadProperties(final ArangoConfigProperties properties) {
         verifyHost = properties.getVerifyHost().orElse(ArangoDefaults.DEFAULT_VERIFY_HOST);
         chunkSize = properties.getChunkSize().orElse(ArangoDefaults.DEFAULT_CHUNK_SIZE);
         pipelining = properties.getPipelining().orElse(ArangoDefaults.DEFAULT_PIPELINING);
+        connectionWindowSize = properties.getConnectionWindowSize().orElse(ArangoDefaults.DEFAULT_CONNECTION_WINDOW_SIZE);
+        initialWindowSize = properties.getInitialWindowSize().orElse(ArangoDefaults.DEFAULT_INITIAL_WINDOW_SIZE);
         // FIXME: make maxConnections field Optional
         maxConnections = properties.getMaxConnections().orElse(null);
         // FIXME: make connectionTtl field Optional
@@ -209,6 +213,22 @@ public void setPipelining(Boolean pipelining) {
         this.pipelining = pipelining;
     }
 
+    public Integer getConnectionWindowSize() {
+        return connectionWindowSize;
+    }
+
+    public void setConnectionWindowSize(Integer connectionWindowSize) {
+        this.connectionWindowSize = connectionWindowSize;
+    }
+
+    public Integer getInitialWindowSize() {
+        return initialWindowSize;
+    }
+
+    public void setInitialWindowSize(Integer initialWindowSize) {
+        this.initialWindowSize = initialWindowSize;
+    }
+
     public Integer getMaxConnections() {
         if (maxConnections == null) {
             maxConnections = getDefaultMaxConnections();

core/src/main/java/com/arangodb/internal/config/ArangoConfigPropertiesImpl.java

@@ -139,6 +139,16 @@ public Optional<Boolean> getPipelining() {
         return Optional.ofNullable(getProperty(KEY_PIPELINING)).map(Boolean::valueOf);
     }
 
+    @Override
+    public Optional<Integer> getConnectionWindowSize() {
+        return Optional.ofNullable(getProperty(KEY_CONNECTION_WINDOW_SIZE)).map(Integer::valueOf);
+    }
+
+    @Override
+    public Optional<Integer> getInitialWindowSize() {
+        return Optional.ofNullable(getProperty(KEY_INITIAL_WINDOW_SIZE)).map(Integer::valueOf);
+    }
+
     @Override
     public Optional<Integer> getMaxConnections() {
         return Optional.ofNullable(getProperty(KEY_MAX_CONNECTIONS)).map(Integer::valueOf);

http-protocol/src/main/java/com/arangodb/http/HttpConnection.java

@@ -40,6 +40,7 @@
 import io.vertx.core.Vertx;
 import io.vertx.core.VertxOptions;
 import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Http2Settings;
 import io.vertx.core.http.HttpHeaders;
 import io.vertx.core.http.HttpMethod;
 import io.vertx.core.http.HttpVersion;
@@ -161,7 +162,9 @@ private static String getUserAgent() {
                 .setProtocolVersion(httpVersion)
                 .setDefaultHost(host.getHost())
                 .setDefaultPort(host.getPort())
-                .setProxyOptions(protocolConfig.getProxyOptions());
+                .setProxyOptions(protocolConfig.getProxyOptions())
+                .setHttp2ConnectionWindowSize(config.getConnectionWindowSize())
+                .setInitialSettings(new Http2Settings().setInitialWindowSize(config.getInitialWindowSize()));
 
         if (compression != Compression.NONE) {
             webClientOptions.setTryUseCompression(true);

test-non-functional/src/test/java/mp/ArangoConfigPropertiesMPImpl.java

@@ -27,6 +27,8 @@ public final class ArangoConfigPropertiesMPImpl implements ArangoConfigPropertie
     private Optional<Boolean> verifyHost;
     private Optional<Integer> chunkSize;
     private Optional<Boolean> pipelining;
+    private Optional<Integer> connectionWindowSize;
+    private Optional<Integer> initialWindowSize;
     private Optional<Integer> maxConnections;
     private Optional<Long> connectionTtl;
     private Optional<Integer> keepAliveInterval;
@@ -104,6 +106,16 @@ public Optional<Boolean> getPipelining() {
         return pipelining;
     }
 
+    @Override
+    public Optional<Integer> getConnectionWindowSize() {
+        return connectionWindowSize;
+    }
+
+    @Override
+    public Optional<Integer> getInitialWindowSize() {
+        return initialWindowSize;
+    }
+
     @Override
     public Optional<Integer> getMaxConnections() {
         return maxConnections;
@@ -164,12 +176,12 @@ public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         ArangoConfigPropertiesMPImpl that = (ArangoConfigPropertiesMPImpl) o;
-        return Objects.equals(hosts, that.hosts) && Objects.equals(protocol, that.protocol) && Objects.equals(user, that.user) && Objects.equals(password, that.password) && Objects.equals(jwt, that.jwt) && Objects.equals(timeout, that.timeout) && Objects.equals(useSsl, that.useSsl) && Objects.equals(verifyHost, that.verifyHost) && Objects.equals(chunkSize, that.chunkSize) && Objects.equals(pipelining, that.pipelining) && Objects.equals(maxConnections, that.maxConnections) && Objects.equals(connectionTtl, that.connectionTtl) && Objects.equals(keepAliveInterval, that.keepAliveInterval) && Objects.equals(acquireHostList, that.acquireHostList) && Objects.equals(acquireHostListInterval, that.acquireHostListInterval) && Objects.equals(loadBalancingStrategy, that.loadBalancingStrategy) && Objects.equals(responseQueueTimeSamples, that.responseQueueTimeSamples) && Objects.equals(compression, that.compression) && Objects.equals(compressionThreshold, that.compressionThreshold) && Objects.equals(compressionLevel, that.compressionLevel) && Objects.equals(serdeProviderClass, that.serdeProviderClass);
+        return Objects.equals(hosts, that.hosts) && Objects.equals(protocol, that.protocol) && Objects.equals(user, that.user) && Objects.equals(password, that.password) && Objects.equals(jwt, that.jwt) && Objects.equals(timeout, that.timeout) && Objects.equals(useSsl, that.useSsl) && Objects.equals(verifyHost, that.verifyHost) && Objects.equals(chunkSize, that.chunkSize) && Objects.equals(pipelining, that.pipelining) && Objects.equals(connectionWindowSize, that.connectionWindowSize) && Objects.equals(initialWindowSize, that.initialWindowSize) && Objects.equals(maxConnections, that.maxConnections) && Objects.equals(connectionTtl, that.connectionTtl) && Objects.equals(keepAliveInterval, that.keepAliveInterval) && Objects.equals(acquireHostList, that.acquireHostList) && Objects.equals(acquireHostListInterval, that.acquireHostListInterval) && Objects.equals(loadBalancingStrategy, that.loadBalancingStrategy) && Objects.equals(responseQueueTimeSamples, that.responseQueueTimeSamples) && Objects.equals(compression, that.compression) && Objects.equals(compressionThreshold, that.compressionThreshold) && Objects.equals(compressionLevel, that.compressionLevel) && Objects.equals(serdeProviderClass, that.serdeProviderClass);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(hosts, protocol, user, password, jwt, timeout, useSsl, verifyHost, chunkSize, pipelining, maxConnections, connectionTtl, keepAliveInterval, acquireHostList, acquireHostListInterval, loadBalancingStrategy, responseQueueTimeSamples, compression, compressionThreshold, compressionLevel, serdeProviderClass);
+        return Objects.hash(hosts, protocol, user, password, jwt, timeout, useSsl, verifyHost, chunkSize, pipelining, connectionWindowSize, initialWindowSize, maxConnections, connectionTtl, keepAliveInterval, acquireHostList, acquireHostListInterval, loadBalancingStrategy, responseQueueTimeSamples, compression, compressionThreshold, compressionLevel, serdeProviderClass);
     }
 
     @Override
@@ -185,6 +197,8 @@ public String toString() {
                 ", verifyHost=" + verifyHost +
                 ", chunkSize=" + chunkSize +
                 ", pipelining=" + pipelining +
+                ", connectionWindowSize=" + connectionWindowSize +
+                ", initialWindowSize=" + initialWindowSize +
                 ", maxConnections=" + maxConnections +
                 ", connectionTtl=" + connectionTtl +
                 ", keepAliveInterval=" + keepAliveInterval +

test-non-functional/src/test/java/mp/ConfigMPDefaultsTest.java

@@ -29,6 +29,8 @@ private void checkResult(ArangoConfigProperties config) {
         assertThat(config.getVerifyHost()).isEmpty();
         assertThat(config.getChunkSize()).isEmpty();
         assertThat(config.getPipelining()).isEmpty();
+        assertThat(config.getConnectionWindowSize()).isEmpty();
+        assertThat(config.getInitialWindowSize()).isEmpty();
         assertThat(config.getMaxConnections()).isNotPresent();
         assertThat(config.getConnectionTtl()).isNotPresent();
         assertThat(config.getKeepAliveInterval()).isNotPresent();

test-non-functional/src/test/java/mp/ConfigMPTest.java

@@ -27,6 +27,8 @@ class ConfigMPTest {
     private final Boolean verifyHost = false;
     private final Integer vstChunkSize = 1234;
     private final Boolean pipelining = true;
+    private final Integer connectionWindowSize = 987;
+    private final Integer initialWindowSize = 876;
     private final Integer maxConnections = 123;
     private final Long connectionTtl = 12345L;
     private final Integer keepAliveInterval = 123456;
@@ -66,6 +68,8 @@ private void checkResult(ArangoConfigProperties config) {
         assertThat(config.getVerifyHost()).hasValue(verifyHost);
         assertThat(config.getChunkSize()).hasValue(vstChunkSize);
         assertThat(config.getPipelining()).hasValue(pipelining);
+        assertThat(config.getConnectionWindowSize()).hasValue(connectionWindowSize);
+        assertThat(config.getInitialWindowSize()).hasValue(initialWindowSize);
         assertThat(config.getMaxConnections())
                 .isPresent()
                 .hasValue(maxConnections);

test-non-functional/src/test/resources/arangodb-config-test.properties

@@ -11,6 +11,8 @@ adb.sslProtocol=sslProtocol
 adb.verifyHost=false
 adb.chunkSize=1234
 adb.pipelining=true
+adb.connectionWindowSize=987
+adb.initialWindowSize=876
 adb.maxConnections=123
 adb.connectionTtl=12345
 adb.keepAliveInterval=123456