Add max-chunk-size property

quarkusio · Sep 19, 2023 · 161d93f · 161d93f
1 parent 7903aa7
commit 161d93f
Show file tree

Hide file tree

Showing 23 changed files with 197 additions and 21 deletions.
diff --git a/...st-client-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientConfig.java b/...st-client-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientConfig.java
@@ -43,6 +43,7 @@ public class RestClientConfig {
         EMPTY.connectionPoolSize = Optional.empty();
         EMPTY.keepAliveEnabled = Optional.empty();
         EMPTY.maxRedirects = Optional.empty();
+        EMPTY.multipart = new RestClientMultipartConfig();
         EMPTY.headers = Collections.emptyMap();
         EMPTY.shared = Optional.empty();
         EMPTY.name = Optional.empty();
@@ -51,6 +52,8 @@ public class RestClientConfig {
         EMPTY.alpn = Optional.empty();
     }
 
+    public RestClientMultipartConfig multipart;
+
     /**
      * The base URL to use for this service. This property or the `uri` property is considered required, unless
      * the `baseUri` attribute is configured in the `@RegisterRestClient` annotation.
@@ -296,6 +299,9 @@ public static RestClientConfig load(String configKey) {
         instance.userAgent = getConfigValue(configKey, "user-agent", String.class);
         instance.http2 = getConfigValue(configKey, "http2", Boolean.class);
 
+        instance.multipart = new RestClientMultipartConfig();
+        instance.multipart.maxChunkSize = getConfigValue(configKey, "multipart.max-chunk-size", Integer.class);
+
         return instance;
     }
 
@@ -333,6 +339,9 @@ public static RestClientConfig load(Class<?> interfaceClass) {
         instance.http2 = getConfigValue(interfaceClass, "http2", Boolean.class);
         instance.alpn = getConfigValue(interfaceClass, "alpn", Boolean.class);
 
+        instance.multipart = new RestClientMultipartConfig();
+        instance.multipart.maxChunkSize = getConfigValue(interfaceClass, "multipart.max-chunk-size", Integer.class);
+
         return instance;
     }
 

diff --git a/...-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientMultipartConfig.java b/...-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientMultipartConfig.java
@@ -0,0 +1,19 @@
+package io.quarkus.restclient.config;
+
+import java.util.Optional;
+
+import io.quarkus.runtime.annotations.ConfigGroup;
+import io.quarkus.runtime.annotations.ConfigItem;
+
+@ConfigGroup
+public class RestClientMultipartConfig {
+
+    /**
+     * The max HTTP chunk size (8096 bytes by default).
+     *
+     * This property is applicable to reactive REST clients only.
+     */
+    @ConfigItem
+    public Optional<Integer> maxChunkSize;
+
+}
diff --git a/...t-client-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientsConfig.java b/...t-client-config/runtime/src/main/java/io/quarkus/restclient/config/RestClientsConfig.java
@@ -102,6 +102,8 @@ public class RestClientsConfig {
 
     public RestClientLoggingConfig logging;
 
+    public RestClientMultipartConfig multipart;
+
     /**
      * A timeout in milliseconds that REST clients should wait to connect to the remote endpoint.
      *

diff --git a/...lient-config/runtime/src/test/java/io/quarkus/restclient/config/RestClientConfigTest.java b/...lient-config/runtime/src/test/java/io/quarkus/restclient/config/RestClientConfigTest.java
@@ -72,6 +72,7 @@ private void verifyConfig(RestClientConfig config) {
         assertThat(config.connectionTTL.get()).isEqualTo(30000);
         assertThat(config.connectionPoolSize).isPresent();
         assertThat(config.connectionPoolSize.get()).isEqualTo(10);
+        assertThat(config.multipart.maxChunkSize.get()).isEqualTo(1024);
     }
 
     private static void setupMPConfig() throws IOException {

diff --git a/...ons/resteasy-classic/rest-client-config/runtime/src/test/resources/application.properties b/...ons/resteasy-classic/rest-client-config/runtime/src/test/resources/application.properties
@@ -10,6 +10,7 @@ quarkus.rest-client.test-client.query-param-style=COMMA_SEPARATED
 quarkus.rest-client.test-client.hostname-verifier=io.quarkus.restclient.configuration.MyHostnameVerifier
 quarkus.rest-client.test-client.connection-ttl=30000
 quarkus.rest-client.test-client.connection-pool-size=10
+quarkus.rest-client.test-client.multipart.max-chunk-size=1024
 
 quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".url=http://localhost:8080
 quarkus.rest-client."RestClientConfigTest".uri=http://localhost:8081
@@ -23,3 +24,4 @@ quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".query-pa
 quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".hostname-verifier=io.quarkus.restclient.configuration.MyHostnameVerifier
 quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".connection-ttl=30000
 quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".connection-pool-size=10
+quarkus.rest-client."io.quarkus.restclient.config.RestClientConfigTest".multipart.max-chunk-size=1024
diff --git a/...deployment/src/test/java/io/quarkus/rest/client/reactive/multipart/MultiByteFileTest.java b/...deployment/src/test/java/io/quarkus/rest/client/reactive/multipart/MultiByteFileTest.java
@@ -18,6 +18,9 @@
 import jakarta.ws.rs.HeaderParam;
 import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.HttpHeaders;
 import jakarta.ws.rs.core.MediaType;
 
 import org.eclipse.microprofile.rest.client.RestClientBuilder;
@@ -63,6 +66,21 @@ void shouldUploadBiggishFile() {
         assertThat(result).isEqualTo("myFile");
     }
 
+    @Test
+    void shouldChunkRequest() {
+        Client client = RestClientBuilder.newBuilder()
+                .baseUri(baseUri)
+                .property("io.quarkus.rest.client.max-chunk-size", 2)
+                .build(Client.class);
+
+        ClientForm form = new ClientForm();
+        form.file = Multi.createBy().repeating().supplier(
+                () -> (byte) 'A').atMost(10);
+
+        String result = client.chunked(form);
+        assertThat(result).isEqualTo("myFile/-1/chunked");
+    }
+
     @Test
     void shouldUploadTwoSmallFiles() {
         Client client = RestClientBuilder.newBuilder().baseUri(baseUri).build(Client.class);
@@ -180,6 +198,15 @@ public String uploadNull(@MultipartForm FormDataWithFile form) {
             return form.myFile != null ? "NON_NULL_FILE_FROM_NULL_MULTI" : "NULL_FILE";
         }
 
+        @Path("/chunked")
+        @POST
+        @Produces(MediaType.TEXT_PLAIN)
+        @Consumes(MediaType.MULTIPART_FORM_DATA)
+        public String chunked(@Context HttpHeaders headers, @MultipartForm FormData form) {
+            String filename = verifyFile(form.myFile, 10, b -> (byte) 'A');
+            return filename + "/" + headers.getLength() + "/" + headers.getHeaderString("transfer-encoding");
+        }
+
         @Path("/")
         @POST
         @Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -269,6 +296,11 @@ public interface Client {
         @Consumes(MediaType.MULTIPART_FORM_DATA)
         String postMultipart(@MultipartForm ClientForm clientForm);
 
+        @Path("/chunked")
+        @POST
+        @Consumes(MediaType.MULTIPART_FORM_DATA)
+        String chunked(@MultipartForm ClientForm clientForm);
+
         @Path("/two-files")
         @POST
         @Consumes(MediaType.MULTIPART_FORM_DATA)

diff --git a/...ent-reactive/runtime/src/main/java/io/quarkus/rest/client/reactive/runtime/Constants.java b/...ent-reactive/runtime/src/main/java/io/quarkus/rest/client/reactive/runtime/Constants.java
@@ -0,0 +1,5 @@
+package io.quarkus.rest.client.reactive.runtime;
+
+public class Constants {
+    public final static int DEFAULT_MAX_CHUNK_SIZE = 8096;
+}
diff --git a/.../runtime/src/main/java/io/quarkus/rest/client/reactive/runtime/RestClientBuilderImpl.java b/.../runtime/src/main/java/io/quarkus/rest/client/reactive/runtime/RestClientBuilderImpl.java
@@ -1,5 +1,7 @@
 package io.quarkus.rest.client.reactive.runtime;
 
+import static io.quarkus.rest.client.reactive.runtime.Constants.DEFAULT_MAX_CHUNK_SIZE;
+
 import java.lang.reflect.InvocationTargetException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -360,6 +362,13 @@ public <T> T build(Class<T> aClass) throws IllegalStateException, RestClientDefi
             clientBuilder.setUserAgent(restClientsConfig.userAgent.get());
         }
 
+        Integer maxChunkSize = (Integer) getConfiguration().getProperty(QuarkusRestClientProperties.MAX_CHUNK_SIZE);
+        if (maxChunkSize != null) {
+            clientBuilder.maxChunkSize(maxChunkSize);
+        } else {
+            clientBuilder.maxChunkSize(DEFAULT_MAX_CHUNK_SIZE);
+        }
+
         if (getConfiguration().hasProperty(QuarkusRestClientProperties.HTTP2)) {
             clientBuilder.http2((Boolean) getConfiguration().getProperty(QuarkusRestClientProperties.HTTP2));
         } else if (restClientsConfig.http2) {

diff --git a/...e/src/main/java/io/quarkus/rest/client/reactive/runtime/RestClientCDIDelegateBuilder.java b/...e/src/main/java/io/quarkus/rest/client/reactive/runtime/RestClientCDIDelegateBuilder.java
@@ -1,5 +1,7 @@
 package io.quarkus.rest.client.reactive.runtime;
 
+import static io.quarkus.rest.client.reactive.runtime.Constants.DEFAULT_MAX_CHUNK_SIZE;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
@@ -120,6 +122,10 @@ private void configureCustomProperties(QuarkusRestClientBuilder builder) {
             builder.property(QuarkusRestClientProperties.USER_AGENT, userAgent.get());
         }
 
+        Optional<Integer> maxChunkSize = oneOf(clientConfigByClassName().multipart.maxChunkSize,
+                clientConfigByConfigKey().multipart.maxChunkSize, configRoot.multipart.maxChunkSize);
+        builder.property(QuarkusRestClientProperties.MAX_CHUNK_SIZE, maxChunkSize.orElse(DEFAULT_MAX_CHUNK_SIZE));
+
         Boolean http2 = oneOf(clientConfigByClassName().http2,
                 clientConfigByConfigKey().http2).orElse(configRoot.http2);
         builder.property(QuarkusRestClientProperties.HTTP2, http2);

diff --git a/...c/test/java/io/quarkus/rest/client/reactive/runtime/RestClientCDIDelegateBuilderTest.java b/...c/test/java/io/quarkus/rest/client/reactive/runtime/RestClientCDIDelegateBuilderTest.java
@@ -103,6 +103,7 @@ public void testClientSpecificConfigs() {
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.CONNECTION_POOL_SIZE, 103);
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.KEEP_ALIVE_ENABLED, false);
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.MAX_REDIRECTS, 104);
+        Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.MAX_CHUNK_SIZE, 1024);
         Mockito.verify(restClientBuilderMock).followRedirects(true);
         Mockito.verify(restClientBuilderMock).register(MyResponseFilter1.class);
         Mockito.verify(restClientBuilderMock).queryParamStyle(QueryParamStyle.COMMA_SEPARATED);
@@ -145,6 +146,7 @@ public void testGlobalConfigs() {
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.CONNECTION_POOL_SIZE, 203);
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.KEEP_ALIVE_ENABLED, true);
         Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.MAX_REDIRECTS, 204);
+        Mockito.verify(restClientBuilderMock).property(QuarkusRestClientProperties.MAX_CHUNK_SIZE, 1024);
         Mockito.verify(restClientBuilderMock).followRedirects(true);
         Mockito.verify(restClientBuilderMock).register(MyResponseFilter2.class);
         Mockito.verify(restClientBuilderMock).queryParamStyle(QueryParamStyle.MULTI_PAIRS);
@@ -173,6 +175,7 @@ private static RestClientsConfig createSampleConfigRoot() {
         configRoot.connectionPoolSize = Optional.of(203);
         configRoot.keepAliveEnabled = Optional.of(true);
         configRoot.maxRedirects = Optional.of(204);
+        configRoot.multipart.maxChunkSize = Optional.of(1024);
         configRoot.followRedirects = Optional.of(true);
         configRoot.providers = Optional
                 .of("io.quarkus.rest.client.reactive.runtime.RestClientCDIDelegateBuilderTest$MyResponseFilter2");
@@ -211,6 +214,7 @@ private static RestClientConfig createSampleClientConfig() {
         clientConfig.keepAliveEnabled = Optional.of(false);
         clientConfig.maxRedirects = Optional.of(104);
         clientConfig.followRedirects = Optional.of(true);
+        clientConfig.multipart.maxChunkSize = Optional.of(1024);
         clientConfig.providers = Optional
                 .of("io.quarkus.rest.client.reactive.runtime.RestClientCDIDelegateBuilderTest$MyResponseFilter1");
         clientConfig.queryParamStyle = Optional.of(QueryParamStyle.COMMA_SEPARATED);

diff --git a/...ime/src/main/java/org/jboss/resteasy/reactive/client/api/QuarkusRestClientProperties.java b/...ime/src/main/java/org/jboss/resteasy/reactive/client/api/QuarkusRestClientProperties.java
@@ -2,6 +2,11 @@
 
 public class QuarkusRestClientProperties {
 
+    /**
+     * Configures the maximum chunk size.
+     */
+    public static final String MAX_CHUNK_SIZE = "io.quarkus.rest.client.max-chunk-size";
+
     /**
      * Configure the connect timeout in ms.
      */

diff --git a/...e/src/main/java/org/jboss/resteasy/reactive/client/handlers/ClientSendRequestHandler.java b/...e/src/main/java/org/jboss/resteasy/reactive/client/handlers/ClientSendRequestHandler.java
@@ -70,9 +70,11 @@ public class ClientSendRequestHandler implements ClientRestHandler {
     private final LoggingScope loggingScope;
     private final ClientLogger clientLogger;
     private final Map<Class<?>, MultipartResponseData> multipartResponseDataMap;
+    private final int maxChunkSize;
 
-    public ClientSendRequestHandler(boolean followRedirects, LoggingScope loggingScope, ClientLogger logger,
+    public ClientSendRequestHandler(int maxChunkSize, boolean followRedirects, LoggingScope loggingScope, ClientLogger logger,
             Map<Class<?>, MultipartResponseData> multipartResponseDataMap) {
+        this.maxChunkSize = maxChunkSize;
         this.followRedirects = followRedirects;
         this.loggingScope = loggingScope;
         this.clientLogger = logger;
@@ -457,7 +459,7 @@ private QuarkusMultipartFormUpload setMultipartHeadersAndPrepareBody(HttpClientR
             mode = (PausableHttpPostRequestEncoder.EncoderMode) property;
         }
         QuarkusMultipartFormUpload multipartFormUpload = new QuarkusMultipartFormUpload(Vertx.currentContext(), multipartForm,
-                true, mode);
+                true, maxChunkSize, mode);
         httpClientRequest.setChunked(multipartFormUpload.isChunked());
         setEntityRelatedHeaders(headerMap, state.getEntity());
 

diff --git a/...ient/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/ClientBuilderImpl.java b/...ient/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/ClientBuilderImpl.java
@@ -71,6 +71,7 @@ public class ClientBuilderImpl extends ClientBuilder {
 
     private LoggingScope loggingScope;
     private Integer loggingBodySize = 100;
+    private int maxChunkSize = 8096;
     private MultiQueryParamMode multiQueryParamMode;
 
     private ClientLogger clientLogger = new DefaultClientLogger();
@@ -196,6 +197,11 @@ public ClientBuilder enableCompression() {
         return this;
     }
 
+    public ClientBuilder maxChunkSize(int maxChunkSize) {
+        this.maxChunkSize = maxChunkSize;
+        return this;
+    }
+
     @Override
     public ClientImpl build() {
         HttpClientOptions options = Optional.ofNullable(configuration.getFromContext(HttpClientOptions.class))
@@ -287,6 +293,7 @@ public ClientImpl build() {
 
         clientLogger.setBodySize(loggingBodySize);
 
+        options.setMaxChunkSize(maxChunkSize);
         return new ClientImpl(options,
                 configuration,
                 CLIENT_CONTEXT_RESOLVER.resolve(Thread.currentThread().getContextClassLoader()),

diff --git a/...tive/client/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/ClientImpl.java b/...tive/client/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/ClientImpl.java
@@ -201,7 +201,8 @@ public Vertx get() {
             });
         }
 
-        handlerChain = new HandlerChain(followRedirects, loggingScope, clientContext.getMultipartResponsesData(), clientLogger);
+        handlerChain = new HandlerChain(options.getMaxChunkSize(), followRedirects, loggingScope,
+                clientContext.getMultipartResponsesData(), clientLogger);
     }
 
     public ClientContext getClientContext() {

diff --git a/...ve/client/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/HandlerChain.java b/...ve/client/runtime/src/main/java/org/jboss/resteasy/reactive/client/impl/HandlerChain.java
@@ -36,11 +36,12 @@ class HandlerChain {
 
     private ClientRestHandler preClientSendHandler = null;
 
-    public HandlerChain(boolean followRedirects, LoggingScope loggingScope,
+    public HandlerChain(int maxChunkSize, boolean followRedirects, LoggingScope loggingScope,
             Map<Class<?>, MultipartResponseData> multipartData, ClientLogger clientLogger) {
         this.clientCaptureCurrentContextRestHandler = new ClientCaptureCurrentContextRestHandler();
         this.clientSwitchToRequestContextRestHandler = new ClientSwitchToRequestContextRestHandler();
-        this.clientSendHandler = new ClientSendRequestHandler(followRedirects, loggingScope, clientLogger, multipartData);
+        this.clientSendHandler = new ClientSendRequestHandler(maxChunkSize, followRedirects, loggingScope, clientLogger,
+                multipartData);
         this.clientSetResponseEntityRestHandler = new ClientSetResponseEntityRestHandler();
         this.clientResponseCompleteRestHandler = new ClientResponseCompleteRestHandler();
         this.clientErrorHandler = new ClientErrorHandler(loggingScope);