chore[proxy-http]: Move utilities out of h1 module

Various utility functions are defined in the h1 module that are not strictly
HTTP/1-specific.

In preparation for additional reorganization of the http module, this change
moves utility functions:

Author: olix0r

linkerd/app/core/src/lib.rs

@@ -77,9 +77,9 @@ pub fn http_request_authority_addr<B>(req: &http::Request<B>) -> Result<Addr, ad
 }
 
 pub fn http_request_host_addr<B>(req: &http::Request<B>) -> Result<Addr, addr::Error> {
-    use crate::proxy::http::h1;
+    use crate::proxy::http;
 
-    h1::authority_from_host(req)
+    http::authority_from_header(req, http::header::HOST)
         .ok_or(addr::Error::InvalidHost)
         .and_then(|a| Addr::from_authority_and_default_port(&a, DEFAULT_PORT))
 }

linkerd/proxy/http/src/glue.rs

@@ -1,4 +1,4 @@
-use crate::{upgrade::Http11Upgrade, HasH2Reason};
+use crate::upgrade::Http11Upgrade;
 use bytes::Bytes;
 use futures::TryFuture;
 use hyper::body::HttpBody;
@@ -180,14 +180,6 @@ where
     }
 }
 
-// === impl Error ===
-
-impl HasH2Reason for hyper::Error {
-    fn h2_reason(&self) -> Option<h2::Reason> {
-        (self as &(dyn std::error::Error + 'static)).h2_reason()
-    }
-}
-
 // === impl Connected ===
 
 impl<C> AsyncRead for Connection<C>

linkerd/proxy/http/src/h1.rs

@@ -4,13 +4,13 @@ use crate::{
 };
 use futures::prelude::*;
 use http::{
-    header::{CONNECTION, CONTENT_LENGTH, HOST, TRANSFER_ENCODING, UPGRADE},
-    uri::{Authority, Parts, Scheme, Uri},
+    header::{CONTENT_LENGTH, TRANSFER_ENCODING},
+    uri::Uri,
 };
 use linkerd_error::{Error, Result};
 use linkerd_http_box::BoxBody;
 use linkerd_stack::MakeConnection;
-use std::{mem, pin::Pin, time::Duration};
+use std::{pin::Pin, time::Duration};
 use tracing::{debug, trace};
 
 #[derive(Copy, Clone, Debug)]
@@ -158,87 +158,14 @@ where
                     upgrade.insert_half(hyper::upgrade::on(&mut rsp));
                 }
             } else {
-                strip_connection_headers(rsp.headers_mut());
+                crate::strip_connection_headers(rsp.headers_mut());
             }
 
             rsp.map(BoxBody::new)
         }))
     }
 }
 
-// === HTTP/1 utils ===
-
-/// Returns an Authority from a request's Host header.
-pub fn authority_from_host<B>(req: &http::Request<B>) -> Option<Authority> {
-    super::authority_from_header(req, HOST)
-}
-
-pub(crate) fn set_authority(uri: &mut http::Uri, auth: Authority) {
-    let mut parts = Parts::from(mem::take(uri));
-
-    parts.authority = Some(auth);
-
-    // If this was an origin-form target (path only),
-    // then we can't *only* set the authority, as that's
-    // an illegal target (such as `example.com/docs`).
-    //
-    // But don't set a scheme if this was authority-form (CONNECT),
-    // since that would change its meaning (like `https://example.com`).
-    if parts.path_and_query.is_some() {
-        parts.scheme = Some(Scheme::HTTP);
-    }
-
-    let new = Uri::from_parts(parts).expect("absolute uri");
-
-    *uri = new;
-}
-
-pub(crate) fn strip_connection_headers(headers: &mut http::HeaderMap) {
-    if let Some(val) = headers.remove(CONNECTION) {
-        if let Ok(conn_header) = val.to_str() {
-            // A `Connection` header may have a comma-separated list of
-            // names of other headers that are meant for only this specific
-            // connection.
-            //
-            // Iterate these names and remove them as headers.
-            for name in conn_header.split(',') {
-                let name = name.trim();
-                headers.remove(name);
-            }
-        }
-    }
-
-    // Additionally, strip these "connection-level" headers always, since
-    // they are otherwise illegal if upgraded to HTTP2.
-    headers.remove(UPGRADE);
-    headers.remove("proxy-connection");
-    headers.remove("keep-alive");
-}
-
-/// Checks requests to determine if they want to perform an HTTP upgrade.
-pub(crate) fn wants_upgrade<B>(req: &http::Request<B>) -> bool {
-    // HTTP upgrades were added in 1.1, not 1.0.
-    if req.version() != http::Version::HTTP_11 {
-        return false;
-    }
-
-    if let Some(upgrade) = req.headers().get(UPGRADE) {
-        // If an `h2` upgrade over HTTP/1.1 were to go by the proxy,
-        // and it succeeded, there would an h2 connection, but it would
-        // be opaque-to-the-proxy, acting as just a TCP proxy.
-        //
-        // A user wouldn't be able to see any usual HTTP telemetry about
-        // requests going over that connection. Instead of that confusion,
-        // the proxy strips h2 upgrade headers.
-        //
-        // Eventually, the proxy will support h2 upgrades directly.
-        return upgrade != "h2c";
-    }
-
-    // HTTP/1.1 CONNECT requests are just like upgrades!
-    req.method() == http::Method::CONNECT
-}
-
 /// Checks responses to determine if they are successful HTTP upgrades.
 pub(crate) fn is_upgrade<B>(res: &http::Response<B>) -> bool {
     #[inline]

linkerd/proxy/http/src/lib.rs

@@ -79,6 +79,12 @@ impl HasH2Reason for ::h2::Error {
     }
 }
 
+impl HasH2Reason for ::hyper::Error {
+    fn h2_reason(&self) -> Option<h2::Reason> {
+        (self as &(dyn std::error::Error + 'static)).h2_reason()
+    }
+}
+
 /// Returns an Authority from the value of `header`.
 pub fn authority_from_header<B, K>(req: &http::Request<B>, header: K) -> Option<Authority>
 where
@@ -87,3 +93,45 @@ where
     let v = req.headers().get(header)?;
     v.to_str().ok()?.parse().ok()
 }
+
+fn set_authority(uri: &mut uri::Uri, auth: uri::Authority) {
+    let mut parts = uri::Parts::from(std::mem::take(uri));
+
+    parts.authority = Some(auth);
+
+    // If this was an origin-form target (path only),
+    // then we can't *only* set the authority, as that's
+    // an illegal target (such as `example.com/docs`).
+    //
+    // But don't set a scheme if this was authority-form (CONNECT),
+    // since that would change its meaning (like `https://example.com`).
+    if parts.path_and_query.is_some() {
+        parts.scheme = Some(http::uri::Scheme::HTTP);
+    }
+
+    let new = http::uri::Uri::from_parts(parts).expect("absolute uri");
+
+    *uri = new;
+}
+
+fn strip_connection_headers(headers: &mut http::HeaderMap) {
+    if let Some(val) = headers.remove(header::CONNECTION) {
+        if let Ok(conn_header) = val.to_str() {
+            // A `Connection` header may have a comma-separated list of
+            // names of other headers that are meant for only this specific
+            // connection.
+            //
+            // Iterate these names and remove them as headers.
+            for name in conn_header.split(',') {
+                let name = name.trim();
+                headers.remove(name);
+            }
+        }
+    }
+
+    // Additionally, strip these "connection-level" headers always, since
+    // they are otherwise illegal if upgraded to HTTP2.
+    headers.remove(header::UPGRADE);
+    headers.remove("proxy-connection");
+    headers.remove("keep-alive");
+}

linkerd/proxy/http/src/normalize_uri.rs

@@ -115,14 +115,15 @@ where
             if req.extensions().get::<h1::WasAbsoluteForm>().is_none()
                 && req.uri().authority().is_none()
             {
-                let authority = match h1::authority_from_host(&req).or_else(|| self.default.clone())
+                let authority = match crate::authority_from_header(&req, http::header::HOST)
+                    .or_else(|| self.default.clone())
                 {
                     Some(a) => a,
                     None => return future::Either::Right(future::err(NoAuthority(()).into())),
                 };
 
                 trace!(%authority, "Normalizing URI");
-                h1::set_authority(req.uri_mut(), authority);
+                crate::set_authority(req.uri_mut(), authority);
             }
         }
 

linkerd/proxy/http/src/override_authority.rs

@@ -1,4 +1,3 @@
-use super::h1;
 use http::{header::AsHeaderName, uri::Authority};
 use linkerd_stack::{layer, NewService, Param};
 use std::{
@@ -85,7 +84,7 @@ where
             }
 
             debug!(%authority, "Overriding");
-            h1::set_authority(req.uri_mut(), authority);
+            crate::set_authority(req.uri_mut(), authority);
         }
 
         self.inner.call(req)

linkerd/proxy/http/src/upgrade.rs

@@ -7,10 +7,11 @@ use futures::{
 };
 use hyper::upgrade::OnUpgrade;
 use linkerd_duplex::Duplex;
-use std::fmt;
-use std::mem;
-use std::sync::Arc;
-use std::task::{Context, Poll};
+use std::{
+    fmt, mem,
+    sync::Arc,
+    task::{Context, Poll},
+};
 use tracing::instrument::Instrument;
 use tracing::{debug, info, trace};
 use try_lock::TryLock;
@@ -198,7 +199,7 @@ where
             return Either::Right(future::ok(res));
         }
 
-        let upgrade = if h1::wants_upgrade(&req) {
+        let upgrade = if wants_upgrade(&req) {
             trace!("server request wants HTTP/1.1 upgrade");
             // Upgrade requests include several "connection" headers that
             // cannot be removed.
@@ -210,7 +211,7 @@ where
 
             Some((halves.server, on_upgrade))
         } else {
-            h1::strip_connection_headers(req.headers_mut());
+            crate::strip_connection_headers(req.headers_mut());
             None
         };
 
@@ -219,3 +220,27 @@ where
         Either::Left(self.service.call(req))
     }
 }
+
+/// Checks requests to determine if they want to perform an HTTP upgrade.
+fn wants_upgrade<B>(req: &http::Request<B>) -> bool {
+    // HTTP upgrades were added in 1.1, not 1.0.
+    if req.version() != http::Version::HTTP_11 {
+        return false;
+    }
+
+    if let Some(upgrade) = req.headers().get(http::header::UPGRADE) {
+        // If an `h2` upgrade over HTTP/1.1 were to go by the proxy,
+        // and it succeeded, there would an h2 connection, but it would
+        // be opaque-to-the-proxy, acting as just a TCP proxy.
+        //
+        // A user wouldn't be able to see any usual HTTP telemetry about
+        // requests going over that connection. Instead of that confusion,
+        // the proxy strips h2 upgrade headers.
+        //
+        // Eventually, the proxy will support h2 upgrades directly.
+        return upgrade != "h2c";
+    }
+
+    // HTTP/1.1 CONNECT requests are just like upgrades!
+    req.method() == http::Method::CONNECT
+}