feat(client): add ALPN h2 support for client connectors

- Adds `Connected::negotiated_h2()` method to signal the connection must
  use HTTP2. `Connect` implementations should set this if using ALPN.

If a connection to a host is detected to have been upgraded via ALPN,
any other oustanding connect futures will be canceled, and the waiting
requests will make use of the single HTTP2 connection.

The `http2_only` builder configuration still works the same, not
requiring ALPN at all, and always using only a single connection.

src/client/conn.rs

@@ -466,6 +466,7 @@ impl Builder {
  T: AsyncRead + AsyncWrite + Send + 'static,
  B: Payload + 'static,
  {
+ trace!("client handshake HTTP/{}", if self.http2 { 2 } else { 1 });
  Handshake {
  builder: self.clone(),
  io: Some(io),

src/client/connect/mod.rs

@@ -36,7 +36,6 @@ pub trait Connect: Send + Sync {
 /// A set of properties to describe where and how to try to connect.
 #[derive(Clone, Debug)]
 pub struct Destination {
- //pub(super) alpn: Alpn,
  pub(super) uri: Uri,
 }
 
@@ -46,21 +45,18 @@ pub struct Destination {
 /// was used, or if connected to an HTTP proxy.
 #[derive(Debug)]
 pub struct Connected {
- //alpn: Alpn,
+ pub(super) alpn: Alpn,
  pub(super) is_proxied: bool,
  pub(super) extra: Option<Extra>,
 }
 
 pub(super) struct Extra(Box<ExtraInner>);
 
-/*TODO: when HTTP1 Upgrades to H2 are added, this will be needed
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub(super) enum Alpn {
- Http1,
- //H2,
- //Http1OrH2
+ H2,
+ None,
 }
-*/
 
 impl Destination {
  /// Get the protocol scheme.
@@ -246,7 +242,7 @@ impl Connected {
  /// Create new `Connected` type with empty metadata.
  pub fn new() -> Connected {
  Connected {
- //alpn: Alpn::Http1,
+ alpn: Alpn::None,
  is_proxied: false,
  extra: None,
  }
@@ -274,19 +270,18 @@ impl Connected {
  self
  }
 
- /*
  /// Set that the connected transport negotiated HTTP/2 as it's
  /// next protocol.
- pub fn h2(mut self) -> Connected {
+ pub fn negotiated_h2(mut self) -> Connected {
  self.alpn = Alpn::H2;
  self
  }
- */
 
  // Don't public expose that `Connected` is `Clone`, unsure if we want to
  // keep that contract...
  pub(super) fn clone(&self) -> Connected {
  Connected {
+ alpn: self.alpn.clone(),
  is_proxied: self.is_proxied,
  extra: self.extra.clone(),
  }

src/client/mod.rs

@@ -86,12 +86,12 @@ use futures::{Async, Future, Poll};
 use futures::future::{self, Either, Executor};
 use futures::sync::oneshot;
 use http::{Method, Request, Response, Uri, Version};
-use http::header::{Entry, HeaderValue, HOST};
+use http::header::{HeaderValue, HOST};
 use http::uri::Scheme;
 
 use body::{Body, Payload};
 use common::{Exec, lazy as hyper_lazy, Lazy};
-use self::connect::{Connect, Connected, Destination};
+use self::connect::{Alpn, Connect, Connected, Destination};
 use self::pool::{Key as PoolKey, Pool, Poolable, Pooled, Reservation};
 
 #[cfg(feature = "runtime")] pub use self::connect::HttpConnector;
@@ -192,23 +192,19 @@ where C: Connect + Sync + 'static,
 
  /// Send a constructed Request using this Client.
  pub fn request(&self, mut req: Request<B>) -> ResponseFuture {
- let is_http_11 = self.ver == Ver::Http1 && match req.version() {
- Version::HTTP_11 => true,
- Version::HTTP_10 => false,
- other => {
+ let is_http_connect = req.method() == &Method::CONNECT;
+ match req.version() {
+ Version::HTTP_11 => (),
+ Version::HTTP_10 => if is_http_connect {
+ debug!("CONNECT is not allowed for HTTP/1.0");
+ return ResponseFuture::new(Box::new(future::err(::Error::new_user_unsupported_request_method())));
+ },
+ other => if self.ver != Ver::Http2 {
  error!("Request has unsupported version \"{:?}\"", other);
  return ResponseFuture::new(Box::new(future::err(::Error::new_user_unsupported_version())));
  }
  };
 
- let is_http_connect = req.method() == &Method::CONNECT;
-
- if !is_http_11 && is_http_connect {
- debug!("client does not support CONNECT requests for {:?}", req.version());
- return ResponseFuture::new(Box::new(future::err(::Error::new_user_unsupported_request_method())));
- }
-
-
  let uri = req.uri().clone();
  let domain = match (uri.scheme_part(), uri.authority_part()) {
  (Some(scheme), Some(auth)) => {
@@ -233,21 +229,7 @@ where C: Connect + Sync + 'static,
  }
  };
 
- if self.set_host && self.ver == Ver::Http1 {
- if let Entry::Vacant(entry) = req.headers_mut().entry(HOST).expect("HOST is always valid header name") {
- let hostname = uri.host().expect("authority implies host");
- let host = if let Some(port) = uri.port() {
- let s = format!("{}:{}", hostname, port);
- HeaderValue::from_str(&s)
- } else {
- HeaderValue::from_str(hostname)
- }.expect("uri host is valid header value");
- entry.insert(host);
- }
- }
-
-
- let pool_key = (Arc::new(domain.to_string()), self.ver);
+ let pool_key = Arc::new(domain.to_string());
  ResponseFuture::new(Box::new(self.retryably_send_request(req, pool_key)))
  }
 
@@ -283,23 +265,38 @@ where C: Connect + Sync + 'static,
  fn send_request(&self, mut req: Request<B>, pool_key: PoolKey) -> impl Future<Item=Response<Body>, Error=ClientError<B>> {
  let conn = self.connection_for(req.uri().clone(), pool_key);
 
- let ver = self.ver;
+ let set_host = self.set_host;
  let executor = self.executor.clone();
  conn.and_then(move |mut pooled| {
- if ver == Ver::Http1 {
- // CONNECT always sends origin-form, so check it first...
+ if pooled.is_http1() {
+ if set_host {
+ let uri = req.uri().clone();
+ req
+ .headers_mut()
+ .entry(HOST)
+ .expect("HOST is always valid header name")
+ .or_insert_with(|| {
+ let hostname = uri.host().expect("authority implies host");
+ if let Some(port) = uri.port() {
+ let s = format!("{}:{}", hostname, port);
+ HeaderValue::from_str(&s)
+ } else {
+ HeaderValue::from_str(hostname)
+ }.expect("uri host is valid header value")
+ });
+ }
+
+ // CONNECT always sends authority-form, so check it first...
  if req.method() == &Method::CONNECT {
  authority_form(req.uri_mut());
  } else if pooled.conn_info.is_proxied {
  absolute_form(req.uri_mut());
  } else {
  origin_form(req.uri_mut());
  };
- } else {
- debug_assert!(
- req.method() != &Method::CONNECT,
- "Client should have returned Error for HTTP2 CONNECT"
- );
+ } else if req.method() == &Method::CONNECT {
+ debug!("client does not support CONNECT requests over HTTP2");
+ return Either::A(future::err(ClientError::Normal(::Error::new_user_unsupported_request_method())));
  }
 
  let fut = pooled.send_request_retryable(req)
@@ -322,10 +319,10 @@ where C: Connect + Sync + 'static,
  // To counteract this, we must check if our senders 'want' channel
  // has been closed after having tried to send. If so, error out...
  if pooled.is_closed() {
- return Either::A(fut);
+ return Either::B(Either::A(fut));
  }
 
- Either::B(fut
+ Either::B(Either::B(fut
  .and_then(move |mut res| {
  // If pooled is HTTP/2, we can toss this reference immediately.
  //
@@ -337,7 +334,7 @@ where C: Connect + Sync + 'static,
  // for a new request to start.
  //
  // It won't be ready if there is a body to stream.
- if ver == Ver::Http2 || !pooled.is_pool_enabled() || pooled.is_ready() {
+ if pooled.is_http2() || !pooled.is_pool_enabled() || pooled.is_ready() {
  drop(pooled);
  } else if !res.body().is_end_stream() {
  let (delayed_tx, delayed_rx) = oneshot::channel();
@@ -370,7 +367,7 @@ where C: Connect + Sync + 'static,
  }
  }
  Ok(res)
- }))
+ })))
  })
  }
 
@@ -463,8 +460,9 @@ where C: Connect + Sync + 'static,
  let pool = self.pool.clone();
  let h1_writev = self.h1_writev;
  let h1_title_case_headers = self.h1_title_case_headers;
+ let ver = self.ver;
+ let is_ver_h2 = self.ver == Ver::Http2;
  let connector = self.connector.clone();
- let ver = pool_key.1;
  let dst = Destination {
  uri,
  };
@@ -474,7 +472,7 @@ where C: Connect + Sync + 'static,
  // If the pool_key is for HTTP/2, and there is already a
  // connection being estabalished, then this can't take a
  // second lock. The "connect_to" future is Canceled.
- let connecting = match pool.connecting(&pool_key) {
+ let connecting = match pool.connecting(&pool_key, ver) {
  Some(lock) => lock,
  None => {
  let canceled = ::Error::new_canceled(Some("HTTP/2 connection in progress"));
@@ -484,11 +482,31 @@ where C: Connect + Sync + 'static,
  Either::A(connector.connect(dst)
  .map_err(::Error::new_connect)
  .and_then(move |(io, connected)| {
- conn::Builder::new()
+ // If ALPN is h2 and we aren't http2_only already,
+ // then we need to convert our pool checkout into
+ // a single HTTP2 one.
+ let connecting = if connected.alpn == Alpn::H2 && !is_ver_h2 {
+ match connecting.alpn_h2(&pool) {
+ Some(lock) => {
+ trace!("ALPN negotiated h2, updating pool");
+ lock
+ },
+ None => {
+ // Another connection has already upgraded,
+ // the pool checkout should finish up for us.
+ let canceled = ::Error::new_canceled(Some("ALPN upgraded to HTTP/2"));
+ return Either::B(future::err(canceled));
+ }
+ }
+ } else {
+ connecting
+ };
+ let is_h2 = is_ver_h2 || connected.alpn == Alpn::H2;
+ Either::A(conn::Builder::new()
  .exec(executor.clone())
  .h1_writev(h1_writev)
  .h1_title_case_headers(h1_title_case_headers)
- .http2_only(pool_key.1 == Ver::Http2)
+ .http2_only(is_h2)
  .handshake(io)
  .and_then(move |(tx, conn)| {
  let bg = executor.execute(conn.map_err(|e| {
@@ -509,12 +527,13 @@ where C: Connect + Sync + 'static,
  .map(move |tx| {
  pool.pooled(connecting, PoolClient {
  conn_info: connected,
- tx: match ver {
- Ver::Http1 => PoolTx::Http1(tx),
- Ver::Http2 => PoolTx::Http2(tx.into_http2()),
+ tx: if is_h2 {
+ PoolTx::Http2(tx.into_http2())
+ } else {
+ PoolTx::Http1(tx)
  },
  })
- })
+ }))
  }))
  })
  }
@@ -591,6 +610,17 @@ impl<B> PoolClient<B> {
  }
  }
 
+ fn is_http1(&self) -> bool {
+ !self.is_http2()
+ }
+
+ fn is_http2(&self) -> bool {
+ match self.tx {
+ PoolTx::Http1(_) => false,
+ PoolTx::Http2(_) => true,
+ }
+ }
+
  fn is_ready(&self) -> bool {
  match self.tx {
  PoolTx::Http1(ref tx) => tx.is_ready(),
@@ -650,6 +680,10 @@ where
  }
  }
  }
+
+ fn can_share(&self) -> bool {
+ self.is_http2()
+ }
 }
 
 // FIXME: allow() required due to `impl Trait` leaking types to this lint