feat(grpc): Add resolver wrapper to handle HTTP CONNECT proxy configuration

grpc/Cargo.toml

@@ -57,6 +57,7 @@ hickory-resolver = { version = "0.26.1", optional = true }
 http = "1.1.0"
 http-body = "1.0.1"
 hyper = { version = "1.6.0", features = ["client", "http2"] }
+hyper-util = { version = "0.1", features = ["client-proxy"] }
 itoa = "1.0"
 parking_lot = "0.12.4"
 percent-encoding = "2.3"

grpc/src/client/channel.rs

@@ -254,7 +254,7 @@ impl PersistentChannel {
             .unwrap_or_else(|| resolver_builder.default_authority(&target).to_owned());
         let security_opts = SecurityOpts {
             credentials,
-            authority: parse_authority(&authority),
+            authority: Authority::from_host_port_str(&authority),
             handshake_info: ClientHandshakeInfo::default(),
         };
 
@@ -616,163 +616,3 @@ fn parse_authority(host_and_port: &str) -> Authority {
     }
     Authority::new(host_and_port.to_string(), None)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_authority() {
-        struct TestCase {
-            input: &'static str,
-            expected: Authority,
-        }
-
-        let cases = [
-            TestCase {
-                input: "localhost:http",
-                expected: Authority::new("localhost:http", None),
-            },
-            TestCase {
-                input: "localhost:80",
-                expected: Authority::new("localhost", Some(80)),
-            },
-            // host name with zone identifier.
-            TestCase {
-                input: "localhost%lo0:80",
-                expected: Authority::new("localhost%lo0", Some(80)),
-            },
-            TestCase {
-                input: "localhost%lo0:http",
-                expected: Authority::new("localhost%lo0:http", None),
-            },
-            TestCase {
-                input: "[localhost%lo0]:http",
-                expected: Authority::new("[localhost%lo0]:http", None),
-            },
-            TestCase {
-                input: "[localhost%lo0]:80",
-                expected: Authority::new("localhost%lo0", Some(80)),
-            },
-            // IP literal
-            TestCase {
-                input: "127.0.0.1:http",
-                expected: Authority::new("127.0.0.1:http", None),
-            },
-            TestCase {
-                input: "127.0.0.1:80",
-                expected: Authority::new("127.0.0.1", Some(80)),
-            },
-            TestCase {
-                input: "[::1]:http",
-                expected: Authority::new("[::1]:http", None),
-            },
-            TestCase {
-                input: "[::1]:80",
-                expected: Authority::new("::1", Some(80)),
-            },
-            // IP literal with zone identifier.
-            TestCase {
-                input: "[::1%lo0]:http",
-                expected: Authority::new("[::1%lo0]:http", None),
-            },
-            TestCase {
-                input: "[::1%lo0]:80",
-                expected: Authority::new("::1%lo0", Some(80)),
-            },
-            TestCase {
-                input: ":http",
-                expected: Authority::new(":http", None),
-            },
-            TestCase {
-                input: ":80",
-                expected: Authority::new("", Some(80)),
-            },
-            TestCase {
-                input: "grpc.io:",
-                expected: Authority::new("grpc.io:", None),
-            },
-            TestCase {
-                input: "127.0.0.1:",
-                expected: Authority::new("127.0.0.1:", None),
-            },
-            TestCase {
-                input: "[::1]:",
-                expected: Authority::new("[::1]:", None),
-            },
-            TestCase {
-                input: "grpc.io:https%foo",
-                expected: Authority::new("grpc.io:https%foo", None),
-            },
-            TestCase {
-                input: "grpc.io",
-                expected: Authority::new("grpc.io", None),
-            },
-            TestCase {
-                input: "127.0.0.1",
-                expected: Authority::new("127.0.0.1", None),
-            },
-            TestCase {
-                input: "[::1]",
-                expected: Authority::new("[::1]", None),
-            },
-            TestCase {
-                input: "[fe80::1%lo0]",
-                expected: Authority::new("[fe80::1%lo0]", None),
-            },
-            TestCase {
-                input: "[localhost%lo0]",
-                expected: Authority::new("[localhost%lo0]", None),
-            },
-            TestCase {
-                input: "localhost%lo0",
-                expected: Authority::new("localhost%lo0", None),
-            },
-            TestCase {
-                input: "::1",
-                expected: Authority::new("::1", None),
-            },
-            TestCase {
-                input: "fe80::1%lo0",
-                expected: Authority::new("fe80::1%lo0", None),
-            },
-            TestCase {
-                input: "fe80::1%lo0:80",
-                expected: Authority::new("fe80::1%lo0:80", None),
-            },
-            TestCase {
-                input: "[foo:bar]",
-                expected: Authority::new("[foo:bar]", None),
-            },
-            TestCase {
-                input: "[foo:bar]baz",
-                expected: Authority::new("[foo:bar]baz", None),
-            },
-            TestCase {
-                input: "[foo]bar:baz",
-                expected: Authority::new("[foo]bar:baz", None),
-            },
-            TestCase {
-                input: "[foo]:[bar]:baz",
-                expected: Authority::new("[foo]:[bar]:baz", None),
-            },
-            TestCase {
-                input: "[foo]:[bar]baz",
-                expected: Authority::new("[foo]:[bar]baz", None),
-            },
-            TestCase {
-                input: "foo[bar]:baz",
-                expected: Authority::new("foo[bar]:baz", None),
-            },
-            TestCase {
-                input: "foo]bar:baz",
-                expected: Authority::new("foo]bar:baz", None),
-            },
-        ];
-
-        for TestCase { input, expected } in cases {
-            let auth = parse_authority(input);
-            assert_eq!(auth, expected, "authority mismatch for {}", input);
-        }
-    }
-}

grpc/src/client/name_resolution/dns/mod.rs

@@ -110,7 +110,7 @@ pub(crate) fn reg() {
     global_registry().add_builder(Box::new(Builder {}));
 }
 
-struct Builder {}
+pub(crate) struct Builder {}
 
 struct DnsOptions {
     min_resolution_interval: Duration,

grpc/src/client/name_resolution/mod.rs

@@ -57,6 +57,7 @@ pub(crate) mod unix;
 #[cfg(target_os = "linux")]
 pub(crate) mod unix_abstract;
 pub(crate) use registry::global_registry;
+pub(crate) mod proxy_resolver;
 
 /// Target represents a target for gRPC, as specified in:
 /// https://github.com/grpc/grpc/blob/master/doc/naming.md.