WebClient not using HTTP2 unless explicitly specified

[dekelpilli]

We're just starting out with using Helidon for our HTTP clients across our stack. I'm not sure what we're doing wrong in trying to get it to default to HTTP/2 when possible, with a fallback to HTTP/1.1 when the server does not support HTTP2. I'm using helidon-webclient-http2 version 4.2.0.

These examples are in Clojure, but I've stuck to directly using Java methods in these examples

(def client (.build (WebClient/builder))) ;use the default client throughout these examples

;defaults to HTTP1 when not protocolId is not specified
(-> (.method client Method/GET)
    (.uri (URI. "https://gitlab.com"))
    (.request)
    (.getClass))
; => io.helidon.webclient.http1.Http1ClientResponseImpl

;showing that HTTP2 would work for this endpoint
(-> (.method client Method/GET)
    (.uri (URI. "https://gitlab.com"))
    (.protocolId "h2")
    (.request)
    (.getClass))
; => io.helidon.webclient.http2.Http2ClientResponseImpl

This behaviour is consistent across HTTP and HTTPS, and I'm not sure what I'd need to do to make it default to HTTP2 when the server supports this. The above examples remain the same even if I explicitly define the protocol priority:

(def client (-> (WebClient/builder)
                (.protocolPreference ["h2" "http/1.1"])
                (.build)))

[arjav-desai]

I am not a Clojure user/expert so don't understand it as well. Our document https://helidon.io/docs/latest/se/webclient section "Protocol Used" explains when/how the protocols are used/upgraded.

[dekelpilli]

Ok, let me rework the examples into Java:

WebClient client = WebClient.builder().build(); // use the default client throughout these examples

client.method(Method/GET)
    .uri(new URI("https://gitlab.com"))
    .request()
    .getClass(); //output is io.helidon.webclient.http1.Http1ClientResponseImpl, indicating the request was made with HTTP1.

client.method(Method/GET)
    .uri(new URI("https://gitlab.com"))
    .protocolId("h2")
    .request()
    .getClass(); //output is io.helidon.webclient.http2.Http2ClientResponseImpl, indicating the request was made with HTTP2.

//if I use the following client instead, the results are the same
List<String> protocols = new ArrayList<>();
protocols.add("h2");
protocols.add("http/1.1");

WebClient client = WebClient.builder().protocolPreference(protocols).build();

In the docs you linked, it says

When using TLS, the client will use ALPN (protocol negotiation) to use appropriate HTTP version (either 1.1, or 2). HTTP/2 has a higher weight, so it is chosen if supported by both sides.

As you can see in the example above, we are using TLS, and gitlab.com does indeed support HTTP/2, and yet the request is made with HTTP/1.1 unless manually specified to use HTTP/2.

Furthermore, the docs say:

If HTTP/2 is used, an upgrade attempt will be performed. If it fails, the client falls-back to HTTP/1.1.
but if I make a request against a server that only supports HTTP/1.1 while specifying to use HTTP/2, the client throws an exception:

//elsewhere, set up webserver with io.helidon.webserver/helidon-webserver but no helidon-webserver-http2. This server is listening on port 3030.

client.method(Method/GET)
    .uri(new URI("http://localhost:3030/test"))
    .protocolId("h2")
    .request(); // the request is received by the server, but the client throws the following
    
/*
java.util.NoSuchElementException: If upgrade fails, connection cannot be obtained
 at io.helidon.webclient.http1.UpgradeResponse.connection (UpgradeResponse.java:90)
    io.helidon.webclient.http2.Http2ClientConnectionHandler.createConnection (Http2ClientConnectionHandler.java:279)
    io.helidon.webclient.http2.Http2ClientConnectionHandler.http2 (Http2ClientConnectionHandler.java:112)
    io.helidon.webclient.http2.Http2ClientConnectionHandler.newStream (Http2ClientConnectionHandler.java:94)
    io.helidon.webclient.http2.Http2ConnectionCache.newStream (Http2ConnectionCache.java:102)
    io.helidon.webclient.http2.Http2CallChainBase.proceed (Http2CallChainBase.java:118)
    io.helidon.webclient.api.ClientRequestBase.invokeServices (ClientRequestBase.java:429)
    io.helidon.webclient.http2.Http2ClientRequestImpl.invokeWithServices (Http2ClientRequestImpl.java:177)
    io.helidon.webclient.http2.Http2ClientRequestImpl.invokeEntity (Http2ClientRequestImpl.java:167)
    io.helidon.webclient.http2.RedirectionProcessor.invokeWithFollowRedirects (RedirectionProcessor.java:60)
    io.helidon.webclient.http2.Http2ClientRequestImpl.doSubmit (Http2ClientRequestImpl.java:104)
    io.helidon.webclient.http2.Http2ClientRequestImpl.doSubmit (Http2ClientRequestImpl.java:30)
    io.helidon.webclient.api.ClientRequestBase.validateAndSubmit (ClientRequestBase.java:486)
    io.helidon.webclient.api.ClientRequestBase.submit (ClientRequestBase.java:282)
    io.helidon.webclient.api.HttpClientRequest.doSubmit (HttpClientRequest.java:95)
    io.helidon.webclient.api.ClientRequestBase.validateAndSubmit (ClientRequestBase.java:486)
    io.helidon.webclient.api.ClientRequestBase.request (ClientRequestBase.java:273)
    ...
*/

[arjav-desai]

I am checking with our experts but just to be sure, are you using this in standalone mode i.e. helidon-webclient is running outside of helidon service? If you can share your reproducer project that would be helpful.

[dekelpilli]

Yes, the clients are fully standalone - we are just using the helidon webclient as a library. I don't have a ready-to-share reproduction project, but if I have time today I'll try to set one up in Java. That said, the code snippets above would be pretty much what it will contain, as we're not deviating from the default settings much at this point.

[arjav-desai]

Thanks for that clarification, I will try to reproduce on my end and keep you posted. With JavaOne going on for next 2 days, response may be delayed.

[dekelpilli]

I'm actually not able to reproduce this exception above ("If upgrade fails, connection cannot be obtained"), but I've set up a test that shows the other behaviours described here - https://github.com/dekelpilli/helidon-http2-behaviour. You can run run-test.sh and read the logs to see the results. For me, the output is:

[SERVER] WEB server is up! http://localhost:3030
[CLIENT] Testing using default client...
[CLIENT] Made request to https://gitlab.com, received class io.helidon.webclient.http1.Http1ClientResponseImpl when protocol was not specified.
[CLIENT] Made request to https://gitlab.com, received class io.helidon.webclient.http2.Http2ClientResponseImpl when protocol was specified as 'h2'.
[SERVER] Received request with protocol HTTP1.1.
[CLIENT] Made request to http://localhost:3030/test, received class io.helidon.webclient.http1.Http1ClientResponseImpl when protocol was not specified.
[SERVER] Received request with protocol HTTP1.1.
[CLIENT] Made request to http://localhost:3030/test, received class io.helidon.webclient.http2.Http2ClientResponseImpl when protocol was specified as 'h2'.
[CLIENT] Testing using client with HTTP2 priority set manually...
[CLIENT] Made request to https://gitlab.com, received class io.helidon.webclient.http1.Http1ClientResponseImpl when protocol was not specified.
[CLIENT] Made request to https://gitlab.com, received class io.helidon.webclient.http2.Http2ClientResponseImpl when protocol was specified as 'h2'.
[SERVER] Received request with protocol HTTP1.1.
[CLIENT] Made request to http://localhost:3030/test, received class io.helidon.webclient.http1.Http1ClientResponseImpl when protocol was not specified.
[SERVER] Received request with protocol HTTP1.1.
[CLIENT] Made request to http://localhost:3030/test, received class io.helidon.webclient.http2.Http2ClientResponseImpl when protocol was specified as 'h2'.
[CLIENT] Made requests to webhook.site, check link to see if query params were present in the requests: https://webhook.site/#!/view/1a562b31-adba-4aad-9f9a-e1a56ee4b9cc

Note that it seems the server actually only receives HTTP/1.1 requests, even when the client receives a io.helidon.webclient.http2.Http2ClientResponseImpl response (when h2 is specified) - this makes sense as it does not have the http2 dependency, but the receiving Http2ClientResponseImpl was unexpected for me.

This above test also shows that (at the end) that when I make requests with h2 specified, the query params are dropped from the request.

[arjav-desai]

Also, this thread #8828 may be worth a look.

[dekelpilli]

Thanks - I saw this thread, but it seems to be talking about the server's ability to accept HTTP/2, rather than the client's ability to make those requests by default.

[danielkec]

This is interesting, let's break it down.

1. Query params
   Query params are part of URI, so when you set URI with uri(URI uri) you are basically overriding any query params previously set.
   Try it like this:

            Class clz = client.method(Method.GET)
                    .uri(uri)
                    .queryParam("test", "test")

2. Http2ClientResponseImpl
   AFAIK it was never meant to indicate that actual connection was made on h2 protocol. It just means that h2 was attempted.
   I don't think we have any such API on the client to check which protocol was used.
   Feel free to create feature request if such API is needed

[dekelpilli]

1. The client tests for both methods of setting the query parameters:

        client.method(Method.POST)
                .uri(new URI("https://webhook.site/1a562b31-adba-4aad-9f9a-e1a56ee4b9cc"))
                .queryParam("xyz", "test")
                .protocolId("h2")
                .request()
                .getClass();

        client.method(Method.PATCH)
                .uri(new URI("https://webhook.site/1a562b31-adba-4aad-9f9a-e1a56ee4b9cc?xyz=test"))
                .protocolId("h2")
                .request()
                .getClass();

As you can see here - https://webhook.site/#!/view/1a562b31-adba-4aad-9f9a-e1a56ee4b9cc/73174e81-fdc2-4d65-92ef-bebfa20dbbd0/1 - both the POST and PATCH requests are received by webhook.site with no query parameters.

2. That's ok, it was a bit surprising to me but not a problem, I guess. Does that mean that io.helidon.webclient.http1.Http1ClientResponseImpl can be returned even if HTTP2 was used, or only the other way around? Because if the HTTP1ClientResponseImpl indicates HTTP2 wasn't attempted, then it's not clear to me why https://gitlab.com never had a HTTP2 attempt.