Better connection management

src-tauri/grpc/src/proto.rs

@@ -1,27 +1,48 @@
 use std::ops::Deref;
 use std::str::FromStr;
+
 use anyhow::anyhow;
+use hyper::client::HttpConnector;
+use hyper::Client;
+use hyper_rustls::{HttpsConnector, HttpsConnectorBuilder};
 use prost::Message;
 use prost_reflect::{DescriptorPool, MethodDescriptor};
 use prost_types::FileDescriptorProto;
 use tokio_stream::StreamExt;
+use tonic::body::BoxBody;
 use tonic::codegen::http::uri::PathAndQuery;
+use tonic::transport::Uri;
 use tonic::Request;
-use tonic::transport::{Channel, Uri};
 use tonic_reflection::pb::server_reflection_client::ServerReflectionClient;
 use tonic_reflection::pb::server_reflection_request::MessageRequest;
 use tonic_reflection::pb::server_reflection_response::MessageResponse;
 use tonic_reflection::pb::ServerReflectionRequest;
 
-pub async fn fill_pool(uri: &Uri) -> (DescriptorPool, Channel) {
+pub async fn fill_pool(
+    uri: &Uri,
+) -> (
+    DescriptorPool,
+    Client<HttpsConnector<HttpConnector>, BoxBody>,
+) {
     let mut pool = DescriptorPool::new();
-    let conn = tonic::transport::Endpoint::new(uri.clone())
-        .unwrap()
-        .connect()
-        .await
-        .unwrap();
+    let connector = HttpsConnectorBuilder::new().with_native_roots();
+    let connector = connector.https_or_http().enable_http2().wrap_connector({
+        let mut http_connector = HttpConnector::new();
+        http_connector.enforce_http(false);
+        http_connector
+    });
+    let transport = Client::builder()
+        .pool_max_idle_per_host(0)
+        .http2_only(true)
+        .build(connector);
 
-    let mut client = ServerReflectionClient::new(conn.clone());
+    println!(
+        "URI uri={} host={:?} authority={:?}",
+        uri,
+        uri.host(),
+        uri.authority()
+    );
+    let mut client = ServerReflectionClient::with_origin(transport.clone(), uri.clone());
     let services = list_services(&mut client).await;
 
     for service in services {
@@ -31,10 +52,12 @@ pub async fn fill_pool(uri: &Uri) -> (DescriptorPool, Channel) {
         file_descriptor_set_from_service_name(&service, &mut pool, &mut client).await;
     }
 
-    (pool, conn)
+    (pool, transport)
 }
 
-async fn list_services(reflect_client: &mut ServerReflectionClient<Channel>) -> Vec<String> {
+async fn list_services(
+    reflect_client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
+) -> Vec<String> {
     let response =
         send_reflection_request(reflect_client, MessageRequest::ListServices("".into())).await;
 
@@ -53,13 +76,13 @@ async fn list_services(reflect_client: &mut ServerReflectionClient<Channel>) ->
 async fn file_descriptor_set_from_service_name(
     service_name: &str,
     pool: &mut DescriptorPool,
-    client: &mut ServerReflectionClient<Channel>,
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
 ) {
     let response = send_reflection_request(
         client,
         MessageRequest::FileContainingSymbol(service_name.into()),
     )
-        .await;
+    .await;
 
     let file_descriptor_response = match response {
         MessageResponse::FileDescriptorResponse(resp) => resp,
@@ -82,7 +105,7 @@ async fn file_descriptor_set_from_service_name(
 async fn file_descriptor_set_by_filename(
     filename: &str,
     pool: &mut DescriptorPool,
-    client: &mut ServerReflectionClient<Channel>,
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
 ) {
     // We already fetched this file
     if let Some(_) = pool.get_file_by_name(filename) {
@@ -104,7 +127,7 @@ async fn file_descriptor_set_by_filename(
 }
 
 async fn send_reflection_request(
-    client: &mut ServerReflectionClient<Channel>,
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
     message: MessageRequest,
 ) -> MessageResponse {
     let reflection_request = ServerReflectionRequest {