Allow setting the HTTP/2 client header table size (#2582)

Adds a new `Endpoint` builder method which forwards the HTTP2 header
table size setting to `h2`. Follows in the footsteps of other `http_`
builder methods.

Author: ArniDagur

tests/integration_tests/tests/http2_header_table_size.rs

@@ -0,0 +1,52 @@
+use std::time::Duration;
+
+use integration_tests::pb::{test_client, test_server, Input, Output};
+use tokio::sync::oneshot;
+use tonic::{
+    transport::{Endpoint, Server},
+    Request, Response, Status,
+};
+
+#[tokio::test]
+async fn http2_header_table_size_zero() {
+    struct Svc;
+
+    #[tonic::async_trait]
+    impl test_server::Test for Svc {
+        async fn unary_call(&self, _: Request<Input>) -> Result<Response<Output>, Status> {
+            Ok(Response::new(Output {}))
+        }
+    }
+
+    let svc = test_server::TestServer::new(Svc);
+
+    let (tx, rx) = oneshot::channel::<()>();
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = format!("http://{}", listener.local_addr().unwrap());
+
+    let jh = tokio::spawn(async move {
+        let listener =
+            tonic::transport::server::TcpIncoming::from(listener).with_nodelay(Some(true));
+        Server::builder()
+            .add_service(svc)
+            .serve_with_incoming_shutdown(listener, async { drop(rx.await) })
+            .await
+            .unwrap();
+    });
+
+    tokio::time::sleep(Duration::from_millis(100)).await;
+
+    let channel = Endpoint::from_shared(addr)
+        .unwrap()
+        .http2_header_table_size(0)
+        .connect()
+        .await
+        .unwrap();
+
+    let mut client = test_client::TestClient::new(channel);
+
+    client.unary_call(Request::new(Input {})).await.unwrap();
+
+    tx.send(()).unwrap();
+    jh.await.unwrap();
+}

tonic/src/transport/channel/endpoint.rs

@@ -49,6 +49,7 @@ pub struct Endpoint {
     pub(crate) http2_keep_alive_interval: Option<Duration>,
     pub(crate) http2_keep_alive_timeout: Option<Duration>,
     pub(crate) http2_keep_alive_while_idle: Option<bool>,
+    pub(crate) http2_header_table_size: Option<u32>,
     pub(crate) http2_max_header_list_size: Option<u32>,
     pub(crate) connect_timeout: Option<Duration>,
     pub(crate) http2_adaptive_window: Option<bool>,
@@ -96,6 +97,7 @@ impl Endpoint {
             http2_keep_alive_interval: None,
             http2_keep_alive_timeout: None,
             http2_keep_alive_while_idle: None,
+            http2_header_table_size: None,
             http2_max_header_list_size: None,
             connect_timeout: None,
             http2_adaptive_window: None,
@@ -125,6 +127,7 @@ impl Endpoint {
             http2_keep_alive_interval: None,
             http2_keep_alive_timeout: None,
             http2_keep_alive_while_idle: None,
+            http2_header_table_size: None,
             http2_max_header_list_size: None,
             connect_timeout: None,
             http2_adaptive_window: None,
@@ -458,6 +461,19 @@ impl Endpoint {
         }
     }
 
+    /// Sets the `SETTINGS_HEADER_TABLE_SIZE` option for HTTP2 connections.
+    ///
+    /// Informs the peer of the maximum size of the header compression
+    /// table used to decode header blocks, in octets.
+    ///
+    /// Default is 4,096.
+    pub fn http2_header_table_size(self, size: u32) -> Self {
+        Endpoint {
+            http2_header_table_size: Some(size),
+            ..self
+        }
+    }
+
     /// Sets the max size of received header frames.
     ///
     /// This will default to whatever the default in hyper is. As of v1.4.1, it is 16 KiB.

tonic/src/transport/channel/service/connection.rs

@@ -51,6 +51,10 @@ impl Connection {
             settings.adaptive_window(val);
         }
 
+        if let Some(val) = endpoint.http2_header_table_size {
+            settings.header_table_size(val);
+        }
+
         if let Some(val) = endpoint.http2_max_header_list_size {
             settings.max_header_list_size(val);
         }