wreq-rb 0.3.0

data/vendor/wreq/src/client/core/rt/timer.rs

@@ -0,0 +1,150 @@
+//! Provides a timer trait with timer-like functions
+
+use std::{
+    any::TypeId,
+    future::Future,
+    pin::Pin,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+/// A timer which provides timer-like functions.
+pub trait Timer {
+    /// Return a future that resolves in `duration` time.
+    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>>;
+
+    /// Return a future that resolves at `deadline`.
+    fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>>;
+
+    /// Return an `Instant` representing the current time.
+    ///
+    /// The default implementation returns [`Instant::now()`].
+    fn now(&self) -> Instant {
+        Instant::now()
+    }
+
+    /// Reset a future to resolve at `new_deadline` instead.
+    fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
+        *sleep = self.sleep_until(new_deadline);
+    }
+}
+
+/// A future returned by a `Timer`.
+pub trait Sleep: Send + Sync + Future<Output = ()> {
+    #[doc(hidden)]
+    /// This method is private and can not be implemented by downstream crate
+    fn __type_id(&self, _: private::Sealed) -> TypeId
+    where
+        Self: 'static,
+    {
+        TypeId::of::<Self>()
+    }
+}
+
+/// A handle to a shared timer instance.
+///
+/// `TimerHandle` provides a reference-counted, thread-safe handle to any type implementing the
+/// [`Timer`] trait. It allows cloning and sharing a timer implementation across multiple components
+/// or tasks.
+///
+/// This is typically used to abstract over different timer backends and to provide a unified
+/// interface for spawning sleep futures or scheduling timeouts.
+#[derive(Clone)]
+pub struct ArcTimer(Arc<dyn Timer + Send + Sync>);
+
+/// A user-provided timer to time background tasks.
+#[derive(Clone)]
+pub enum Time {
+    Timer(ArcTimer),
+    Empty,
+}
+
+// =====impl Sleep =====
+
+impl dyn Sleep {
+    //! This is a re-implementation of downcast methods from std::any::Any
+
+    /// Check whether the type is the same as `T`
+    pub fn is<T>(&self) -> bool
+    where
+        T: Sleep + 'static,
+    {
+        self.__type_id(private::Sealed {}) == TypeId::of::<T>()
+    }
+
+    /// Downcast a pinned &mut Sleep object to its original type
+    pub fn downcast_mut_pin<T>(self: Pin<&mut Self>) -> Option<Pin<&mut T>>
+    where
+        T: Sleep + 'static,
+    {
+        if self.is::<T>() {
+            #[allow(unsafe_code)]
+            unsafe {
+                let inner = Pin::into_inner_unchecked(self);
+                Some(Pin::new_unchecked(
+                    &mut *(&mut *inner as *mut dyn Sleep as *mut T),
+                ))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+// =====impl ArcTimer =====
+
+impl ArcTimer {
+    pub(crate) fn new<T>(inner: T) -> Self
+    where
+        T: Timer + Send + Sync + 'static,
+    {
+        Self(Arc::new(inner))
+    }
+}
+
+impl Timer for ArcTimer {
+    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
+        self.0.sleep(duration)
+    }
+
+    fn now(&self) -> Instant {
+        tokio::time::Instant::now().into()
+    }
+
+    fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
+        self.0.sleep_until(deadline)
+    }
+}
+
+// =====impl Time =====
+
+impl Time {
+    pub(crate) fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
+        match *self {
+            Time::Empty => {
+                panic!("You must supply a timer.")
+            }
+            Time::Timer(ref t) => t.sleep(duration),
+        }
+    }
+
+    pub(crate) fn now(&self) -> Instant {
+        match *self {
+            Time::Empty => Instant::now(),
+            Time::Timer(ref t) => t.now(),
+        }
+    }
+
+    pub(crate) fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
+        match *self {
+            Time::Empty => {
+                panic!("You must supply a timer.")
+            }
+            Time::Timer(ref t) => t.reset(sleep, new_deadline),
+        }
+    }
+}
+
+mod private {
+    pub struct Sealed {}
+}

data/vendor/wreq/src/client/core/rt/tokio.rs

@@ -0,0 +1,99 @@
+//! Tokio IO integration for core.
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+    time::{Duration, Instant},
+};
+
+use pin_project_lite::pin_project;
+
+use super::{Executor, Sleep, Timer};
+
+/// Future executor that utilises `tokio` threads.
+#[non_exhaustive]
+#[derive(Default, Debug, Clone)]
+pub struct TokioExecutor {}
+
+/// A Timer that uses the tokio runtime.
+#[non_exhaustive]
+#[derive(Default, Clone, Debug)]
+pub struct TokioTimer;
+
+// Use TokioSleep to get tokio::time::Sleep to implement Unpin.
+// see https://docs.rs/tokio/latest/tokio/time/struct.Sleep.html
+pin_project! {
+    #[derive(Debug)]
+    struct TokioSleep {
+        #[pin]
+        inner: tokio::time::Sleep,
+    }
+}
+
+// ===== impl TokioExecutor =====
+
+impl<Fut> Executor<Fut> for TokioExecutor
+where
+    Fut: Future + Send + 'static,
+    Fut::Output: Send + 'static,
+{
+    fn execute(&self, fut: Fut) {
+        tokio::spawn(fut);
+    }
+}
+
+impl TokioExecutor {
+    /// Create new executor that relies on [`tokio::spawn`] to execute futures.
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+// ==== impl TokioTimer =====
+
+impl Timer for TokioTimer {
+    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
+        Box::pin(TokioSleep {
+            inner: tokio::time::sleep(duration),
+        })
+    }
+
+    fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
+        Box::pin(TokioSleep {
+            inner: tokio::time::sleep_until(deadline.into()),
+        })
+    }
+
+    fn now(&self) -> Instant {
+        tokio::time::Instant::now().into()
+    }
+
+    fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
+        if let Some(sleep) = sleep.as_mut().downcast_mut_pin::<TokioSleep>() {
+            sleep.reset(new_deadline)
+        }
+    }
+}
+
+impl TokioTimer {
+    /// Create a new TokioTimer
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Future for TokioSleep {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.project().inner.poll(cx)
+    }
+}
+
+impl Sleep for TokioSleep {}
+
+impl TokioSleep {
+    fn reset(self: Pin<&mut Self>, deadline: Instant) {
+        self.project().inner.as_mut().reset(deadline.into());
+    }
+}

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

@@ -0,0 +1,25 @@
+//! Runtime components
+//!
+//! The traits and types within this module are used to allow plugging in
+//! runtime types. These include:
+//!
+//! - Executors
+//! - Timers
+//! - IO transports
+
+pub mod bounds;
+mod timer;
+mod tokio;
+
+pub use self::{
+    timer::{ArcTimer, Sleep, Time, Timer},
+    tokio::{TokioExecutor, TokioTimer},
+};
+
+/// An executor of futures.
+///
+/// This trait allows abstract over async runtimes. Implement this trait for your own type.
+pub trait Executor<Fut> {
+    /// Place the future into the executor to be run.
+    fn execute(&self, fut: Fut);
+}

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

@@ -0,0 +1,267 @@
+//! HTTP Upgrades
+//!
+//! This module deals with managing [HTTP Upgrades][mdn] in crate::core:. Since
+//! several concepts in HTTP allow for first talking HTTP, and then converting
+//! to a different protocol, this module conflates them into a single API.
+//! Those include:
+//!
+//! - HTTP/1.1 Upgrades
+//! - HTTP `CONNECT`
+//!
+//! You are responsible for any other pre-requisites to establish an upgrade,
+//! such as sending the appropriate headers, methods, and status codes. You can
+//! then use [`on`][] to grab a `Future` which will resolve to the upgraded
+//! connection object, or an error if the upgrade fails.
+//!
+//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism
+//!
+//! Sending an HTTP upgrade from the client involves setting
+//! either the appropriate method, if wanting to `CONNECT`, or headers such as
+//! `Upgrade` and `Connection`, on the `http::Request`. Once receiving the
+//! `http::Response` back, you must check for the specific information that the
+//! upgrade is agreed upon by the server (such as a `101` status code), and then
+//! get the `Future` from the `Response`.
+
+use std::{
+    error::Error as StdError,
+    fmt,
+    future::Future,
+    io,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    sync::oneshot,
+};
+
+use super::{Error, Result, common::rewind::Rewind};
+use crate::sync::Mutex;
+
+/// An upgraded HTTP connection.
+///
+/// This type holds a trait object internally of the original IO that
+/// was used to speak HTTP before the upgrade. It can be used directly
+/// as a [`AsyncRead`] or [`AsyncWrite`] for convenience.
+///
+/// Alternatively, if the exact type is known, this can be deconstructed
+/// into its parts.
+pub struct Upgraded {
+    io: Rewind<Box<dyn Io + Send>>,
+}
+
+/// A future for a possible HTTP upgrade.
+///
+/// If no upgrade was available, or it doesn't succeed, yields an `Error`.
+#[derive(Clone)]
+pub struct OnUpgrade {
+    rx: Option<Arc<Mutex<oneshot::Receiver<Result<Upgraded>>>>>,
+}
+
+/// Gets a pending HTTP upgrade from this message.
+///
+/// This can be called on the following types:
+///
+/// - `http::Request<B>`
+/// - `http::Response<B>`
+/// - `&mut http::Request<B>`
+/// - `&mut http::Response<B>`
+#[inline]
+pub fn on<T: sealed::CanUpgrade>(msg: T) -> OnUpgrade {
+    msg.on_upgrade()
+}
+
+pub(super) struct Pending {
+    tx: oneshot::Sender<Result<Upgraded>>,
+}
+
+pub(super) fn pending() -> (Pending, OnUpgrade) {
+    let (tx, rx) = oneshot::channel();
+    (
+        Pending { tx },
+        OnUpgrade {
+            rx: Some(Arc::new(Mutex::new(rx))),
+        },
+    )
+}
+
+// ===== impl Upgraded =====
+
+impl Upgraded {
+    #[inline]
+    pub(super) fn new<T>(io: T, read_buf: Bytes) -> Self
+    where
+        T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    {
+        Upgraded {
+            io: Rewind::new_buffered(Box::new(io), read_buf),
+        }
+    }
+}
+
+impl AsyncRead for Upgraded {
+    #[inline]
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for Upgraded {
+    #[inline]
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write(cx, buf)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write_vectored(cx, bufs)
+    }
+
+    #[inline]
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_shutdown(cx)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        self.io.is_write_vectored()
+    }
+}
+
+impl fmt::Debug for Upgraded {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Upgraded").finish()
+    }
+}
+
+// ===== impl OnUpgrade =====
+
+impl OnUpgrade {
+    #[inline]
+    pub(super) fn none() -> Self {
+        OnUpgrade { rx: None }
+    }
+
+    #[inline]
+    pub(super) fn is_none(&self) -> bool {
+        self.rx.is_none()
+    }
+}
+
+impl Future for OnUpgrade {
+    type Output = std::result::Result<Upgraded, Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.rx {
+            Some(ref rx) => Pin::new(&mut *rx.lock()).poll(cx).map(|res| match res {
+                Ok(Ok(upgraded)) => Ok(upgraded),
+                Ok(Err(err)) => Err(err),
+                Err(_oneshot_canceled) => Err(Error::new_canceled().with(UpgradeExpected)),
+            }),
+            None => Poll::Ready(Err(Error::new_user_no_upgrade())),
+        }
+    }
+}
+
+// ===== impl Pending =====
+
+impl Pending {
+    #[inline]
+    pub(super) fn fulfill(self, upgraded: Upgraded) {
+        trace!("pending upgrade fulfill");
+        let _ = self.tx.send(Ok(upgraded));
+    }
+
+    /// Don't fulfill the pending Upgrade, but instead signal that
+    /// upgrades are handled manually.
+    #[inline]
+    pub(super) fn manual(self) {
+        trace!("pending upgrade handled manually");
+        let _ = self.tx.send(Err(Error::new_user_manual_upgrade()));
+    }
+}
+
+// ===== impl UpgradeExpected =====
+
+/// Error cause returned when an upgrade was expected but canceled
+/// for whatever reason.
+///
+/// This likely means the actual `Conn` future wasn't polled and upgraded.
+#[derive(Debug)]
+struct UpgradeExpected;
+
+impl fmt::Display for UpgradeExpected {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("upgrade expected but not completed")
+    }
+}
+
+impl StdError for UpgradeExpected {}
+
+// ===== impl Io =====
+
+trait Io: AsyncRead + AsyncWrite + Unpin + 'static {}
+
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Io for T {}
+
+impl dyn Io + Send {}
+
+mod sealed {
+    use super::OnUpgrade;
+
+    pub trait CanUpgrade {
+        fn on_upgrade(self) -> OnUpgrade;
+    }
+
+    impl<B> CanUpgrade for http::Request<B> {
+        fn on_upgrade(mut self) -> OnUpgrade {
+            self.extensions_mut()
+                .remove::<OnUpgrade>()
+                .unwrap_or_else(OnUpgrade::none)
+        }
+    }
+
+    impl<B> CanUpgrade for &'_ mut http::Request<B> {
+        fn on_upgrade(self) -> OnUpgrade {
+            self.extensions_mut()
+                .remove::<OnUpgrade>()
+                .unwrap_or_else(OnUpgrade::none)
+        }
+    }
+
+    impl<B> CanUpgrade for http::Response<B> {
+        fn on_upgrade(mut self) -> OnUpgrade {
+            self.extensions_mut()
+                .remove::<OnUpgrade>()
+                .unwrap_or_else(OnUpgrade::none)
+        }
+    }
+
+    impl<B> CanUpgrade for &'_ mut http::Response<B> {
+        fn on_upgrade(self) -> OnUpgrade {
+            self.extensions_mut()
+                .remove::<OnUpgrade>()
+                .unwrap_or_else(OnUpgrade::none)
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+//! HTTP Client protocol implementation and low level utilities.
+
+mod common;
+mod dispatch;
+mod error;
+mod proto;
+
+pub mod body;
+pub mod conn;
+pub mod ext;
+pub mod http1;
+pub mod http2;
+pub mod rt;
+pub mod upgrade;
+
+pub use self::error::{Error, Result};