wreq-rb 0.3.0

data/vendor/wreq/src/client/core/conn/http2.rs

@@ -0,0 +1,307 @@
+//! HTTP/2 client connections
+
+use std::{
+    fmt,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+
+use http::{Request, Response};
+use http_body::Body;
+use tokio::io::{AsyncRead, AsyncWrite};
+
+use crate::{
+    client::core::{
+        Result,
+        body::Incoming as IncomingBody,
+        dispatch::{self, TrySendError},
+        error::{BoxError, Error},
+        proto::{self, h2::ping},
+        rt::{ArcTimer, Time, Timer, bounds::Http2ClientConnExec},
+    },
+    http2::Http2Options,
+};
+
+/// 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.
+#[must_use = "futures do nothing unless polled"]
+pub struct Connection<T, B, E>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    B: Body + 'static,
+    E: Http2ClientConnExec<B, T> + Unpin,
+    B::Error: Into<BoxError>,
+{
+    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)]
+pub struct Builder<Ex> {
+    exec: Ex,
+    timer: Time,
+    opts: Http2Options,
+}
+
+// ===== 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<Result<()>> {
+        if self.is_closed() {
+            Poll::Ready(Err(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) -> Result<()> {
+        std::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`.
+    ///
+    /// # 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 = std::result::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 = 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> fmt::Debug for Connection<T, B, E>
+where
+    T: AsyncRead + AsyncWrite + fmt::Debug + 'static + Unpin,
+    B: Body + 'static,
+    E: Http2ClientConnExec<B, T> + Unpin,
+    B::Error: Into<BoxError>,
+{
+    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: AsyncRead + AsyncWrite + Unpin + 'static,
+    B: Body + 'static + Unpin,
+    B::Data: Send,
+    E: Unpin,
+    B::Error: Into<BoxError>,
+    E: Http2ClientConnExec<B, T> + Unpin,
+{
+    type Output = 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(())),
+            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,
+            opts: Default::default(),
+        }
+    }
+
+    /// Provide a timer to execute background HTTP2 tasks.
+    #[inline]
+    pub fn timer<M>(&mut self, timer: M)
+    where
+        M: Timer + Send + Sync + 'static,
+    {
+        self.timer = Time::Timer(ArcTimer::new(timer));
+    }
+
+    /// Provide a options configuration for the HTTP/2 connection.
+    #[inline]
+    pub fn options(&mut self, opts: Http2Options) {
+        self.opts = opts;
+    }
+
+    /// Constructs a connection with the configured options and IO.
+    ///
+    /// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will
+    /// do nothing.
+    pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, Connection<T, B, Ex>)>
+    where
+        T: AsyncRead + AsyncWrite + Unpin,
+        B: Body + 'static,
+        B::Data: Send,
+        B::Error: Into<BoxError>,
+        Ex: Http2ClientConnExec<B, T> + Unpin,
+    {
+        trace!("client handshake HTTP/2");
+
+        // Crate the HTTP/2 client with the provided options.
+        let builder = {
+            let mut builder = http2::client::Builder::default();
+            builder
+                .initial_max_send_streams(self.opts.initial_max_send_streams)
+                .initial_window_size(self.opts.initial_window_size)
+                .initial_connection_window_size(self.opts.initial_conn_window_size)
+                .max_send_buffer_size(self.opts.max_send_buffer_size);
+            if let Some(id) = self.opts.initial_stream_id {
+                builder.initial_stream_id(id);
+            }
+            if let Some(max) = self.opts.max_pending_accept_reset_streams {
+                builder.max_pending_accept_reset_streams(max);
+            }
+            if let Some(max) = self.opts.max_concurrent_reset_streams {
+                builder.max_concurrent_reset_streams(max);
+            }
+            if let Some(max) = self.opts.max_concurrent_streams {
+                builder.max_concurrent_streams(max);
+            }
+            if let Some(max) = self.opts.max_header_list_size {
+                builder.max_header_list_size(max);
+            }
+            if let Some(opt) = self.opts.enable_push {
+                builder.enable_push(opt);
+            }
+            if let Some(max) = self.opts.max_frame_size {
+                builder.max_frame_size(max);
+            }
+            if let Some(max) = self.opts.header_table_size {
+                builder.header_table_size(max);
+            }
+            if let Some(v) = self.opts.enable_connect_protocol {
+                builder.enable_connect_protocol(v);
+            }
+            if let Some(v) = self.opts.no_rfc7540_priorities {
+                builder.no_rfc7540_priorities(v);
+            }
+            if let Some(order) = self.opts.settings_order {
+                builder.settings_order(order);
+            }
+            if let Some(experimental_settings) = self.opts.experimental_settings {
+                builder.experimental_settings(experimental_settings);
+            }
+            if let Some(stream_dependency) = self.opts.headers_stream_dependency {
+                builder.headers_stream_dependency(stream_dependency);
+            }
+            if let Some(order) = self.opts.headers_pseudo_order {
+                builder.headers_pseudo_order(order);
+            }
+            if let Some(priority) = self.opts.priorities {
+                builder.priorities(priority);
+            }
+
+            builder
+        };
+
+        // Create the ping configuration for the connection.
+        let ping_config = ping::Config::new(
+            self.opts.adaptive_window,
+            self.opts.initial_window_size,
+            self.opts.keep_alive_interval,
+            self.opts.keep_alive_timeout,
+            self.opts.keep_alive_while_idle,
+        );
+
+        let (tx, rx) = dispatch::channel();
+        let h2 = proto::h2::client::handshake(io, rx, builder, ping_config, self.exec, self.timer)
+            .await?;
+        Ok((
+            SendRequest {
+                dispatch: tx.unbound(),
+            },
+            Connection {
+                inner: (PhantomData, h2),
+            },
+        ))
+    }
+}

data/vendor/wreq/src/client/core/conn.rs

@@ -0,0 +1,11 @@
+//! 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.
+
+pub mod http1;
+pub mod http2;
+
+pub use super::dispatch::TrySendError;

data/vendor/wreq/src/client/core/dispatch.rs

@@ -0,0 +1,299 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use http::{Request, Response};
+use http_body::Body;
+use pin_project_lite::pin_project;
+use tokio::sync::{mpsc, oneshot};
+
+use super::{Error, body::Incoming, proto::h2::client::ResponseFutMap};
+
+pub(crate) type RetryPromise<T, U> = oneshot::Receiver<Result<U, TrySendError<T>>>;
+
+/// 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: 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 {
+        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.
+    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.
+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> {
+    pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<super::Result<()>> {
+        self.giver.poll_want(cx).map_err(|_| Error::new_closed())
+    }
+
+    pub(crate) fn is_ready(&self) -> bool {
+        self.giver.is_wanting()
+    }
+
+    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
+        }
+    }
+
+    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(Some(tx))))))
+            .map(move |_| rx)
+            .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+    }
+
+    pub(crate) fn unbound(self) -> UnboundedSender<T, U> {
+        UnboundedSender {
+            giver: self.giver.shared(),
+            inner: self.inner,
+        }
+    }
+}
+
+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(Some(tx))))))
+            .map(move |_| rx)
+            .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+    }
+}
+
+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
+            }
+        }
+    }
+
+    pub(crate) fn close(&mut self) {
+        self.taker.cancel();
+        self.inner.close();
+    }
+
+    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: Error::new_canceled().with("connection closed"),
+                message: Some(val),
+            }));
+        }
+    }
+}
+
+pub(crate) struct Callback<T, U>(Option<oneshot::Sender<Result<U, TrySendError<T>>>>);
+
+impl<T, U> Drop for Callback<T, U> {
+    fn drop(&mut self) {
+        if let Some(tx) = self.0.take() {
+            let _ = tx.send(Err(TrySendError {
+                error: dispatch_gone(),
+                message: None,
+            }));
+        }
+    }
+}
+
+#[cold]
+fn dispatch_gone() -> Error {
+    // FIXME(nox): What errors do we want here?
+    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> {
+    pub(crate) fn is_canceled(&self) -> bool {
+        if let Some(ref tx) = self.0 {
+            return tx.is_closed();
+        }
+
+        unreachable!()
+    }
+
+    pub(crate) fn poll_canceled(&mut self, cx: &mut Context<'_>) -> Poll<()> {
+        if let Some(ref mut tx) = self.0 {
+            return tx.poll_closed(cx);
+        }
+
+        unreachable!()
+    }
+
+    pub(crate) fn send(mut self, val: Result<U, TrySendError<T>>) {
+        let _ = self.0.take().unwrap().send(val);
+    }
+}
+
+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) -> Error {
+        self.error
+    }
+}
+
+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>>>,
+    }
+}
+
+impl<B> Future for SendWhen<B>
+where
+    B: Body + 'static,
+    B::Data: Send,
+{
+    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(())
+            }
+        }
+    }
+}