Added Http2 support

Author: liujoey

driver/pom.xml

@@ -175,6 +175,11 @@
       <artifactId>netty-codec-http</artifactId>
       <version>${netty.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-codec-http2</artifactId>
+      <version>${netty.version}</version>
+    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-handler</artifactId>

driver/src/main/java/oracle/nosql/driver/NoSQLHandleConfig.java

@@ -142,6 +142,13 @@ public class NoSQLHandleConfig implements Cloneable {
      */
     private int maxChunkSize = 0;
 
+    /**
+     * Use http2 protocol
+     *
+     * Default: false (use http_1_1)
+     */
+    private boolean http2 = false;
+
     /**
      * A RetryHandler, or null if not configured by the user.
      */
@@ -553,6 +560,14 @@ public int getDefaultRequestTimeout() {
         return timeout == 0 ? DEFAULT_TIMEOUT : timeout;
     }
 
+    /**
+     *
+     * @return http2 setting
+     */
+    public boolean useHttp2() {
+        return http2;
+    }
+
     /**
      * Returns the configured table request timeout value, in milliseconds.
      * The table request timeout default can be specified independently to allow
@@ -788,6 +803,15 @@ public NoSQLHandleConfig setMaxContentLength(int maxContentLength) {
         return this;
     }
 
+    /**
+     * Enables http2 protocol
+     * @return this
+     */
+    public NoSQLHandleConfig useHttp2(boolean enable) {
+        this.http2 = enable;
+        return this;
+    }
+
     /**
      * Returns the maximum size, in bytes, of a request operation payload.
      * On-premise only. This value is ignored for cloud operations.

driver/src/main/java/oracle/nosql/driver/http/Client.java

@@ -244,6 +244,7 @@ public Client(Logger logger,
             httpConfig.getNumThreads(),
             httpConfig.getConnectionPoolMinSize(),
             httpConfig.getConnectionPoolInactivityPeriod(),
+            httpConfig.useHttp2(),
             httpConfig.getMaxContentLength(),
             httpConfig.getMaxChunkSize(),
             sslCtx,

driver/src/main/java/oracle/nosql/driver/http/NoSQLHandleImpl.java

@@ -12,6 +12,10 @@
 
 import javax.net.ssl.SSLException;
 
+import io.netty.handler.codec.http2.Http2SecurityUtil;
+import io.netty.handler.ssl.ApplicationProtocolConfig;
+import io.netty.handler.ssl.ApplicationProtocolNames;
+import io.netty.handler.ssl.SupportedCipherSuiteFilter;
 import oracle.nosql.driver.AuthorizationProvider;
 import oracle.nosql.driver.NoSQLHandle;
 import oracle.nosql.driver.NoSQLHandleConfig;
@@ -124,6 +128,14 @@ private void configSslContext(NoSQLHandleConfig config) {
                 }
                 builder.sessionTimeout(config.getSSLSessionTimeout());
                 builder.sessionCacheSize(config.getSSLSessionCacheSize());
+                if (config.useHttp2()) {
+                    builder.ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE);
+                    builder.applicationProtocolConfig(
+                            new ApplicationProtocolConfig(ApplicationProtocolConfig.Protocol.ALPN,
+                                    ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
+                                    ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
+                                    ApplicationProtocolNames.HTTP_2));
+                }
                 config.setSslContext(builder.build());
             } catch (SSLException se) {
                 throw new IllegalStateException(
@@ -137,6 +149,7 @@ private void configAuthProvider(Logger logger, NoSQLHandleConfig config) {
         if (ap instanceof StoreAccessTokenProvider) {
             final StoreAccessTokenProvider stProvider =
                 (StoreAccessTokenProvider) ap;
+            stProvider.useHttp2(config.useHttp2());
             if (stProvider.getLogger() == null) {
                 stProvider.setLogger(logger);
             }

driver/src/main/java/oracle/nosql/driver/httpclient/Http2SettingsHandler.java

@@ -0,0 +1,28 @@
+package oracle.nosql.driver.httpclient;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http2.Http2Settings;
+
+import java.util.concurrent.TimeUnit;
+
+public class Http2SettingsHandler extends SimpleChannelInboundHandler<Http2Settings> {
+    private final ChannelPromise promise;
+
+    public Http2SettingsHandler(ChannelPromise promise) {
+        this.promise = promise;
+    }
+
+    public void awaitSettings(long timeout, TimeUnit unit) throws Exception {
+        if (!promise.awaitUninterruptibly(timeout, unit)) {
+            throw new IllegalStateException("Timed out waiting for settings");
+        }
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Http2Settings http2Settings) throws Exception {
+        promise.setSuccess();
+        channelHandlerContext.pipeline().remove(this);
+    }
+}

driver/src/main/java/oracle/nosql/driver/httpclient/HttpClient.java

@@ -96,6 +96,7 @@ public class HttpClient {
     private final String host;
     private final int port;
     private final String name;
+    private final boolean http2;
 
     /*
      * Amount of time to wait for acquiring a channel before timing
@@ -130,13 +131,15 @@ public class HttpClient {
      *
      * @param host the hostname for the HTTP server
      * @param port the port for the HTTP server
+     * @param useHttp2 if set to true, use http2 connections.
      * @param sslCtx if non-null, SSL context to use for connections.
      * @param handshakeTimeoutMs if not zero, timeout to use for SSL handshake
      * @param name A name to use in logging messages for this client.
      * @param logger A logger to use for logging messages.
      */
     public static HttpClient createMinimalClient(String host,
                                                  int port,
+                                                 boolean useHttp2,
                                                  SslContext sslCtx,
                                                  int handshakeTimeoutMs,
                                                  String name,
@@ -147,6 +150,7 @@ public static HttpClient createMinimalClient(String host,
                               0, /* pool min */
                               0, /* pool inactivity period */
                               true, /* minimal client */
+                              useHttp2,
                               DEFAULT_MAX_CONTENT_LENGTH,
                               DEFAULT_MAX_CHUNK_SIZE,
                               sslCtx, handshakeTimeoutMs, name, logger);
@@ -184,6 +188,7 @@ public HttpClient(String host,
                       int numThreads,
                       int connectionPoolMinSize,
                       int inactivityPeriodSeconds,
+                      boolean isHttp2,
                       int maxContentLength,
                       int maxChunkSize,
                       SslContext sslCtx,
@@ -192,7 +197,7 @@ public HttpClient(String host,
                       Logger logger) {
 
         this(host, port, numThreads, connectionPoolMinSize,
-             inactivityPeriodSeconds, false /* not minimal */,
+             inactivityPeriodSeconds, false /* not minimal */, isHttp2,
              maxContentLength, maxChunkSize, sslCtx, handshakeTimeoutMs, name, logger);
     }
 
@@ -205,6 +210,7 @@ private HttpClient(String host,
                        int connectionPoolMinSize,
                        int inactivityPeriodSeconds,
                        boolean isMinimalClient,
+                       boolean isHttp2,
                        int maxContentLength,
                        int maxChunkSize,
                        SslContext sslCtx,
@@ -217,6 +223,7 @@ private HttpClient(String host,
         this.host = host;
         this.port = port;
         this.name = name;
+        this.http2 = isHttp2;
 
         this.maxContentLength = (maxContentLength == 0 ?
             DEFAULT_MAX_CONTENT_LENGTH : maxContentLength);
@@ -292,6 +299,10 @@ String getName() {
         return name;
     }
 
+    boolean isHttp2() {
+        return http2;
+    }
+
     Logger getLogger() {
         return logger;
     }

driver/src/main/java/oracle/nosql/driver/httpclient/HttpClientChannelPoolHandler.java

@@ -7,9 +7,11 @@
 
 package oracle.nosql.driver.httpclient;
 
+import static io.netty.handler.logging.LogLevel.DEBUG;
 import static oracle.nosql.driver.util.LogUtil.logFine;
 
 import java.net.InetSocketAddress;
+
 import javax.net.ssl.SSLEngine;
 import javax.net.ssl.SSLParameters;
 
@@ -23,6 +25,7 @@
 import io.netty.channel.pool.ChannelPoolHandler;
 import io.netty.handler.codec.http.HttpClientCodec;
 import io.netty.handler.codec.http.HttpObjectAggregator;
+import io.netty.handler.codec.http2.*;
 import io.netty.handler.proxy.HttpProxyHandler;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.handler.ssl.SslHandshakeCompletionEvent;
@@ -37,6 +40,8 @@
 public class HttpClientChannelPoolHandler implements ChannelPoolHandler,
                                                      ChannelHealthChecker {
 
+    private static final Http2FrameLogger logger = new Http2FrameLogger(DEBUG, HttpClientChannelPoolHandler.class);
+
     private static final String CODEC_HANDLER_NAME = "http-codec";
     private static final String AGG_HANDLER_NAME = "http-aggregator";
     private static final String HTTP_HANDLER_NAME = "http-response-handler";
@@ -81,12 +86,30 @@ public void channelCreated(Channel ch) {
             p.addLast(sslHandler);
             p.addLast(new ChannelLoggingHandler(client));
         }
-        p.addLast(CODEC_HANDLER_NAME, new HttpClientCodec
-                              (4096, // initial line
-                               8192, // header size
-                               client.getMaxChunkSize()));
-        p.addLast(AGG_HANDLER_NAME, new HttpObjectAggregator(
-                                  client.getMaxContentLength()));
+        if (client.isHttp2()) {
+            Http2Connection connection = new DefaultHttp2Connection(false);
+            HttpToHttp2ConnectionHandler connectionHandler = new HttpToHttp2ConnectionHandlerBuilder()
+                    .frameListener(new DelegatingDecompressorFrameListener(
+                            connection,
+                            new InboundHttp2ToHttpAdapterBuilder(connection)
+                                    .maxContentLength(client.getMaxContentLength())
+                                    .propagateSettings(true)
+                                    .build()))
+                    .frameLogger(logger)
+                    .connection(connection)
+                    .build();
+            Http2SettingsHandler settingsHandler = new Http2SettingsHandler(ch.newPromise());
+
+            p.addLast(connectionHandler);
+            p.addLast(settingsHandler);
+        } else { // http_1_1
+            p.addLast(CODEC_HANDLER_NAME, new HttpClientCodec
+                                (4096, // initial line
+                                8192, // header size
+                                client.getMaxChunkSize()));
+            p.addLast(AGG_HANDLER_NAME, new HttpObjectAggregator(
+                                    client.getMaxContentLength()));
+        }
         p.addLast(HTTP_HANDLER_NAME,
                               new HttpClientHandler(client.getLogger()));
 

driver/src/main/java/oracle/nosql/driver/iam/InstancePrincipalsProvider.java

@@ -57,6 +57,7 @@ public class InstancePrincipalsProvider
     protected final SecurityTokenSupplier tokenSupplier;
     protected final DefaultSessionKeySupplier sessionKeySupplier;
     private final Region region;
+    private boolean useHttp2 = false;
 
     public InstancePrincipalsProvider(SecurityTokenSupplier tokenSupplier,
                                       SessionKeyPairSupplier keyPairSupplier,
@@ -72,6 +73,7 @@ public InstancePrincipalsProvider(SecurityTokenSupplier tokenSupplier,
      */
     public void prepare(NoSQLHandleConfig config) {
         tokenSupplier.prepare(config);
+        useHttp2 = config.useHttp2();
     }
 
     public void close() {
@@ -295,6 +297,7 @@ private void autoDetectEndpointUsingMetadataUrl() {
             try {
                 client = HttpClient.createMinimalClient(METADATA_SERVICE_HOST,
                                                         80,
+                                                        false,
                                                         null,
                                                         0,
                                                         "InstanceMDClient",

driver/src/main/java/oracle/nosql/driver/iam/SecurityTokenSupplier.java

@@ -104,13 +104,16 @@ synchronized void prepare(NoSQLHandleConfig config) {
             federationClient = buildHttpClient(
                 federationURL,
                 config.getSslContext(),
-                config.getSSLHandshakeTimeout(), logger);
+                config.getSSLHandshakeTimeout(),
+                config.useHttp2(),
+                logger);
         }
     }
 
     private static HttpClient buildHttpClient(URI endpoint,
                                               SslContext sslCtx,
                                               int sslHandshakeTimeout,
+                                              boolean useHttp2,
                                               Logger logger) {
         String scheme = endpoint.getScheme();
         if (scheme == null) {
@@ -119,7 +122,7 @@ private static HttpClient buildHttpClient(URI endpoint,
                  endpoint.toString());
         }
         if (scheme.equalsIgnoreCase("http")) {
-            return HttpClient.createMinimalClient(endpoint.getHost(), endpoint.getPort(),
+            return HttpClient.createMinimalClient(endpoint.getHost(), endpoint.getPort(), useHttp2,
                                                   null, 0, "FederationClient", logger);
         }
 
@@ -132,7 +135,7 @@ private static HttpClient buildHttpClient(URI endpoint,
             }
         }
 
-        return HttpClient.createMinimalClient(endpoint.getHost(), 443,
+        return HttpClient.createMinimalClient(endpoint.getHost(), 443, useHttp2,
                               sslCtx, sslHandshakeTimeout,
                               "FederationClient", logger);
     }
@@ -338,8 +341,8 @@ void validate(long minTokenLifetime) {
 
         /**
          * Checks if two public keys are equal
-         * @param a one public key
-         * @param b the other one
+         * @param actual one public key
+         * @param expect the other one
          * @return true if the same
          */
         private boolean isEqualPublicKey(RSAPublicKey actual,

driver/src/main/java/oracle/nosql/driver/kv/StoreAccessTokenProvider.java

@@ -112,6 +112,11 @@ public class StoreAccessTokenProvider implements AuthorizationProvider {
      */
     private boolean autoRenew = true;
 
+    /*
+     * Whether use http2 connection, default use http1.1
+     */
+    private boolean useHttp2 = false;
+
     /*
      * Whether this is a secure store token provider.
      */
@@ -375,6 +380,16 @@ public StoreAccessTokenProvider setLogger(Logger logger) {
         return this;
     }
 
+    /**
+     * Sets useHttp2 state
+     * @param enable set to true to use Http2 connection
+     * @return this
+     */
+    public StoreAccessTokenProvider useHttp2(boolean enable) {
+        this.useHttp2 = enable;
+        return this;
+    }
+
     public String getEndpoint() {
         return endpoint;
     }
@@ -483,6 +498,7 @@ private HttpResponse sendRequest(String authHeader,
             client = HttpClient.createMinimalClient
                 (loginHost,
                  loginPort,
+                 useHttp2,
                  (isSecure && !disableSSLHook) ? sslContext : null,
                  sslHandshakeTimeoutMs,
                  serviceName,