Add RFC 10008 (QUERY Method) Support

vertx-core/src/main/generated/io/vertx/core/http/HttpClientOptionsConverter.java

@@ -127,6 +127,11 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, HttpCli
             obj.setMaxRedirects(((Number)member.getValue()).intValue());
           }
           break;
+        case "maxRedirectBufferSize":
+          if (member.getValue() instanceof Number) {
+            obj.setMaxRedirectBufferSize(((Number)member.getValue()).intValue());
+          }
+          break;
         case "forceSni":
           if (member.getValue() instanceof Boolean) {
             obj.setForceSni((Boolean)member.getValue());
@@ -193,6 +198,7 @@ static void toJson(HttpClientOptions obj, java.util.Map<String, Object> json) {
     json.put("http2ClearTextUpgrade", obj.isHttp2ClearTextUpgrade());
     json.put("http2ClearTextUpgradeWithPreflightRequest", obj.isHttp2ClearTextUpgradeWithPreflightRequest());
     json.put("maxRedirects", obj.getMaxRedirects());
+    json.put("maxRedirectBufferSize", obj.getMaxRedirectBufferSize());
     json.put("forceSni", obj.isForceSni());
     json.put("decoderInitialBufferSize", obj.getDecoderInitialBufferSize());
     if (obj.getTracingPolicy() != null) {

vertx-core/src/main/java/io/vertx/core/http/HttpClientConfig.java

@@ -79,6 +79,7 @@ private static QuicClientConfig defaultQuicConfig() {
   private String defaultHost;
   private int defaultPort;
   private int maxRedirects;
+  private int maxRedirectBufferSize;
   private ObservabilityConfig observabilityConfig;
   private boolean shared;
   private String name;
@@ -97,6 +98,7 @@ public HttpClientConfig() {
     this.defaultHost = HttpClientOptions.DEFAULT_DEFAULT_HOST;
     this.defaultPort = HttpClientOptions.DEFAULT_DEFAULT_PORT;
     this.maxRedirects = HttpClientOptions.DEFAULT_MAX_REDIRECTS;
+    this.maxRedirectBufferSize = HttpClientOptions.DEFAULT_MAX_REDIRECT_BUFFER_SIZE;
     this.observabilityConfig = null;
     this.shared = HttpClientOptions.DEFAULT_SHARED;
     this.name = HttpClientOptions.DEFAULT_NAME;
@@ -116,6 +118,7 @@ public HttpClientConfig(HttpClientConfig other) {
     this.defaultHost = other.defaultHost;
     this.defaultPort = other.defaultPort;
     this.maxRedirects = other.maxRedirects;
+    this.maxRedirectBufferSize = other.maxRedirectBufferSize;
     this.observabilityConfig = other.observabilityConfig != null ? new ObservabilityConfig(other.observabilityConfig) : null;
     this.shared = other.shared;
     this.name = other.name;
@@ -143,6 +146,7 @@ public HttpClientConfig(HttpClientOptions options) {
     this.defaultHost = options.getDefaultHost();
     this.defaultPort = options.getDefaultPort();
     this.maxRedirects = options.getMaxRedirects();
+    this.maxRedirectBufferSize = options.getMaxRedirectBufferSize();
     this.observabilityConfig = observabilityConfig;
     this.shared = options.isShared();
     this.name = options.getName();
@@ -451,6 +455,24 @@ public HttpClientConfig setMaxRedirects(int maxRedirects) {
     return this;
   }
 
+  /**
+   * @return the maximum size of the redirect buffer when redirecting QUERY requests
+   */
+  public int getMaxRedirectBufferSize() {
+    return maxRedirectBufferSize;
+  }
+
+  /**
+   * Set the maximum size of the redirect buffer in bytes when redirecting QUERY requests.
+   *
+   * @param maxRedirectBufferSize the maximum buffer size
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpClientConfig setMaxRedirectBufferSize(int maxRedirectBufferSize) {
+    this.maxRedirectBufferSize = maxRedirectBufferSize;
+    return this;
+  }
+
   /**
    * @return the client observability config.
    */

vertx-core/src/main/java/io/vertx/core/http/HttpClientOptions.java

@@ -133,6 +133,11 @@ public class HttpClientOptions extends ClientOptionsBase {
    */
   public static final int DEFAULT_MAX_REDIRECTS = 16;
 
+  /**
+   * Default max redirect buffer size = 1024 * 1024 bytes (1MB)
+   */
+  public static final int DEFAULT_MAX_REDIRECT_BUFFER_SIZE = 1024 * 1024;
+
   /*
    * Default force SNI = {@code false}
    */
@@ -171,6 +176,7 @@ public class HttpClientOptions extends ClientOptionsBase {
   private int defaultPort;
   private HttpVersion protocolVersion;
   private int maxRedirects;
+  private int maxRedirectBufferSize;
   private boolean forceSni;
 
   private TracingPolicy tracingPolicy;
@@ -211,6 +217,7 @@ public HttpClientOptions(HttpClientOptions other) {
     this.defaultPort = other.defaultPort;
     this.protocolVersion = other.protocolVersion;
     this.maxRedirects = other.maxRedirects;
+    this.maxRedirectBufferSize = other.maxRedirectBufferSize;
     this.forceSni = other.forceSni;
     this.tracingPolicy = other.tracingPolicy;
     this.shared = other.shared;
@@ -248,6 +255,7 @@ private void init() {
     defaultPort = DEFAULT_DEFAULT_PORT;
     protocolVersion = DEFAULT_PROTOCOL_VERSION;
     maxRedirects = DEFAULT_MAX_REDIRECTS;
+    maxRedirectBufferSize = DEFAULT_MAX_REDIRECT_BUFFER_SIZE;
     forceSni = DEFAULT_FORCE_SNI;
     tracingPolicy = DEFAULT_TRACING_POLICY;
     shared = DEFAULT_SHARED;
@@ -896,6 +904,24 @@ public HttpClientOptions setMaxRedirects(int maxRedirects) {
     return this;
   }
 
+  /**
+   * @return the maximum size of the redirect buffer when redirecting QUERY requests
+   */
+  public int getMaxRedirectBufferSize() {
+    return maxRedirectBufferSize;
+  }
+
+  /**
+   * Set the maximum size of the redirect buffer in bytes when redirecting QUERY requests.
+   *
+   * @param maxRedirectBufferSize the maximum buffer size
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpClientOptions setMaxRedirectBufferSize(int maxRedirectBufferSize) {
+    this.maxRedirectBufferSize = maxRedirectBufferSize;
+    return this;
+  }
+
   /**
    * @return whether the client should always use SNI on TLS/SSL connections
    */

vertx-core/src/main/java/io/vertx/core/http/HttpClientRequest.java

@@ -106,6 +106,20 @@ public interface HttpClientRequest extends WriteStream<Buffer> {
    */
   int getMaxRedirects();
 
+  /**
+   * @return the maximum size of the redirect buffer in bytes when redirecting QUERY requests
+   */
+  int getMaxRedirectBufferSize();
+
+  /**
+   * Set the maximum size of the redirect buffer in bytes when redirecting QUERY requests.
+   *
+   * @param maxRedirectBufferSize the maximum buffer size
+   * @return a reference to this, so the API can be used fluently
+   */
+  @Fluent
+  HttpClientRequest setMaxRedirectBufferSize(int maxRedirectBufferSize);
+
   /**
    * @return the number of followed redirections for the current HTTP request
    */

vertx-core/src/main/java/io/vertx/core/http/HttpHeaders.java

@@ -71,6 +71,14 @@ public interface HttpHeaders {
   @GenIgnore(GenIgnore.PERMITTED_TYPE)
   CharSequence ACCEPT_PATCH = HttpHeaderNames.ACCEPT_PATCH;
 
+  /**
+   * Accept-Query header name
+   * <p>
+   * TODO: Use {@code HttpHeaderNames.ACCEPT_QUERY} when bumping to the next Netty release
+   */
+  @GenIgnore(GenIgnore.PERMITTED_TYPE)
+  CharSequence ACCEPT_QUERY = createOptimized("accept-query");
+
   /**
    * Access-Control-Allow-Credentials header name
    */

vertx-core/src/main/java/io/vertx/core/http/HttpMethod.java

@@ -73,6 +73,11 @@ public class HttpMethod {
    */
   public static final HttpMethod PATCH;
 
+  /**
+   * The RFC 10008 {@code QUERY} method, this instance is interned and uniquely used.
+   */
+  public static final HttpMethod QUERY;
+
   /**
    * The RFC 2518/4918 {@code PROPFIND} method, this instance is interned and uniquely used.
    */
@@ -198,6 +203,8 @@ public class HttpMethod {
     TRACE = new HttpMethod(io.netty.handler.codec.http.HttpMethod.TRACE);
     CONNECT = new HttpMethod(io.netty.handler.codec.http.HttpMethod.CONNECT);
     PATCH = new HttpMethod(io.netty.handler.codec.http.HttpMethod.PATCH);
+    // TODO: Use Netty HttpMethod.QUERY in the next Netty bump
+    QUERY = new HttpMethod(io.netty.handler.codec.http.HttpMethod.valueOf("QUERY"));
     PROPFIND = new HttpMethod(io.netty.handler.codec.http.HttpMethod.valueOf("PROPFIND"));
     PROPPATCH = new HttpMethod(io.netty.handler.codec.http.HttpMethod.valueOf("PROPPATCH"));
     MKCOL = new HttpMethod(io.netty.handler.codec.http.HttpMethod.valueOf("MKCOL"));
@@ -252,7 +259,8 @@ public class HttpMethod {
       HttpMethod.MKACTIVITY,
       HttpMethod.ORDERPATCH,
       HttpMethod.ACL,
-      HttpMethod.SEARCH
+      HttpMethod.SEARCH,
+      HttpMethod.QUERY
     ));
   }
 
@@ -303,6 +311,8 @@ private static HttpMethod _fromNetty(io.netty.handler.codec.http.HttpMethod sMet
         return CONNECT;
       case "PATCH":
         return PATCH;
+      case "QUERY":
+        return QUERY;
       case "PROPFIND":
         return PROPFIND;
       case "PROPPATCH":
@@ -386,6 +396,8 @@ public static HttpMethod valueOf(String value) {
         return CONNECT;
       case "PATCH":
         return PATCH;
+      case "QUERY":
+        return QUERY;
       case "PROPFIND":
         return PROPFIND;
       case "PROPPATCH":

vertx-core/src/main/java/io/vertx/core/http/impl/DefaultRedirectHandler.java

@@ -35,7 +35,7 @@ public Future<RequestOptions> apply(HttpClientResponse resp) {
         HttpMethod m = resp.request().getMethod();
         if (statusCode == 303) {
           m = HttpMethod.GET;
-        } else if (m != HttpMethod.GET && m != HttpMethod.HEAD) {
+        } else if (m != HttpMethod.GET && m != HttpMethod.HEAD && m != HttpMethod.QUERY) {
           return null;
         }
         URI uri = HttpUtils.resolveURIReference(resp.request().absoluteURI(), location);

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientBuilderInternal.java

@@ -183,6 +183,7 @@ private HttpClientImpl createHttpClientImpl(HttpClientConfig config,
       config.getDefaultHost(),
       config.getDefaultPort(),
       config.getMaxRedirects(),
+      config.getMaxRedirectBufferSize(),
       versions,
       sslOptions,
       connectHandler,
@@ -210,14 +211,15 @@ public LegacyHttpClient(
       String defaultHost,
       int defaultPort,
       int maxRedirects,
+      int maxRedirectBufferSize,
       List<HttpVersion> versions,
       ClientSSLOptions sslOptions,
       Handler<HttpConnection> connectHandler,
       HttpClientTransport tcpTransport,
       HttpClientTransport quicTransport,
       HttpClientConfig config,
       HttpClientOptions options) {
-      super(vertx, resolver, redirectHandler, httpMetrics, poolOptions, defaultProxyOptions, nonProxyHosts, loadBalancer, followAlternativeServices, resolverIdeTimeout, verifyHost, defaultSsl, defaultHost, defaultPort, maxRedirects, versions, sslOptions, connectHandler, tcpTransport, quicTransport);
+      super(vertx, resolver, redirectHandler, httpMetrics, poolOptions, defaultProxyOptions, nonProxyHosts, loadBalancer, followAlternativeServices, resolverIdeTimeout, verifyHost, defaultSsl, defaultHost, defaultPort, maxRedirects, maxRedirectBufferSize, versions, sslOptions, connectHandler, tcpTransport, quicTransport);
       this.config = config;
       this.options = options;
     }

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientImpl.java

@@ -69,6 +69,7 @@ public class HttpClientImpl extends HttpClientBase implements HttpClientInternal
   private final String defaultHost;
   private final int defaultPort;
   private final int maxRedirects;
+  private final int maxRedirectBufferSize;
   private final List<HttpVersion> versions;
   private final Handler<HttpConnection> connectHandler;
   private volatile Handler<Throwable> exceptionHandler;
@@ -89,6 +90,7 @@ public class HttpClientImpl extends HttpClientBase implements HttpClientInternal
                  String defaultHost,
                  int defaultPort,
                  int maxRedirects,
+                 int maxRedirectBufferSize,
                  List<HttpVersion> versions,
                  ClientSSLOptions sslOptions,
                  Handler<HttpConnection> connectHandler,
@@ -117,6 +119,7 @@ public class HttpClientImpl extends HttpClientBase implements HttpClientInternal
     this.defaultHost = defaultHost;
     this.defaultPort = defaultPort;
     this.maxRedirects = maxRedirects;
+    this.maxRedirectBufferSize = maxRedirectBufferSize;
     this.versions = versions;
     this.sslOptions = sslOptions;
     this.connectHandler = connectHandler;
@@ -791,6 +794,7 @@ public ConnectionObtainedResult(HttpClientStream stream, Lease<HttpClientConnect
   HttpClientRequestImpl createRequest(HttpConnection connection, HttpClientStream stream, RequestOptions options) {
     HttpClientRequestImpl request = new HttpClientRequestImpl(connection, stream);
     request.init(options);
+    request.setMaxRedirectBufferSize(maxRedirectBufferSize);
     Function<HttpClientResponse, Future<RequestOptions>> rHandler = redirectHandler;
     if (rHandler != null) {
       request.setMaxRedirects(maxRedirects);

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java

@@ -26,6 +26,10 @@
 import io.vertx.core.net.ProxyOptions;
 import io.vertx.core.net.ProxyType;
 
+import java.util.ArrayList;
+import java.util.List;
+import io.netty.buffer.Unpooled;
+import io.netty.buffer.CompositeByteBuf;
 import java.util.Base64;
 import java.util.Map;
 import java.util.Objects;
@@ -41,6 +45,7 @@ public class HttpClientRequestImpl extends HttpClientRequestBase implements Http
 
   static final Logger log = LoggerFactory.getLogger(HttpClientRequestImpl.class);
 
+  private static final int MAX_REDIRECT_BUFFER_SIZE = 1024 * 1024;
   private final Promise<Void> endPromise;
   private final Future<Void> endFuture;
   private boolean chunked;
@@ -58,6 +63,8 @@ public class HttpClientRequestImpl extends HttpClientRequestBase implements Http
   private StreamPriority priority;
   private boolean isConnect;
   private String traceOperation;
+  private int maxRedirectBufferSize = HttpClientOptions.DEFAULT_MAX_REDIRECT_BUFFER_SIZE;
+  private List<Buffer> bodyBuffer;
 
   public HttpClientRequestImpl(HttpConnection connection, HttpClientStream stream) {
     super(connection, stream, stream.context().promise(), HttpMethod.GET, "/");
@@ -160,6 +167,18 @@ public synchronized int getMaxRedirects() {
     return maxRedirects;
   }
 
+  @Override
+  public synchronized HttpClientRequest setMaxRedirectBufferSize(int maxRedirectBufferSize) {
+    Arguments.require(maxRedirectBufferSize >= 0, "Max redirect buffer size must be >= 0");
+    this.maxRedirectBufferSize = maxRedirectBufferSize;
+    return this;
+  }
+
+  @Override
+  public synchronized int getMaxRedirectBufferSize() {
+    return maxRedirectBufferSize;
+  }
+
   @Override
   public int numberOfRedirections() {
     return numberOfRedirections;
@@ -384,13 +403,29 @@ private void handleNextRequest(HttpClientRequest next, Promise<HttpClientRespons
     next.pushHandler(pushHandler());
     next.setFollowRedirects(true);
     next.setMaxRedirects(maxRedirects);
-    ((HttpClientRequestImpl)next).numberOfRedirections = numberOfRedirections + 1;
+    HttpClientRequestImpl nextImpl = (HttpClientRequestImpl) next;
+    nextImpl.numberOfRedirections = numberOfRedirections + 1;
+    nextImpl.bodyBuffer = bodyBuffer;
     endFuture.onComplete(ar -> {
       if (ar.succeeded()) {
         if (timeoutMs > 0) {
           next.idleTimeout(timeoutMs);
         }
-        next.end();
+        if (next.getMethod() == HttpMethod.QUERY && bodyBuffer != null && !bodyBuffer.isEmpty()) {
+          Buffer redirectBody;
+          if (bodyBuffer.size() == 1) {
+            redirectBody = bodyBuffer.get(0);
+          } else {
+            CompositeByteBuf composite = Unpooled.compositeBuffer();
+            for (Buffer b : bodyBuffer) {
+              composite.addComponent(true, ((BufferInternal) b).getByteBuf());
+            }
+            redirectBody = BufferInternal.buffer(composite);
+          }
+          next.end(redirectBody);
+        } else {
+          next.end();
+        }
       } else {
         next.reset(0);
       }
@@ -505,6 +540,25 @@ private Future<Void> doWrite(Buffer buff, boolean end, boolean connect) {
       if (trailersSent) {
         return context.failedFuture(new IllegalStateException("Request already complete"));
       }
+      if (followRedirects && getMethod() == HttpMethod.QUERY) {
+        if (buff != null) {
+          int currentLen = 0;
+          if (bodyBuffer != null) {
+            for (Buffer b : bodyBuffer) {
+              currentLen += b.length();
+            }
+          }
+          if (currentLen + buff.length() > maxRedirectBufferSize) {
+            followRedirects = false;
+            bodyBuffer = null;
+          } else {
+            if (bodyBuffer == null) {
+              bodyBuffer = new ArrayList<>();
+            }
+            bodyBuffer.add(buff);
+          }
+        }
+      }
       if (!headersSent) {
         if (!connect) {
           boolean requiresContentLength = !this.chunked && !headers.contains(CONTENT_LENGTH);