5.1.x breaking change in ALPN

[NilsRenaud]

Version

5.1.1 -> 5.1.3

Context

When Client and Server are configured with ALPN enabled and the same list of protocol, in the same order (HTTP/2, HTTP/1.1), They end up agreeing on HTTP/1.1 instead of HTTP/2 (as it used to be in 5.0.x).

Reproducer

This test pass in 5.0.x, but breaks on 5.1.x.
It simply creates a HTTPs server returning the request protocol version as HTTP response body. Checking that when both client/server have HTTP/2 as preferred protocol, they should agree to use it.

import java.util.List;

import org.junit.jupiter.api.Test;

import io.vertx.core.Vertx;
import io.vertx.core.http.HttpClientAgent;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.http.HttpVersion;
import io.vertx.core.http.RequestOptions;
import io.vertx.core.net.PemKeyCertOptions;

public class VertxMigrationTests {

    @Test
    void shouldAccessServerWithHttp2IfRequestIsHttpsAndAlpnUsed() {
        Vertx vertx = Vertx.vertx();
        HttpServer server = createHttpServerReturningVersionUsed(vertx);
        HttpClientAgent client = createHttpClientWithAlpn(vertx);
        try {
            RequestOptions requestOptions = new RequestOptions().setHost("localhost")
                                                                .setPort(server.actualPort())
                                                                .setSsl(true)
                                                                .setURI("/")
                                                                .setMethod(HttpMethod.GET);
            String responseContent = client.request(requestOptions).await()
                         .send().await()
                         .body().await()
                         .toString();
            assert "HTTP_2".equals(responseContent);
        } finally {
            server.close();
            client.close();
        }
    }

    private static HttpClientAgent createHttpClientWithAlpn(final Vertx vertx) {
        HttpClientOptions clientOptions = new HttpClientOptions()
                .setUseAlpn(true)
                .setTrustAll(true)
                .setAlpnVersions(List.of(HttpVersion.HTTP_2, HttpVersion.HTTP_1_1));
        return vertx.createHttpClient(clientOptions);
    }

    private static HttpServer createHttpServerReturningVersionUsed(final Vertx vertx) {
        HttpServerOptions serverOptions = new HttpServerOptions()
                .setSsl(true)
                .setKeyCertOptions(new PemKeyCertOptions()
                                           .setCertPath("<SELF_SIGNED_CERT>")
                                           .setKeyPath("<SELF_SIGNED_CERT_KEY>"))
                .setUseAlpn(true)
                .setAlpnVersions(List.of(HttpVersion.HTTP_2, HttpVersion.HTTP_1_1));
        return vertx.createHttpServer(serverOptions)
                                 .requestHandler(request -> request.response().end(request.version().toString()))
                                 .listen(0)
                                 .await();
    }
}

What does the spec says

From RFC 7301:

It is expected that a server will have a list of protocols that it
supports, in preference order, and will only select a protocol if the
client supports it. In that case, the server SHOULD select the most
highly preferred protocol that it supports and that is also
advertised by the client.

[vietj]

what does differ in the 2 requests beside the port ?

[NilsRenaud]

Woops sorry, It's http vs httpS.
I've updated my exemple, which was wrong (bas copy/paste).

[vietj]

@NilsRenaud can you provide a reproducer ?

I tried this test on 5.0.x

    vertx
      .createHttpServer()
      .requestHandler(request -> {
        request.response().end();
      })
      .listen(8080)
      .await();
    vertx
      .createHttpServer(new HttpServerOptions().setSsl(true).setUseAlpn(true).setKeyCertOptions(Cert.CLIENT_JKS.get()))
      .requestHandler(request -> {
        request.response().end();
      })
      .listen(8443)
      .await();
    HttpClient client = vertx.createHttpClient(new HttpClientOptions().setUseAlpn(true).setVerifyHost(false).setTrustAll(true));
    HttpClientResponse resp = client.request(new RequestOptions().setAbsoluteURI("https://localhost:8443")).compose(HttpClientRequest::send).await();
    System.out.println(resp.request().version());
    HttpClientResponse resp2 = client.request(new RequestOptions().setAbsoluteURI("http://localhost:8080")).compose(HttpClientRequest::send).await();
    System.out.println(resp2.request().version());

it is always HTTP/1.1 that is selected, perhaps I'm doing something incorrect.

[NilsRenaud]

@vietj Sorry for the delay, I switched context for a while.

Thanks for the time you took trying to reproduce the error. I've re-written my issue, with a reproducer. It's definitely an issue with ALPN.