summaryrefslogtreecommitdiff
path: root/vendor/hyper/src/client
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/hyper/src/client')
-rw-r--r--vendor/hyper/src/client/conn/http1.rs611
-rw-r--r--vendor/hyper/src/client/conn/http2.rs718
-rw-r--r--vendor/hyper/src/client/conn/mod.rs22
-rw-r--r--vendor/hyper/src/client/dispatch.rs510
-rw-r--r--vendor/hyper/src/client/mod.rs22
-rw-r--r--vendor/hyper/src/client/tests.rs261
6 files changed, 2144 insertions, 0 deletions
diff --git a/vendor/hyper/src/client/conn/http1.rs b/vendor/hyper/src/client/conn/http1.rs
new file mode 100644
index 00000000..ecfe6eb8
--- /dev/null
+++ b/vendor/hyper/src/client/conn/http1.rs
@@ -0,0 +1,611 @@
+//! HTTP/1 client connections
+
+use std::error::Error as StdError;
+use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::rt::{Read, Write};
+use bytes::Bytes;
+use futures_util::ready;
+use http::{Request, Response};
+use httparse::ParserConfig;
+
+use super::super::dispatch::{self, TrySendError};
+use crate::body::{Body, Incoming as IncomingBody};
+use crate::proto;
+
+type Dispatcher<T, B> =
+ proto::dispatch::Dispatcher<proto::dispatch::Client<B>, B, T, proto::h1::ClientTransaction>;
+
+/// The sender side of an established connection.
+pub struct SendRequest<B> {
+ dispatch: dispatch::Sender<Request<B>, Response<IncomingBody>>,
+}
+
+/// Deconstructed parts of a `Connection`.
+///
+/// This allows taking apart a `Connection` at a later time, in order to
+/// reclaim the IO object, and additional related pieces.
+#[derive(Debug)]
+#[non_exhaustive]
+pub struct Parts<T> {
+ /// The original IO object used in the handshake.
+ pub io: T,
+ /// A buffer of bytes that have been read but not processed as HTTP.
+ ///
+ /// For instance, if the `Connection` is used for an HTTP upgrade request,
+ /// it is possible the server sent back the first bytes of the new protocol
+ /// along with the response upgrade.
+ ///
+ /// You will want to check for any existing bytes if you plan to continue
+ /// communicating on the IO object.
+ pub read_buf: Bytes,
+}
+
+/// A future that processes all HTTP state for the IO object.
+///
+/// In most cases, this should just be spawned into an executor, so that it
+/// can process incoming and outgoing messages, notice hangups, and the like.
+///
+/// Instances of this type are typically created via the [`handshake`] function
+#[must_use = "futures do nothing unless polled"]
+pub struct Connection<T, B>
+where
+ T: Read + Write,
+ B: Body + 'static,
+{
+ inner: Dispatcher<T, B>,
+}
+
+impl<T, B> Connection<T, B>
+where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+ /// Return the inner IO object, and additional information.
+ ///
+ /// Only works for HTTP/1 connections. HTTP/2 connections will panic.
+ pub fn into_parts(self) -> Parts<T> {
+ let (io, read_buf, _) = self.inner.into_inner();
+ Parts { io, read_buf }
+ }
+
+ /// Poll the connection for completion, but without calling `shutdown`
+ /// on the underlying IO.
+ ///
+ /// This is useful to allow running a connection while doing an HTTP
+ /// upgrade. Once the upgrade is completed, the connection would be "done",
+ /// but it is not desired to actually shutdown the IO object. Instead you
+ /// would take it back using `into_parts`.
+ ///
+ /// Use [`poll_fn`](https://docs.rs/futures/0.1.25/futures/future/fn.poll_fn.html)
+ /// and [`try_ready!`](https://docs.rs/futures/0.1.25/futures/macro.try_ready.html)
+ /// to work with this function; or use the `without_shutdown` wrapper.
+ pub fn poll_without_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
+ self.inner.poll_without_shutdown(cx)
+ }
+
+ /// Prevent shutdown of the underlying IO object at the end of service the request,
+ /// instead run `into_parts`. This is a convenience wrapper over `poll_without_shutdown`.
+ pub async fn without_shutdown(self) -> crate::Result<Parts<T>> {
+ let mut conn = Some(self);
+ futures_util::future::poll_fn(move |cx| -> Poll<crate::Result<Parts<T>>> {
+ ready!(conn.as_mut().unwrap().poll_without_shutdown(cx))?;
+ Poll::Ready(Ok(conn.take().unwrap().into_parts()))
+ })
+ .await
+ }
+}
+
+/// A builder to configure an HTTP connection.
+///
+/// After setting options, the builder is used to create a handshake future.
+///
+/// **Note**: The default values of options are *not considered stable*. They
+/// are subject to change at any time.
+#[derive(Clone, Debug)]
+pub struct Builder {
+ h09_responses: bool,
+ h1_parser_config: ParserConfig,
+ h1_writev: Option<bool>,
+ h1_title_case_headers: bool,
+ h1_preserve_header_case: bool,
+ h1_max_headers: Option<usize>,
+ #[cfg(feature = "ffi")]
+ h1_preserve_header_order: bool,
+ h1_read_buf_exact_size: Option<usize>,
+ h1_max_buf_size: Option<usize>,
+}
+
+/// Returns a handshake future over some IO.
+///
+/// This is a shortcut for `Builder::new().handshake(io)`.
+/// See [`client::conn`](crate::client::conn) for more.
+pub async fn handshake<T, B>(io: T) -> crate::Result<(SendRequest<B>, Connection<T, B>)>
+where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+ Builder::new().handshake(io).await
+}
+
+// ===== impl SendRequest
+
+impl<B> SendRequest<B> {
+ /// Polls to determine whether this sender can be used yet for a request.
+ ///
+ /// If the associated connection is closed, this returns an Error.
+ pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
+ self.dispatch.poll_ready(cx)
+ }
+
+ /// Waits until the dispatcher is ready
+ ///
+ /// If the associated connection is closed, this returns an Error.
+ pub async fn ready(&mut self) -> crate::Result<()> {
+ futures_util::future::poll_fn(|cx| self.poll_ready(cx)).await
+ }
+
+ /// Checks if the connection is currently ready to send a request.
+ ///
+ /// # Note
+ ///
+ /// This is mostly a hint. Due to inherent latency of networks, it is
+ /// possible that even after checking this is ready, sending a request
+ /// may still fail because the connection was closed in the meantime.
+ pub fn is_ready(&self) -> bool {
+ self.dispatch.is_ready()
+ }
+
+ /// Checks if the connection side has been closed.
+ pub fn is_closed(&self) -> bool {
+ self.dispatch.is_closed()
+ }
+}
+
+impl<B> SendRequest<B>
+where
+ B: Body + 'static,
+{
+ /// Sends a `Request` on the associated connection.
+ ///
+ /// Returns a future that if successful, yields the `Response`.
+ ///
+ /// `req` must have a `Host` header.
+ ///
+ /// # Uri
+ ///
+ /// The `Uri` of the request is serialized as-is.
+ ///
+ /// - Usually you want origin-form (`/path?query`).
+ /// - For sending to an HTTP proxy, you want to send in absolute-form
+ /// (`https://hyper.rs/guides`).
+ ///
+ /// This is however not enforced or validated and it is up to the user
+ /// of this method to ensure the `Uri` is correct for their intended purpose.
+ pub fn send_request(
+ &mut self,
+ req: Request<B>,
+ ) -> impl Future<Output = crate::Result<Response<IncomingBody>>> {
+ let sent = self.dispatch.send(req);
+
+ async move {
+ match sent {
+ Ok(rx) => match rx.await {
+ Ok(Ok(resp)) => Ok(resp),
+ Ok(Err(err)) => Err(err),
+ // this is definite bug if it happens, but it shouldn't happen!
+ Err(_canceled) => panic!("dispatch dropped without returning error"),
+ },
+ Err(_req) => {
+ debug!("connection was not ready");
+ Err(crate::Error::new_canceled().with("connection was not ready"))
+ }
+ }
+ }
+ }
+
+ /// Sends a `Request` on the associated connection.
+ ///
+ /// Returns a future that if successful, yields the `Response`.
+ ///
+ /// # Error
+ ///
+ /// If there was an error before trying to serialize the request to the
+ /// connection, the message will be returned as part of this error.
+ pub fn try_send_request(
+ &mut self,
+ req: Request<B>,
+ ) -> impl Future<Output = Result<Response<IncomingBody>, TrySendError<Request<B>>>> {
+ let sent = self.dispatch.try_send(req);
+ async move {
+ match sent {
+ Ok(rx) => match rx.await {
+ Ok(Ok(res)) => Ok(res),
+ Ok(Err(err)) => Err(err),
+ // this is definite bug if it happens, but it shouldn't happen!
+ Err(_) => panic!("dispatch dropped without returning error"),
+ },
+ Err(req) => {
+ debug!("connection was not ready");
+ let error = crate::Error::new_canceled().with("connection was not ready");
+ Err(TrySendError {
+ error,
+ message: Some(req),
+ })
+ }
+ }
+ }
+ }
+}
+
+impl<B> fmt::Debug for SendRequest<B> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("SendRequest").finish()
+ }
+}
+
+// ===== impl Connection
+
+impl<T, B> Connection<T, B>
+where
+ T: Read + Write + Unpin + Send,
+ B: Body + 'static,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+ /// Enable this connection to support higher-level HTTP upgrades.
+ ///
+ /// See [the `upgrade` module](crate::upgrade) for more.
+ pub fn with_upgrades(self) -> upgrades::UpgradeableConnection<T, B> {
+ upgrades::UpgradeableConnection { inner: Some(self) }
+ }
+}
+
+impl<T, B> fmt::Debug for Connection<T, B>
+where
+ T: Read + Write + fmt::Debug,
+ B: Body + 'static,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Connection").finish()
+ }
+}
+
+impl<T, B> Future for Connection<T, B>
+where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+ type Output = crate::Result<()>;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ match ready!(Pin::new(&mut self.inner).poll(cx))? {
+ proto::Dispatched::Shutdown => Poll::Ready(Ok(())),
+ proto::Dispatched::Upgrade(pending) => {
+ // With no `Send` bound on `I`, we can't try to do
+ // upgrades here. In case a user was trying to use
+ // `upgrade` with this API, send a special
+ // error letting them know about that.
+ pending.manual();
+ Poll::Ready(Ok(()))
+ }
+ }
+ }
+}
+
+// ===== impl Builder
+
+impl Builder {
+ /// Creates a new connection builder.
+ #[inline]
+ pub fn new() -> Builder {
+ Builder {
+ h09_responses: false,
+ h1_writev: None,
+ h1_read_buf_exact_size: None,
+ h1_parser_config: Default::default(),
+ h1_title_case_headers: false,
+ h1_preserve_header_case: false,
+ h1_max_headers: None,
+ #[cfg(feature = "ffi")]
+ h1_preserve_header_order: false,
+ h1_max_buf_size: None,
+ }
+ }
+
+ /// Set whether HTTP/0.9 responses should be tolerated.
+ ///
+ /// Default is false.
+ pub fn http09_responses(&mut self, enabled: bool) -> &mut Builder {
+ self.h09_responses = enabled;
+ self
+ }
+
+ /// Set whether HTTP/1 connections will accept spaces between header names
+ /// and the colon that follow them in responses.
+ ///
+ /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+ /// to say about it:
+ ///
+ /// > No whitespace is allowed between the header field-name and colon. In
+ /// > the past, differences in the handling of such whitespace have led to
+ /// > security vulnerabilities in request routing and response handling. A
+ /// > server MUST reject any received request message that contains
+ /// > whitespace between a header field-name and colon with a response code
+ /// > of 400 (Bad Request). A proxy MUST remove any such whitespace from a
+ /// > response message before forwarding the message downstream.
+ ///
+ /// Default is false.
+ ///
+ /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+ pub fn allow_spaces_after_header_name_in_responses(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_parser_config
+ .allow_spaces_after_header_name_in_responses(enabled);
+ self
+ }
+
+ /// Set whether HTTP/1 connections will accept obsolete line folding for
+ /// header values.
+ ///
+ /// Newline codepoints (`\r` and `\n`) will be transformed to spaces when
+ /// parsing.
+ ///
+ /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+ /// to say about it:
+ ///
+ /// > A server that receives an obs-fold in a request message that is not
+ /// > within a message/http container MUST either reject the message by
+ /// > sending a 400 (Bad Request), preferably with a representation
+ /// > explaining that obsolete line folding is unacceptable, or replace
+ /// > each received obs-fold with one or more SP octets prior to
+ /// > interpreting the field value or forwarding the message downstream.
+ ///
+ /// > A proxy or gateway that receives an obs-fold in a response message
+ /// > that is not within a message/http container MUST either discard the
+ /// > message and replace it with a 502 (Bad Gateway) response, preferably
+ /// > with a representation explaining that unacceptable line folding was
+ /// > received, or replace each received obs-fold with one or more SP
+ /// > octets prior to interpreting the field value or forwarding the
+ /// > message downstream.
+ ///
+ /// > A user agent that receives an obs-fold in a response message that is
+ /// > not within a message/http container MUST replace each received
+ /// > obs-fold with one or more SP octets prior to interpreting the field
+ /// > value.
+ ///
+ /// Default is false.
+ ///
+ /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+ pub fn allow_obsolete_multiline_headers_in_responses(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_parser_config
+ .allow_obsolete_multiline_headers_in_responses(enabled);
+ self
+ }
+
+ /// Set whether HTTP/1 connections will silently ignored malformed header lines.
+ ///
+ /// If this is enabled and a header line does not start with a valid header
+ /// name, or does not include a colon at all, the line will be silently ignored
+ /// and no error will be reported.
+ ///
+ /// Default is false.
+ pub fn ignore_invalid_headers_in_responses(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_parser_config
+ .ignore_invalid_headers_in_responses(enabled);
+ self
+ }
+
+ /// Set whether HTTP/1 connections should try to use vectored writes,
+ /// or always flatten into a single buffer.
+ ///
+ /// Note that setting this to false may mean more copies of body data,
+ /// but may also improve performance when an IO transport doesn't
+ /// support vectored writes well, such as most TLS implementations.
+ ///
+ /// Setting this to true will force hyper to use queued strategy
+ /// which may eliminate unnecessary cloning on some TLS backends
+ ///
+ /// Default is `auto`. In this mode hyper will try to guess which
+ /// mode to use
+ pub fn writev(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_writev = Some(enabled);
+ self
+ }
+
+ /// Set whether HTTP/1 connections will write header names as title case at
+ /// the socket level.
+ ///
+ /// Default is false.
+ pub fn title_case_headers(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_title_case_headers = enabled;
+ self
+ }
+
+ /// Set whether to support preserving original header cases.
+ ///
+ /// Currently, this will record the original cases received, and store them
+ /// in a private extension on the `Response`. It will also look for and use
+ /// such an extension in any provided `Request`.
+ ///
+ /// Since the relevant extension is still private, there is no way to
+ /// interact with the original cases. The only effect this can have now is
+ /// to forward the cases in a proxy-like fashion.
+ ///
+ /// Default is false.
+ pub fn preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_preserve_header_case = enabled;
+ self
+ }
+
+ /// Set the maximum number of headers.
+ ///
+ /// When a response is received, the parser will reserve a buffer to store headers for optimal
+ /// performance.
+ ///
+ /// If client receives more headers than the buffer size, the error "message header too large"
+ /// is returned.
+ ///
+ /// Note that headers is allocated on the stack by default, which has higher performance. After
+ /// setting this value, headers will be allocated in heap memory, that is, heap memory
+ /// allocation will occur for each response, and there will be a performance drop of about 5%.
+ ///
+ /// Default is 100.
+ pub fn max_headers(&mut self, val: usize) -> &mut Self {
+ self.h1_max_headers = Some(val);
+ self
+ }
+
+ /// Set whether to support preserving original header order.
+ ///
+ /// Currently, this will record the order in which headers are received, and store this
+ /// ordering in a private extension on the `Response`. It will also look for and use
+ /// such an extension in any provided `Request`.
+ ///
+ /// Default is false.
+ #[cfg(feature = "ffi")]
+ pub fn preserve_header_order(&mut self, enabled: bool) -> &mut Builder {
+ self.h1_preserve_header_order = enabled;
+ self
+ }
+
+ /// Sets the exact size of the read buffer to *always* use.
+ ///
+ /// Note that setting this option unsets the `max_buf_size` option.
+ ///
+ /// Default is an adaptive read buffer.
+ pub fn read_buf_exact_size(&mut self, sz: Option<usize>) -> &mut Builder {
+ self.h1_read_buf_exact_size = sz;
+ self.h1_max_buf_size = None;
+ self
+ }
+
+ /// Set the maximum buffer size for the connection.
+ ///
+ /// Default is ~400kb.
+ ///
+ /// Note that setting this option unsets the `read_exact_buf_size` option.
+ ///
+ /// # Panics
+ ///
+ /// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum.
+ pub fn max_buf_size(&mut self, max: usize) -> &mut Self {
+ assert!(
+ max >= proto::h1::MINIMUM_MAX_BUFFER_SIZE,
+ "the max_buf_size cannot be smaller than the minimum that h1 specifies."
+ );
+
+ self.h1_max_buf_size = Some(max);
+ self.h1_read_buf_exact_size = None;
+ self
+ }
+
+ /// Constructs a connection with the configured options and IO.
+ /// See [`client::conn`](crate::client::conn) for more.
+ ///
+ /// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will
+ /// do nothing.
+ pub fn handshake<T, B>(
+ &self,
+ io: T,
+ ) -> impl Future<Output = crate::Result<(SendRequest<B>, Connection<T, B>)>>
+ where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+ {
+ let opts = self.clone();
+
+ async move {
+ trace!("client handshake HTTP/1");
+
+ let (tx, rx) = dispatch::channel();
+ let mut conn = proto::Conn::new(io);
+ conn.set_h1_parser_config(opts.h1_parser_config);
+ if let Some(writev) = opts.h1_writev {
+ if writev {
+ conn.set_write_strategy_queue();
+ } else {
+ conn.set_write_strategy_flatten();
+ }
+ }
+ if opts.h1_title_case_headers {
+ conn.set_title_case_headers();
+ }
+ if opts.h1_preserve_header_case {
+ conn.set_preserve_header_case();
+ }
+ if let Some(max_headers) = opts.h1_max_headers {
+ conn.set_http1_max_headers(max_headers);
+ }
+ #[cfg(feature = "ffi")]
+ if opts.h1_preserve_header_order {
+ conn.set_preserve_header_order();
+ }
+
+ if opts.h09_responses {
+ conn.set_h09_responses();
+ }
+
+ if let Some(sz) = opts.h1_read_buf_exact_size {
+ conn.set_read_buf_exact_size(sz);
+ }
+ if let Some(max) = opts.h1_max_buf_size {
+ conn.set_max_buf_size(max);
+ }
+ let cd = proto::h1::dispatch::Client::new(rx);
+ let proto = proto::h1::Dispatcher::new(cd, conn);
+
+ Ok((SendRequest { dispatch: tx }, Connection { inner: proto }))
+ }
+ }
+}
+
+mod upgrades {
+ use crate::upgrade::Upgraded;
+
+ use super::*;
+
+ // A future binding a connection with a Service with Upgrade support.
+ //
+ // This type is unnameable outside the crate.
+ #[must_use = "futures do nothing unless polled"]
+ #[allow(missing_debug_implementations)]
+ pub struct UpgradeableConnection<T, B>
+ where
+ T: Read + Write + Unpin + Send + 'static,
+ B: Body + 'static,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+ {
+ pub(super) inner: Option<Connection<T, B>>,
+ }
+
+ impl<I, B> Future for UpgradeableConnection<I, B>
+ where
+ I: Read + Write + Unpin + Send + 'static,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn StdError + Send + Sync>>,
+ {
+ type Output = crate::Result<()>;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ match ready!(Pin::new(&mut self.inner.as_mut().unwrap().inner).poll(cx)) {
+ Ok(proto::Dispatched::Shutdown) => Poll::Ready(Ok(())),
+ Ok(proto::Dispatched::Upgrade(pending)) => {
+ let Parts { io, read_buf } = self.inner.take().unwrap().into_parts();
+ pending.fulfill(Upgraded::new(io, read_buf));
+ Poll::Ready(Ok(()))
+ }
+ Err(e) => Poll::Ready(Err(e)),
+ }
+ }
+ }
+}
diff --git a/vendor/hyper/src/client/conn/http2.rs b/vendor/hyper/src/client/conn/http2.rs
new file mode 100644
index 00000000..3db28957
--- /dev/null
+++ b/vendor/hyper/src/client/conn/http2.rs
@@ -0,0 +1,718 @@
+//! HTTP/2 client connections
+
+use std::error::Error;
+use std::fmt;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use std::time::Duration;
+
+use crate::rt::{Read, Write};
+use futures_util::ready;
+use http::{Request, Response};
+
+use super::super::dispatch::{self, TrySendError};
+use crate::body::{Body, Incoming as IncomingBody};
+use crate::common::time::Time;
+use crate::proto;
+use crate::rt::bounds::Http2ClientConnExec;
+use crate::rt::Timer;
+
+/// The sender side of an established connection.
+pub struct SendRequest<B> {
+ dispatch: dispatch::UnboundedSender<Request<B>, Response<IncomingBody>>,
+}
+
+impl<B> Clone for SendRequest<B> {
+ fn clone(&self) -> SendRequest<B> {
+ SendRequest {
+ dispatch: self.dispatch.clone(),
+ }
+ }
+}
+
+/// A future that processes all HTTP state for the IO object.
+///
+/// In most cases, this should just be spawned into an executor, so that it
+/// can process incoming and outgoing messages, notice hangups, and the like.
+///
+/// Instances of this type are typically created via the [`handshake`] function
+#[must_use = "futures do nothing unless polled"]
+pub struct Connection<T, B, E>
+where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ E: Http2ClientConnExec<B, T> + Unpin,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+{
+ inner: (PhantomData<T>, proto::h2::ClientTask<B, E, T>),
+}
+
+/// A builder to configure an HTTP connection.
+///
+/// After setting options, the builder is used to create a handshake future.
+///
+/// **Note**: The default values of options are *not considered stable*. They
+/// are subject to change at any time.
+#[derive(Clone, Debug)]
+pub struct Builder<Ex> {
+ pub(super) exec: Ex,
+ pub(super) timer: Time,
+ h2_builder: proto::h2::client::Config,
+}
+
+/// Returns a handshake future over some IO.
+///
+/// This is a shortcut for `Builder::new(exec).handshake(io)`.
+/// See [`client::conn`](crate::client::conn) for more.
+pub async fn handshake<E, T, B>(
+ exec: E,
+ io: T,
+) -> crate::Result<(SendRequest<B>, Connection<T, B, E>)>
+where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+ E: Http2ClientConnExec<B, T> + Unpin + Clone,
+{
+ Builder::new(exec).handshake(io).await
+}
+
+// ===== impl SendRequest
+
+impl<B> SendRequest<B> {
+ /// Polls to determine whether this sender can be used yet for a request.
+ ///
+ /// If the associated connection is closed, this returns an Error.
+ pub fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
+ if self.is_closed() {
+ Poll::Ready(Err(crate::Error::new_closed()))
+ } else {
+ Poll::Ready(Ok(()))
+ }
+ }
+
+ /// Waits until the dispatcher is ready
+ ///
+ /// If the associated connection is closed, this returns an Error.
+ pub async fn ready(&mut self) -> crate::Result<()> {
+ futures_util::future::poll_fn(|cx| self.poll_ready(cx)).await
+ }
+
+ /// Checks if the connection is currently ready to send a request.
+ ///
+ /// # Note
+ ///
+ /// This is mostly a hint. Due to inherent latency of networks, it is
+ /// possible that even after checking this is ready, sending a request
+ /// may still fail because the connection was closed in the meantime.
+ pub fn is_ready(&self) -> bool {
+ self.dispatch.is_ready()
+ }
+
+ /// Checks if the connection side has been closed.
+ pub fn is_closed(&self) -> bool {
+ self.dispatch.is_closed()
+ }
+}
+
+impl<B> SendRequest<B>
+where
+ B: Body + 'static,
+{
+ /// Sends a `Request` on the associated connection.
+ ///
+ /// Returns a future that if successful, yields the `Response`.
+ ///
+ /// `req` must have a `Host` header.
+ ///
+ /// Absolute-form `Uri`s are not required. If received, they will be serialized
+ /// as-is.
+ pub fn send_request(
+ &mut self,
+ req: Request<B>,
+ ) -> impl Future<Output = crate::Result<Response<IncomingBody>>> {
+ let sent = self.dispatch.send(req);
+
+ async move {
+ match sent {
+ Ok(rx) => match rx.await {
+ Ok(Ok(resp)) => Ok(resp),
+ Ok(Err(err)) => Err(err),
+ // this is definite bug if it happens, but it shouldn't happen!
+ Err(_canceled) => panic!("dispatch dropped without returning error"),
+ },
+ Err(_req) => {
+ debug!("connection was not ready");
+
+ Err(crate::Error::new_canceled().with("connection was not ready"))
+ }
+ }
+ }
+ }
+
+ /// Sends a `Request` on the associated connection.
+ ///
+ /// Returns a future that if successful, yields the `Response`.
+ ///
+ /// # Error
+ ///
+ /// If there was an error before trying to serialize the request to the
+ /// connection, the message will be returned as part of this error.
+ pub fn try_send_request(
+ &mut self,
+ req: Request<B>,
+ ) -> impl Future<Output = Result<Response<IncomingBody>, TrySendError<Request<B>>>> {
+ let sent = self.dispatch.try_send(req);
+ async move {
+ match sent {
+ Ok(rx) => match rx.await {
+ Ok(Ok(res)) => Ok(res),
+ Ok(Err(err)) => Err(err),
+ // this is definite bug if it happens, but it shouldn't happen!
+ Err(_) => panic!("dispatch dropped without returning error"),
+ },
+ Err(req) => {
+ debug!("connection was not ready");
+ let error = crate::Error::new_canceled().with("connection was not ready");
+ Err(TrySendError {
+ error,
+ message: Some(req),
+ })
+ }
+ }
+ }
+ }
+}
+
+impl<B> fmt::Debug for SendRequest<B> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("SendRequest").finish()
+ }
+}
+
+// ===== impl Connection
+
+impl<T, B, E> Connection<T, B, E>
+where
+ T: Read + Write + Unpin + 'static,
+ B: Body + Unpin + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+ E: Http2ClientConnExec<B, T> + Unpin,
+{
+ /// Returns whether the [extended CONNECT protocol][1] is enabled or not.
+ ///
+ /// This setting is configured by the server peer by sending the
+ /// [`SETTINGS_ENABLE_CONNECT_PROTOCOL` parameter][2] in a `SETTINGS` frame.
+ /// This method returns the currently acknowledged value received from the
+ /// remote.
+ ///
+ /// [1]: https://datatracker.ietf.org/doc/html/rfc8441#section-4
+ /// [2]: https://datatracker.ietf.org/doc/html/rfc8441#section-3
+ pub fn is_extended_connect_protocol_enabled(&self) -> bool {
+ self.inner.1.is_extended_connect_protocol_enabled()
+ }
+}
+
+impl<T, B, E> fmt::Debug for Connection<T, B, E>
+where
+ T: Read + Write + fmt::Debug + 'static + Unpin,
+ B: Body + 'static,
+ E: Http2ClientConnExec<B, T> + Unpin,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Connection").finish()
+ }
+}
+
+impl<T, B, E> Future for Connection<T, B, E>
+where
+ T: Read + Write + Unpin + 'static,
+ B: Body + 'static + Unpin,
+ B::Data: Send,
+ E: Unpin,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+ E: Http2ClientConnExec<B, T> + Unpin,
+{
+ type Output = crate::Result<()>;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ match ready!(Pin::new(&mut self.inner.1).poll(cx))? {
+ proto::Dispatched::Shutdown => Poll::Ready(Ok(())),
+ #[cfg(feature = "http1")]
+ proto::Dispatched::Upgrade(_pending) => unreachable!("http2 cannot upgrade"),
+ }
+ }
+}
+
+// ===== impl Builder
+
+impl<Ex> Builder<Ex>
+where
+ Ex: Clone,
+{
+ /// Creates a new connection builder.
+ #[inline]
+ pub fn new(exec: Ex) -> Builder<Ex> {
+ Builder {
+ exec,
+ timer: Time::Empty,
+ h2_builder: Default::default(),
+ }
+ }
+
+ /// Provide a timer to execute background HTTP2 tasks.
+ pub fn timer<M>(&mut self, timer: M) -> &mut Builder<Ex>
+ where
+ M: Timer + Send + Sync + 'static,
+ {
+ self.timer = Time::Timer(Arc::new(timer));
+ self
+ }
+
+ /// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
+ /// stream-level flow control.
+ ///
+ /// Passing `None` will do nothing.
+ ///
+ /// If not set, hyper will use a default.
+ ///
+ /// [spec]: https://httpwg.org/specs/rfc9113.html#SETTINGS_INITIAL_WINDOW_SIZE
+ pub fn initial_stream_window_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
+ if let Some(sz) = sz.into() {
+ self.h2_builder.adaptive_window = false;
+ self.h2_builder.initial_stream_window_size = sz;
+ }
+ self
+ }
+
+ /// Sets the max connection-level flow control for HTTP2
+ ///
+ /// Passing `None` will do nothing.
+ ///
+ /// If not set, hyper will use a default.
+ pub fn initial_connection_window_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
+ if let Some(sz) = sz.into() {
+ self.h2_builder.adaptive_window = false;
+ self.h2_builder.initial_conn_window_size = sz;
+ }
+ self
+ }
+
+ /// Sets the initial maximum of locally initiated (send) streams.
+ ///
+ /// This value will be overwritten by the value included in the initial
+ /// SETTINGS frame received from the peer as part of a [connection preface].
+ ///
+ /// Passing `None` will do nothing.
+ ///
+ /// If not set, hyper will use a default.
+ ///
+ /// [connection preface]: https://httpwg.org/specs/rfc9113.html#preface
+ pub fn initial_max_send_streams(&mut self, initial: impl Into<Option<usize>>) -> &mut Self {
+ if let Some(initial) = initial.into() {
+ self.h2_builder.initial_max_send_streams = initial;
+ }
+ self
+ }
+
+ /// Sets whether to use an adaptive flow control.
+ ///
+ /// Enabling this will override the limits set in
+ /// `initial_stream_window_size` and
+ /// `initial_connection_window_size`.
+ pub fn adaptive_window(&mut self, enabled: bool) -> &mut Self {
+ use proto::h2::SPEC_WINDOW_SIZE;
+
+ self.h2_builder.adaptive_window = enabled;
+ if enabled {
+ self.h2_builder.initial_conn_window_size = SPEC_WINDOW_SIZE;
+ self.h2_builder.initial_stream_window_size = SPEC_WINDOW_SIZE;
+ }
+ self
+ }
+
+ /// Sets the maximum frame size to use for HTTP2.
+ ///
+ /// Default is currently 16KB, but can change.
+ pub fn max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
+ self.h2_builder.max_frame_size = sz.into();
+ self
+ }
+
+ /// Sets the max size of received header frames.
+ ///
+ /// Default is currently 16KB, but can change.
+ pub fn max_header_list_size(&mut self, max: u32) -> &mut Self {
+ self.h2_builder.max_header_list_size = max;
+ self
+ }
+
+ /// Sets the header table size.
+ ///
+ /// This setting informs the peer of the maximum size of the header compression
+ /// table used to encode header blocks, in octets. The encoder may select any value
+ /// equal to or less than the header table size specified by the sender.
+ ///
+ /// The default value of crate `h2` is 4,096.
+ pub fn header_table_size(&mut self, size: impl Into<Option<u32>>) -> &mut Self {
+ self.h2_builder.header_table_size = size.into();
+ self
+ }
+
+ /// Sets the maximum number of concurrent streams.
+ ///
+ /// The maximum concurrent streams setting only controls the maximum number
+ /// of streams that can be initiated by the remote peer. In other words,
+ /// when this setting is set to 100, this does not limit the number of
+ /// concurrent streams that can be created by the caller.
+ ///
+ /// It is recommended that this value be no smaller than 100, so as to not
+ /// unnecessarily limit parallelism. However, any value is legal, including
+ /// 0. If `max` is set to 0, then the remote will not be permitted to
+ /// initiate streams.
+ ///
+ /// Note that streams in the reserved state, i.e., push promises that have
+ /// been reserved but the stream has not started, do not count against this
+ /// setting.
+ ///
+ /// Also note that if the remote *does* exceed the value set here, it is not
+ /// a protocol level error. Instead, the `h2` library will immediately reset
+ /// the stream.
+ ///
+ /// See [Section 5.1.2] in the HTTP/2 spec for more details.
+ ///
+ /// [Section 5.1.2]: https://http2.github.io/http2-spec/#rfc.section.5.1.2
+ pub fn max_concurrent_streams(&mut self, max: impl Into<Option<u32>>) -> &mut Self {
+ self.h2_builder.max_concurrent_streams = max.into();
+ self
+ }
+
+ /// Sets an interval for HTTP2 Ping frames should be sent to keep a
+ /// connection alive.
+ ///
+ /// Pass `None` to disable HTTP2 keep-alive.
+ ///
+ /// Default is currently disabled.
+ pub fn keep_alive_interval(&mut self, interval: impl Into<Option<Duration>>) -> &mut Self {
+ self.h2_builder.keep_alive_interval = interval.into();
+ self
+ }
+
+ /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
+ ///
+ /// If the ping is not acknowledged within the timeout, the connection will
+ /// be closed. Does nothing if `keep_alive_interval` is disabled.
+ ///
+ /// Default is 20 seconds.
+ pub fn keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
+ self.h2_builder.keep_alive_timeout = timeout;
+ self
+ }
+
+ /// Sets whether HTTP2 keep-alive should apply while the connection is idle.
+ ///
+ /// If disabled, keep-alive pings are only sent while there are open
+ /// request/responses streams. If enabled, pings are also sent when no
+ /// streams are active. Does nothing if `keep_alive_interval` is
+ /// disabled.
+ ///
+ /// Default is `false`.
+ pub fn keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
+ self.h2_builder.keep_alive_while_idle = enabled;
+ self
+ }
+
+ /// Sets the maximum number of HTTP2 concurrent locally reset streams.
+ ///
+ /// See the documentation of [`h2::client::Builder::max_concurrent_reset_streams`] for more
+ /// details.
+ ///
+ /// The default value is determined by the `h2` crate.
+ ///
+ /// [`h2::client::Builder::max_concurrent_reset_streams`]: https://docs.rs/h2/client/struct.Builder.html#method.max_concurrent_reset_streams
+ pub fn max_concurrent_reset_streams(&mut self, max: usize) -> &mut Self {
+ self.h2_builder.max_concurrent_reset_streams = Some(max);
+ self
+ }
+
+ /// Set the maximum write buffer size for each HTTP/2 stream.
+ ///
+ /// Default is currently 1MB, but may change.
+ ///
+ /// # Panics
+ ///
+ /// The value must be no larger than `u32::MAX`.
+ pub fn max_send_buf_size(&mut self, max: usize) -> &mut Self {
+ assert!(max <= u32::MAX as usize);
+ self.h2_builder.max_send_buffer_size = max;
+ self
+ }
+
+ /// Configures the maximum number of pending reset streams allowed before a GOAWAY will be sent.
+ ///
+ /// This will default to the default value set by the [`h2` crate](https://crates.io/crates/h2).
+ /// As of v0.4.0, it is 20.
+ ///
+ /// See <https://github.com/hyperium/hyper/issues/2877> for more information.
+ pub fn max_pending_accept_reset_streams(&mut self, max: impl Into<Option<usize>>) -> &mut Self {
+ self.h2_builder.max_pending_accept_reset_streams = max.into();
+ self
+ }
+
+ /// Constructs a connection with the configured options and IO.
+ /// See [`client::conn`](crate::client::conn) for more.
+ ///
+ /// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will
+ /// do nothing.
+ pub fn handshake<T, B>(
+ &self,
+ io: T,
+ ) -> impl Future<Output = crate::Result<(SendRequest<B>, Connection<T, B, Ex>)>>
+ where
+ T: Read + Write + Unpin,
+ B: Body + 'static,
+ B::Data: Send,
+ B::Error: Into<Box<dyn Error + Send + Sync>>,
+ Ex: Http2ClientConnExec<B, T> + Unpin,
+ {
+ let opts = self.clone();
+
+ async move {
+ trace!("client handshake HTTP/2");
+
+ let (tx, rx) = dispatch::channel();
+ let h2 = proto::h2::client::handshake(io, rx, &opts.h2_builder, opts.exec, opts.timer)
+ .await?;
+ Ok((
+ SendRequest {
+ dispatch: tx.unbound(),
+ },
+ Connection {
+ inner: (PhantomData, h2),
+ },
+ ))
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn send_sync_executor_of_non_send_futures() {
+ #[derive(Clone)]
+ struct LocalTokioExecutor;
+
+ impl<F> crate::rt::Executor<F> for LocalTokioExecutor
+ where
+ F: std::future::Future + 'static, // not requiring `Send`
+ {
+ fn execute(&self, fut: F) {
+ // This will spawn into the currently running `LocalSet`.
+ tokio::task::spawn_local(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Unpin + 'static) {
+ let (_sender, conn) = crate::client::conn::http2::handshake::<
+ _,
+ _,
+ http_body_util::Empty<bytes::Bytes>,
+ >(LocalTokioExecutor, io)
+ .await
+ .unwrap();
+
+ tokio::task::spawn_local(async move {
+ conn.await.unwrap();
+ });
+ }
+ }
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn not_send_not_sync_executor_of_not_send_futures() {
+ #[derive(Clone)]
+ struct LocalTokioExecutor {
+ _x: std::marker::PhantomData<std::rc::Rc<()>>,
+ }
+
+ impl<F> crate::rt::Executor<F> for LocalTokioExecutor
+ where
+ F: std::future::Future + 'static, // not requiring `Send`
+ {
+ fn execute(&self, fut: F) {
+ // This will spawn into the currently running `LocalSet`.
+ tokio::task::spawn_local(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Unpin + 'static) {
+ let (_sender, conn) =
+ crate::client::conn::http2::handshake::<_, _, http_body_util::Empty<bytes::Bytes>>(
+ LocalTokioExecutor {
+ _x: Default::default(),
+ },
+ io,
+ )
+ .await
+ .unwrap();
+
+ tokio::task::spawn_local(async move {
+ conn.await.unwrap();
+ });
+ }
+ }
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn send_not_sync_executor_of_not_send_futures() {
+ #[derive(Clone)]
+ struct LocalTokioExecutor {
+ _x: std::marker::PhantomData<std::cell::Cell<()>>,
+ }
+
+ impl<F> crate::rt::Executor<F> for LocalTokioExecutor
+ where
+ F: std::future::Future + 'static, // not requiring `Send`
+ {
+ fn execute(&self, fut: F) {
+ // This will spawn into the currently running `LocalSet`.
+ tokio::task::spawn_local(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Unpin + 'static) {
+ let (_sender, conn) =
+ crate::client::conn::http2::handshake::<_, _, http_body_util::Empty<bytes::Bytes>>(
+ LocalTokioExecutor {
+ _x: Default::default(),
+ },
+ io,
+ )
+ .await
+ .unwrap();
+
+ tokio::task::spawn_local(async move {
+ conn.await.unwrap();
+ });
+ }
+ }
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn send_sync_executor_of_send_futures() {
+ #[derive(Clone)]
+ struct TokioExecutor;
+
+ impl<F> crate::rt::Executor<F> for TokioExecutor
+ where
+ F: std::future::Future + 'static + Send,
+ F::Output: Send + 'static,
+ {
+ fn execute(&self, fut: F) {
+ tokio::task::spawn(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Send + Unpin + 'static) {
+ let (_sender, conn) = crate::client::conn::http2::handshake::<
+ _,
+ _,
+ http_body_util::Empty<bytes::Bytes>,
+ >(TokioExecutor, io)
+ .await
+ .unwrap();
+
+ tokio::task::spawn(async move {
+ conn.await.unwrap();
+ });
+ }
+ }
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn not_send_not_sync_executor_of_send_futures() {
+ #[derive(Clone)]
+ struct TokioExecutor {
+ // !Send, !Sync
+ _x: std::marker::PhantomData<std::rc::Rc<()>>,
+ }
+
+ impl<F> crate::rt::Executor<F> for TokioExecutor
+ where
+ F: std::future::Future + 'static + Send,
+ F::Output: Send + 'static,
+ {
+ fn execute(&self, fut: F) {
+ tokio::task::spawn(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Send + Unpin + 'static) {
+ let (_sender, conn) =
+ crate::client::conn::http2::handshake::<_, _, http_body_util::Empty<bytes::Bytes>>(
+ TokioExecutor {
+ _x: Default::default(),
+ },
+ io,
+ )
+ .await
+ .unwrap();
+
+ tokio::task::spawn_local(async move {
+ // can't use spawn here because when executor is !Send
+ conn.await.unwrap();
+ });
+ }
+ }
+
+ #[tokio::test]
+ #[ignore] // only compilation is checked
+ async fn send_not_sync_executor_of_send_futures() {
+ #[derive(Clone)]
+ struct TokioExecutor {
+ // !Sync
+ _x: std::marker::PhantomData<std::cell::Cell<()>>,
+ }
+
+ impl<F> crate::rt::Executor<F> for TokioExecutor
+ where
+ F: std::future::Future + 'static + Send,
+ F::Output: Send + 'static,
+ {
+ fn execute(&self, fut: F) {
+ tokio::task::spawn(fut);
+ }
+ }
+
+ #[allow(unused)]
+ async fn run(io: impl crate::rt::Read + crate::rt::Write + Send + Unpin + 'static) {
+ let (_sender, conn) =
+ crate::client::conn::http2::handshake::<_, _, http_body_util::Empty<bytes::Bytes>>(
+ TokioExecutor {
+ _x: Default::default(),
+ },
+ io,
+ )
+ .await
+ .unwrap();
+
+ tokio::task::spawn_local(async move {
+ // can't use spawn here because when executor is !Send
+ conn.await.unwrap();
+ });
+ }
+ }
+}
diff --git a/vendor/hyper/src/client/conn/mod.rs b/vendor/hyper/src/client/conn/mod.rs
new file mode 100644
index 00000000..f982ae6d
--- /dev/null
+++ b/vendor/hyper/src/client/conn/mod.rs
@@ -0,0 +1,22 @@
+//! Lower-level client connection API.
+//!
+//! The types in this module are to provide a lower-level API based around a
+//! single connection. Connecting to a host, pooling connections, and the like
+//! are not handled at this level. This module provides the building blocks to
+//! customize those things externally.
+//!
+//! If you are looking for a convenient HTTP client, then you may wish to
+//! consider [reqwest](https://github.com/seanmonstar/reqwest) for a high level
+//! client or [`hyper-util`'s client](https://docs.rs/hyper-util/latest/hyper_util/client/index.html)
+//! if you want to keep it more low level / basic.
+//!
+//! ## Example
+//!
+//! See the [client guide](https://hyper.rs/guides/1/client/basic/).
+
+#[cfg(feature = "http1")]
+pub mod http1;
+#[cfg(feature = "http2")]
+pub mod http2;
+
+pub use super::dispatch::TrySendError;
diff --git a/vendor/hyper/src/client/dispatch.rs b/vendor/hyper/src/client/dispatch.rs
new file mode 100644
index 00000000..4ae41c50
--- /dev/null
+++ b/vendor/hyper/src/client/dispatch.rs
@@ -0,0 +1,510 @@
+use std::task::{Context, Poll};
+#[cfg(feature = "http2")]
+use std::{future::Future, pin::Pin};
+
+#[cfg(feature = "http2")]
+use http::{Request, Response};
+#[cfg(feature = "http2")]
+use http_body::Body;
+#[cfg(feature = "http2")]
+use pin_project_lite::pin_project;
+use tokio::sync::{mpsc, oneshot};
+
+#[cfg(feature = "http2")]
+use crate::{body::Incoming, proto::h2::client::ResponseFutMap};
+
+pub(crate) type RetryPromise<T, U> = oneshot::Receiver<Result<U, TrySendError<T>>>;
+pub(crate) type Promise<T> = oneshot::Receiver<Result<T, crate::Error>>;
+
+/// An error when calling `try_send_request`.
+///
+/// There is a possibility of an error occurring on a connection in-between the
+/// time that a request is queued and when it is actually written to the IO
+/// transport. If that happens, it is safe to return the request back to the
+/// caller, as it was never fully sent.
+#[derive(Debug)]
+pub struct TrySendError<T> {
+ pub(crate) error: crate::Error,
+ pub(crate) message: Option<T>,
+}
+
+pub(crate) fn channel<T, U>() -> (Sender<T, U>, Receiver<T, U>) {
+ let (tx, rx) = mpsc::unbounded_channel();
+ let (giver, taker) = want::new();
+ let tx = Sender {
+ #[cfg(feature = "http1")]
+ buffered_once: false,
+ giver,
+ inner: tx,
+ };
+ let rx = Receiver { inner: rx, taker };
+ (tx, rx)
+}
+
+/// A bounded sender of requests and callbacks for when responses are ready.
+///
+/// While the inner sender is unbounded, the Giver is used to determine
+/// if the Receiver is ready for another request.
+pub(crate) struct Sender<T, U> {
+ /// One message is always allowed, even if the Receiver hasn't asked
+ /// for it yet. This boolean keeps track of whether we've sent one
+ /// without notice.
+ #[cfg(feature = "http1")]
+ buffered_once: bool,
+ /// The Giver helps watch that the Receiver side has been polled
+ /// when the queue is empty. This helps us know when a request and
+ /// response have been fully processed, and a connection is ready
+ /// for more.
+ giver: want::Giver,
+ /// Actually bounded by the Giver, plus `buffered_once`.
+ inner: mpsc::UnboundedSender<Envelope<T, U>>,
+}
+
+/// An unbounded version.
+///
+/// Cannot poll the Giver, but can still use it to determine if the Receiver
+/// has been dropped. However, this version can be cloned.
+#[cfg(feature = "http2")]
+pub(crate) struct UnboundedSender<T, U> {
+ /// Only used for `is_closed`, since mpsc::UnboundedSender cannot be checked.
+ giver: want::SharedGiver,
+ inner: mpsc::UnboundedSender<Envelope<T, U>>,
+}
+
+impl<T, U> Sender<T, U> {
+ #[cfg(feature = "http1")]
+ pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
+ self.giver
+ .poll_want(cx)
+ .map_err(|_| crate::Error::new_closed())
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn is_ready(&self) -> bool {
+ self.giver.is_wanting()
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn is_closed(&self) -> bool {
+ self.giver.is_canceled()
+ }
+
+ #[cfg(feature = "http1")]
+ fn can_send(&mut self) -> bool {
+ if self.giver.give() || !self.buffered_once {
+ // If the receiver is ready *now*, then of course we can send.
+ //
+ // If the receiver isn't ready yet, but we don't have anything
+ // in the channel yet, then allow one message.
+ self.buffered_once = true;
+ true
+ } else {
+ false
+ }
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, T> {
+ if !self.can_send() {
+ return Err(val);
+ }
+ let (tx, rx) = oneshot::channel();
+ self.inner
+ .send(Envelope(Some((val, Callback::Retry(Some(tx))))))
+ .map(move |_| rx)
+ .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn send(&mut self, val: T) -> Result<Promise<U>, T> {
+ if !self.can_send() {
+ return Err(val);
+ }
+ let (tx, rx) = oneshot::channel();
+ self.inner
+ .send(Envelope(Some((val, Callback::NoRetry(Some(tx))))))
+ .map(move |_| rx)
+ .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+ }
+
+ #[cfg(feature = "http2")]
+ pub(crate) fn unbound(self) -> UnboundedSender<T, U> {
+ UnboundedSender {
+ giver: self.giver.shared(),
+ inner: self.inner,
+ }
+ }
+}
+
+#[cfg(feature = "http2")]
+impl<T, U> UnboundedSender<T, U> {
+ pub(crate) fn is_ready(&self) -> bool {
+ !self.giver.is_canceled()
+ }
+
+ pub(crate) fn is_closed(&self) -> bool {
+ self.giver.is_canceled()
+ }
+
+ pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, T> {
+ let (tx, rx) = oneshot::channel();
+ self.inner
+ .send(Envelope(Some((val, Callback::Retry(Some(tx))))))
+ .map(move |_| rx)
+ .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+ }
+
+ pub(crate) fn send(&mut self, val: T) -> Result<Promise<U>, T> {
+ let (tx, rx) = oneshot::channel();
+ self.inner
+ .send(Envelope(Some((val, Callback::NoRetry(Some(tx))))))
+ .map(move |_| rx)
+ .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+ }
+}
+
+#[cfg(feature = "http2")]
+impl<T, U> Clone for UnboundedSender<T, U> {
+ fn clone(&self) -> Self {
+ UnboundedSender {
+ giver: self.giver.clone(),
+ inner: self.inner.clone(),
+ }
+ }
+}
+
+pub(crate) struct Receiver<T, U> {
+ inner: mpsc::UnboundedReceiver<Envelope<T, U>>,
+ taker: want::Taker,
+}
+
+impl<T, U> Receiver<T, U> {
+ pub(crate) fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<(T, Callback<T, U>)>> {
+ match self.inner.poll_recv(cx) {
+ Poll::Ready(item) => {
+ Poll::Ready(item.map(|mut env| env.0.take().expect("envelope not dropped")))
+ }
+ Poll::Pending => {
+ self.taker.want();
+ Poll::Pending
+ }
+ }
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn close(&mut self) {
+ self.taker.cancel();
+ self.inner.close();
+ }
+
+ #[cfg(feature = "http1")]
+ pub(crate) fn try_recv(&mut self) -> Option<(T, Callback<T, U>)> {
+ use futures_util::FutureExt;
+ match self.inner.recv().now_or_never() {
+ Some(Some(mut env)) => env.0.take(),
+ _ => None,
+ }
+ }
+}
+
+impl<T, U> Drop for Receiver<T, U> {
+ fn drop(&mut self) {
+ // Notify the giver about the closure first, before dropping
+ // the mpsc::Receiver.
+ self.taker.cancel();
+ }
+}
+
+struct Envelope<T, U>(Option<(T, Callback<T, U>)>);
+
+impl<T, U> Drop for Envelope<T, U> {
+ fn drop(&mut self) {
+ if let Some((val, cb)) = self.0.take() {
+ cb.send(Err(TrySendError {
+ error: crate::Error::new_canceled().with("connection closed"),
+ message: Some(val),
+ }));
+ }
+ }
+}
+
+pub(crate) enum Callback<T, U> {
+ #[allow(unused)]
+ Retry(Option<oneshot::Sender<Result<U, TrySendError<T>>>>),
+ NoRetry(Option<oneshot::Sender<Result<U, crate::Error>>>),
+}
+
+impl<T, U> Drop for Callback<T, U> {
+ fn drop(&mut self) {
+ match self {
+ Callback::Retry(tx) => {
+ if let Some(tx) = tx.take() {
+ let _ = tx.send(Err(TrySendError {
+ error: dispatch_gone(),
+ message: None,
+ }));
+ }
+ }
+ Callback::NoRetry(tx) => {
+ if let Some(tx) = tx.take() {
+ let _ = tx.send(Err(dispatch_gone()));
+ }
+ }
+ }
+ }
+}
+
+#[cold]
+fn dispatch_gone() -> crate::Error {
+ // FIXME(nox): What errors do we want here?
+ crate::Error::new_user_dispatch_gone().with(if std::thread::panicking() {
+ "user code panicked"
+ } else {
+ "runtime dropped the dispatch task"
+ })
+}
+
+impl<T, U> Callback<T, U> {
+ #[cfg(feature = "http2")]
+ pub(crate) fn is_canceled(&self) -> bool {
+ match *self {
+ Callback::Retry(Some(ref tx)) => tx.is_closed(),
+ Callback::NoRetry(Some(ref tx)) => tx.is_closed(),
+ _ => unreachable!(),
+ }
+ }
+
+ pub(crate) fn poll_canceled(&mut self, cx: &mut Context<'_>) -> Poll<()> {
+ match *self {
+ Callback::Retry(Some(ref mut tx)) => tx.poll_closed(cx),
+ Callback::NoRetry(Some(ref mut tx)) => tx.poll_closed(cx),
+ _ => unreachable!(),
+ }
+ }
+
+ pub(crate) fn send(mut self, val: Result<U, TrySendError<T>>) {
+ match self {
+ Callback::Retry(ref mut tx) => {
+ let _ = tx.take().unwrap().send(val);
+ }
+ Callback::NoRetry(ref mut tx) => {
+ let _ = tx.take().unwrap().send(val.map_err(|e| e.error));
+ }
+ }
+ }
+}
+
+impl<T> TrySendError<T> {
+ /// Take the message from this error.
+ ///
+ /// The message will not always have been recovered. If an error occurs
+ /// after the message has been serialized onto the connection, it will not
+ /// be available here.
+ pub fn take_message(&mut self) -> Option<T> {
+ self.message.take()
+ }
+
+ /// Consumes this to return the inner error.
+ pub fn into_error(self) -> crate::Error {
+ self.error
+ }
+}
+
+#[cfg(feature = "http2")]
+pin_project! {
+ pub struct SendWhen<B>
+ where
+ B: Body,
+ B: 'static,
+ {
+ #[pin]
+ pub(crate) when: ResponseFutMap<B>,
+ #[pin]
+ pub(crate) call_back: Option<Callback<Request<B>, Response<Incoming>>>,
+ }
+}
+
+#[cfg(feature = "http2")]
+impl<B> Future for SendWhen<B>
+where
+ B: Body + 'static,
+{
+ type Output = ();
+
+ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ let mut this = self.project();
+
+ let mut call_back = this.call_back.take().expect("polled after complete");
+
+ match Pin::new(&mut this.when).poll(cx) {
+ Poll::Ready(Ok(res)) => {
+ call_back.send(Ok(res));
+ Poll::Ready(())
+ }
+ Poll::Pending => {
+ // check if the callback is canceled
+ match call_back.poll_canceled(cx) {
+ Poll::Ready(v) => v,
+ Poll::Pending => {
+ // Move call_back back to struct before return
+ this.call_back.set(Some(call_back));
+ return Poll::Pending;
+ }
+ };
+ trace!("send_when canceled");
+ Poll::Ready(())
+ }
+ Poll::Ready(Err((error, message))) => {
+ call_back.send(Err(TrySendError { error, message }));
+ Poll::Ready(())
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ #[cfg(feature = "nightly")]
+ extern crate test;
+
+ use std::future::Future;
+ use std::pin::Pin;
+ use std::task::{Context, Poll};
+
+ use super::{channel, Callback, Receiver};
+
+ #[derive(Debug)]
+ struct Custom(#[allow(dead_code)] i32);
+
+ impl<T, U> Future for Receiver<T, U> {
+ type Output = Option<(T, Callback<T, U>)>;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ self.poll_recv(cx)
+ }
+ }
+
+ /// Helper to check if the future is ready after polling once.
+ struct PollOnce<'a, F>(&'a mut F);
+
+ impl<F, T> Future for PollOnce<'_, F>
+ where
+ F: Future<Output = T> + Unpin,
+ {
+ type Output = Option<()>;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ match Pin::new(&mut self.0).poll(cx) {
+ Poll::Ready(_) => Poll::Ready(Some(())),
+ Poll::Pending => Poll::Ready(None),
+ }
+ }
+ }
+
+ #[cfg(not(miri))]
+ #[tokio::test]
+ async fn drop_receiver_sends_cancel_errors() {
+ let _ = pretty_env_logger::try_init();
+
+ let (mut tx, mut rx) = channel::<Custom, ()>();
+
+ // must poll once for try_send to succeed
+ assert!(PollOnce(&mut rx).await.is_none(), "rx empty");
+
+ let promise = tx.try_send(Custom(43)).unwrap();
+ drop(rx);
+
+ let fulfilled = promise.await;
+ let err = fulfilled
+ .expect("fulfilled")
+ .expect_err("promise should error");
+ match (err.error.is_canceled(), err.message) {
+ (true, Some(_)) => (),
+ e => panic!("expected Error::Cancel(_), found {:?}", e),
+ }
+ }
+
+ #[cfg(not(miri))]
+ #[tokio::test]
+ async fn sender_checks_for_want_on_send() {
+ let (mut tx, mut rx) = channel::<Custom, ()>();
+
+ // one is allowed to buffer, second is rejected
+ let _ = tx.try_send(Custom(1)).expect("1 buffered");
+ tx.try_send(Custom(2)).expect_err("2 not ready");
+
+ assert!(PollOnce(&mut rx).await.is_some(), "rx once");
+
+ // Even though 1 has been popped, only 1 could be buffered for the
+ // lifetime of the channel.
+ tx.try_send(Custom(2)).expect_err("2 still not ready");
+
+ assert!(PollOnce(&mut rx).await.is_none(), "rx empty");
+
+ let _ = tx.try_send(Custom(2)).expect("2 ready");
+ }
+
+ #[cfg(feature = "http2")]
+ #[test]
+ fn unbounded_sender_doesnt_bound_on_want() {
+ let (tx, rx) = channel::<Custom, ()>();
+ let mut tx = tx.unbound();
+
+ let _ = tx.try_send(Custom(1)).unwrap();
+ let _ = tx.try_send(Custom(2)).unwrap();
+ let _ = tx.try_send(Custom(3)).unwrap();
+
+ drop(rx);
+
+ let _ = tx.try_send(Custom(4)).unwrap_err();
+ }
+
+ #[cfg(feature = "nightly")]
+ #[bench]
+ fn giver_queue_throughput(b: &mut test::Bencher) {
+ use crate::{body::Incoming, Request, Response};
+
+ let rt = tokio::runtime::Builder::new_current_thread()
+ .build()
+ .unwrap();
+ let (mut tx, mut rx) = channel::<Request<Incoming>, Response<Incoming>>();
+
+ b.iter(move || {
+ let _ = tx.send(Request::new(Incoming::empty())).unwrap();
+ rt.block_on(async {
+ loop {
+ let poll_once = PollOnce(&mut rx);
+ let opt = poll_once.await;
+ if opt.is_none() {
+ break;
+ }
+ }
+ });
+ })
+ }
+
+ #[cfg(feature = "nightly")]
+ #[bench]
+ fn giver_queue_not_ready(b: &mut test::Bencher) {
+ let rt = tokio::runtime::Builder::new_current_thread()
+ .build()
+ .unwrap();
+ let (_tx, mut rx) = channel::<i32, ()>();
+ b.iter(move || {
+ rt.block_on(async {
+ let poll_once = PollOnce(&mut rx);
+ assert!(poll_once.await.is_none());
+ });
+ })
+ }
+
+ #[cfg(feature = "nightly")]
+ #[bench]
+ fn giver_queue_cancel(b: &mut test::Bencher) {
+ let (_tx, mut rx) = channel::<i32, ()>();
+
+ b.iter(move || {
+ rx.taker.cancel();
+ })
+ }
+}
diff --git a/vendor/hyper/src/client/mod.rs b/vendor/hyper/src/client/mod.rs
new file mode 100644
index 00000000..86e38973
--- /dev/null
+++ b/vendor/hyper/src/client/mod.rs
@@ -0,0 +1,22 @@
+//! HTTP Client
+//!
+//! hyper provides HTTP over a single connection. See the [`conn`] module.
+//!
+//! ## Examples
+//!
+//! * [`client`] - A simple CLI http client that requests the url passed in parameters and outputs the response content and details to the stdout, reading content chunk-by-chunk.
+//!
+//! * [`client_json`] - A simple program that GETs some json, reads the body asynchronously, parses it with serde and outputs the result.
+//!
+//! [`client`]: https://github.com/hyperium/hyper/blob/master/examples/client.rs
+//! [`client_json`]: https://github.com/hyperium/hyper/blob/master/examples/client_json.rs
+
+#[cfg(test)]
+mod tests;
+
+cfg_feature! {
+ #![any(feature = "http1", feature = "http2")]
+
+ pub mod conn;
+ pub(super) mod dispatch;
+}
diff --git a/vendor/hyper/src/client/tests.rs b/vendor/hyper/src/client/tests.rs
new file mode 100644
index 00000000..144349e5
--- /dev/null
+++ b/vendor/hyper/src/client/tests.rs
@@ -0,0 +1,261 @@
+/*
+// FIXME: re-implement tests with `async/await`
+#[test]
+fn retryable_request() {
+ let _ = pretty_env_logger::try_init();
+
+ let mut rt = Runtime::new().expect("new rt");
+ let mut connector = MockConnector::new();
+
+ let sock1 = connector.mock("http://mock.local");
+ let sock2 = connector.mock("http://mock.local");
+
+ let client = Client::builder()
+ .build::<_, crate::Body>(connector);
+
+ client.pool.no_timer();
+
+ {
+
+ let req = Request::builder()
+ .uri("http://mock.local/a")
+ .body(Default::default())
+ .unwrap();
+ let res1 = client.request(req);
+ let srv1 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+ rt.block_on(res1.join(srv1)).expect("res1");
+ }
+ drop(sock1);
+
+ let req = Request::builder()
+ .uri("http://mock.local/b")
+ .body(Default::default())
+ .unwrap();
+ let res2 = client.request(req)
+ .map(|res| {
+ assert_eq!(res.status().as_u16(), 222);
+ });
+ let srv2 = poll_fn(|| {
+ try_ready!(sock2.read(&mut [0u8; 512]));
+ try_ready!(sock2.write(b"HTTP/1.1 222 OK\r\nContent-Length: 0\r\n\r\n"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+
+ rt.block_on(res2.join(srv2)).expect("res2");
+}
+
+#[test]
+fn conn_reset_after_write() {
+ let _ = pretty_env_logger::try_init();
+
+ let mut rt = Runtime::new().expect("new rt");
+ let mut connector = MockConnector::new();
+
+ let sock1 = connector.mock("http://mock.local");
+
+ let client = Client::builder()
+ .build::<_, crate::Body>(connector);
+
+ client.pool.no_timer();
+
+ {
+ let req = Request::builder()
+ .uri("http://mock.local/a")
+ .body(Default::default())
+ .unwrap();
+ let res1 = client.request(req);
+ let srv1 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+ rt.block_on(res1.join(srv1)).expect("res1");
+ }
+
+ let req = Request::builder()
+ .uri("http://mock.local/a")
+ .body(Default::default())
+ .unwrap();
+ let res2 = client.request(req);
+ let mut sock1 = Some(sock1);
+ let srv2 = poll_fn(|| {
+ // We purposefully keep the socket open until the client
+ // has written the second request, and THEN disconnect.
+ //
+ // Not because we expect servers to be jerks, but to trigger
+ // state where we write on an assumedly good connection, and
+ // only reset the close AFTER we wrote bytes.
+ try_ready!(sock1.as_mut().unwrap().read(&mut [0u8; 512]));
+ sock1.take();
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+ let err = rt.block_on(res2.join(srv2)).expect_err("res2");
+ assert!(err.is_incomplete_message(), "{:?}", err);
+}
+
+#[test]
+fn checkout_win_allows_connect_future_to_be_pooled() {
+ let _ = pretty_env_logger::try_init();
+
+ let mut rt = Runtime::new().expect("new rt");
+ let mut connector = MockConnector::new();
+
+
+ let (tx, rx) = oneshot::channel::<()>();
+ let sock1 = connector.mock("http://mock.local");
+ let sock2 = connector.mock_fut("http://mock.local", rx);
+
+ let client = Client::builder()
+ .build::<_, crate::Body>(connector);
+
+ client.pool.no_timer();
+
+ let uri = "http://mock.local/a".parse::<crate::Uri>().expect("uri parse");
+
+ // First request just sets us up to have a connection able to be put
+ // back in the pool. *However*, it doesn't insert immediately. The
+ // body has 1 pending byte, and we will only drain in request 2, once
+ // the connect future has been started.
+ let mut body = {
+ let res1 = client.get(uri.clone())
+ .map(|res| res.into_body().concat2());
+ let srv1 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ // Chunked is used so as to force 2 body reads.
+ try_ready!(sock1.write(b"\
+ HTTP/1.1 200 OK\r\n\
+ transfer-encoding: chunked\r\n\
+ \r\n\
+ 1\r\nx\r\n\
+ 0\r\n\r\n\
+ "));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+
+ rt.block_on(res1.join(srv1)).expect("res1").0
+ };
+
+
+ // The second request triggers the only mocked connect future, but then
+ // the drained body allows the first socket to go back to the pool,
+ // "winning" the checkout race.
+ {
+ let res2 = client.get(uri.clone());
+ let drain = poll_fn(move || {
+ body.poll()
+ });
+ let srv2 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nx"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+
+ rt.block_on(res2.join(drain).join(srv2)).expect("res2");
+ }
+
+ // "Release" the mocked connect future, and let the runtime spin once so
+ // it's all setup...
+ {
+ let mut tx = Some(tx);
+ let client = &client;
+ let key = client.pool.h1_key("http://mock.local");
+ let mut tick_cnt = 0;
+ let fut = poll_fn(move || {
+ tx.take();
+
+ if client.pool.idle_count(&key) == 0 {
+ tick_cnt += 1;
+ assert!(tick_cnt < 10, "ticked too many times waiting for idle");
+ trace!("no idle yet; tick count: {}", tick_cnt);
+ ::futures::task::current().notify();
+ Ok(Async::NotReady)
+ } else {
+ Ok::<_, ()>(Async::Ready(()))
+ }
+ });
+ rt.block_on(fut).unwrap();
+ }
+
+ // Third request just tests out that the "loser" connection was pooled. If
+ // it isn't, this will panic since the MockConnector doesn't have any more
+ // mocks to give out.
+ {
+ let res3 = client.get(uri);
+ let srv3 = poll_fn(|| {
+ try_ready!(sock2.read(&mut [0u8; 512]));
+ try_ready!(sock2.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv3 poll_fn error: {}", e));
+
+ rt.block_on(res3.join(srv3)).expect("res3");
+ }
+}
+
+#[cfg(feature = "nightly")]
+#[bench]
+fn bench_http1_get_0b(b: &mut test::Bencher) {
+ let _ = pretty_env_logger::try_init();
+
+ let mut rt = Runtime::new().expect("new rt");
+ let mut connector = MockConnector::new();
+
+
+ let client = Client::builder()
+ .build::<_, crate::Body>(connector.clone());
+
+ client.pool.no_timer();
+
+ let uri = Uri::from_static("http://mock.local/a");
+
+ b.iter(move || {
+ let sock1 = connector.mock("http://mock.local");
+ let res1 = client
+ .get(uri.clone())
+ .and_then(|res| {
+ res.into_body().for_each(|_| Ok(()))
+ });
+ let srv1 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+ rt.block_on(res1.join(srv1)).expect("res1");
+ });
+}
+
+#[cfg(feature = "nightly")]
+#[bench]
+fn bench_http1_get_10b(b: &mut test::Bencher) {
+ let _ = pretty_env_logger::try_init();
+
+ let mut rt = Runtime::new().expect("new rt");
+ let mut connector = MockConnector::new();
+
+
+ let client = Client::builder()
+ .build::<_, crate::Body>(connector.clone());
+
+ client.pool.no_timer();
+
+ let uri = Uri::from_static("http://mock.local/a");
+
+ b.iter(move || {
+ let sock1 = connector.mock("http://mock.local");
+ let res1 = client
+ .get(uri.clone())
+ .and_then(|res| {
+ res.into_body().for_each(|_| Ok(()))
+ });
+ let srv1 = poll_fn(|| {
+ try_ready!(sock1.read(&mut [0u8; 512]));
+ try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n0123456789"));
+ Ok(Async::Ready(()))
+ }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+ rt.block_on(res1.join(srv1)).expect("res1");
+ });
+}
+*/
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-03 22:02:01 +0000