wreq-rb 0.3.0

data/vendor/wreq/examples/request_with_emulation.rs

@@ -0,0 +1,115 @@
+use wreq::{
+    Emulation,
+    header::{self, HeaderMap, HeaderValue, OrigHeaderMap},
+    http2::{Http2Options, PseudoId, PseudoOrder},
+    tls::{AlpnProtocol, TlsOptions, TlsVersion},
+};
+
+macro_rules! join {
+    ($sep:expr, $first:expr $(, $rest:expr)*) => {
+        concat!($first $(, $sep, $rest)*)
+    };
+}
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::TRACE)
+        .init();
+
+    //  TLS options config
+    let tls = TlsOptions::builder()
+        .enable_ocsp_stapling(true)
+        .curves_list(join!(":", "X25519", "P-256", "P-384"))
+        .cipher_list(join!(
+            ":",
+            "TLS_AES_128_GCM_SHA256",
+            "TLS_AES_256_GCM_SHA384",
+            "TLS_CHACHA20_POLY1305_SHA256",
+            "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+            "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
+            "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+            "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+            "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+        ))
+        .sigalgs_list(join!(
+            ":",
+            "ecdsa_secp256r1_sha256",
+            "rsa_pss_rsae_sha256",
+            "rsa_pkcs1_sha256",
+            "ecdsa_secp384r1_sha384",
+            "rsa_pss_rsae_sha384",
+            "rsa_pkcs1_sha384",
+            "rsa_pss_rsae_sha512",
+            "rsa_pkcs1_sha512",
+            "rsa_pkcs1_sha1"
+        ))
+        .alpn_protocols([AlpnProtocol::HTTP2, AlpnProtocol::HTTP1])
+        .min_tls_version(TlsVersion::TLS_1_2)
+        .max_tls_version(TlsVersion::TLS_1_3)
+        .build();
+
+    // HTTP/2 options config
+    let http2 = Http2Options::builder()
+        .initial_stream_id(3)
+        .initial_window_size(16777216)
+        .initial_connection_window_size(16711681 + 65535)
+        .headers_pseudo_order(
+            PseudoOrder::builder()
+                .extend([
+                    PseudoId::Method,
+                    PseudoId::Path,
+                    PseudoId::Authority,
+                    PseudoId::Scheme,
+                ])
+                .build(),
+        )
+        .build();
+
+    // Default headers
+    let headers = {
+        let mut headers = HeaderMap::new();
+        headers.insert(header::USER_AGENT, HeaderValue::from_static("TwitterAndroid/10.89.0-release.0 (310890000-r-0) G011A/9 (google;G011A;google;G011A;0;;1;2016)"));
+        headers.insert(header::ACCEPT_LANGUAGE, HeaderValue::from_static("en-US"));
+        headers.insert(
+            header::ACCEPT_ENCODING,
+            HeaderValue::from_static("br, gzip, deflate"),
+        );
+        headers.insert(header::ACCEPT, HeaderValue::from_static("application/json"));
+        headers.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+        headers.insert(
+            header::COOKIE,
+            HeaderValue::from_static("ct0=YOUR_CT0_VALUE;"),
+        );
+        headers
+    };
+
+    // The headers keep the original case and order
+    let orig_headers = {
+        let mut orig_headers = OrigHeaderMap::new();
+        orig_headers.insert("cookie");
+        orig_headers.insert("content-length");
+        orig_headers.insert("User-Agent");
+        orig_headers.insert("Accept-Language");
+        orig_headers.insert("Accept-Encoding");
+        orig_headers
+    };
+
+    // This provider encapsulates TLS, HTTP/1, HTTP/2, default headers, and original headers
+    let emulation = Emulation::builder()
+        .tls_options(tls)
+        .http2_options(http2)
+        .headers(headers)
+        .orig_headers(orig_headers)
+        .build();
+
+    // Use the API you're already familiar with
+    let resp = wreq::get("https://tls.peet.ws/api/all")
+        .emulation(emulation)
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/examples/request_with_interface.rs

@@ -0,0 +1,37 @@
+#[cfg(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "solaris",
+    target_os = "tvos",
+    target_os = "visionos",
+    target_os = "watchos",
+))]
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Use the API you're already familiar with
+    let resp = wreq::get("https://api.ip.sb/ip")
+        .interface("utun4")
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}
+
+#[cfg(not(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "solaris",
+    target_os = "tvos",
+    target_os = "visionos",
+    target_os = "watchos",
+)))]
+fn main() {}

data/vendor/wreq/examples/request_with_local_address.rs

@@ -0,0 +1,16 @@
+use std::net::IpAddr;
+
+use wreq::redirect::Policy;
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Use the API you're already familiar with
+    let resp = wreq::get("http://www.baidu.com")
+        .redirect(Policy::default())
+        .local_address(IpAddr::from([192, 168, 1, 226]))
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/examples/request_with_proxy.rs

@@ -0,0 +1,13 @@
+use wreq::Proxy;
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Use the API you're already familiar with
+    let resp = wreq::get("https://api.ip.sb/ip")
+        .proxy(Proxy::all("socks5h://localhost:6153")?)
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/examples/request_with_redirect.rs

@@ -0,0 +1,22 @@
+use wreq::redirect::Policy;
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Use the API you're already familiar with
+    let resp = wreq::get("https://google.com/")
+        .redirect(Policy::custom(|attempt| {
+            // we can inspect the redirect attempt
+            println!(
+                "Redirecting (status: {}) to {:?} and headers: {:#?}",
+                attempt.status, attempt.uri, attempt.headers
+            );
+
+            // we can follow redirects as normal
+            attempt.follow()
+        }))
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/examples/request_with_version.rs

@@ -0,0 +1,15 @@
+use http::Version;
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Use the API you're already familiar with
+    let resp = wreq::get("https://www.google.com")
+        .version(Version::HTTP_11)
+        .send()
+        .await?;
+
+    assert_eq!(resp.version(), Version::HTTP_11);
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/examples/tor_socks.rs

@@ -0,0 +1,24 @@
+#![deny(warnings)]
+
+// This is using the `tokio` runtime. You'll need the following dependency:
+//
+// `tokio = { version = "1", features = ["full"] }`
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Make sure you are running tor and this is your socks port
+    let proxy = wreq::Proxy::all("socks5h://127.0.0.1:9050").expect("tor proxy should be there");
+    let client = wreq::Client::builder()
+        .proxy(proxy)
+        .build()
+        .expect("should be able to build wreq client");
+
+    let res = client.get("https://check.torproject.org").send().await?;
+    println!("Status: {}", res.status());
+
+    let text = res.text().await?;
+    let is_tor = text.contains("Congratulations. This emulation is configured to use Tor.");
+    println!("Is Tor: {is_tor}");
+    assert!(is_tor);
+
+    Ok(())
+}

data/vendor/wreq/examples/unix_socket.rs

@@ -0,0 +1,33 @@
+#[cfg(unix)]
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Create a Unix socket proxy
+    let proxy = wreq::Proxy::unix("/var/run/docker.sock")?;
+
+    // Build a client
+    let client = wreq::Client::builder()
+        // Specify the Unix socket path
+        .proxy(proxy.clone())
+        .timeout(std::time::Duration::from_secs(10))
+        .build()?;
+
+    // Use the API you're already familiar with
+    let resp = client
+        .get("http://localhost/v1.41/containers/json")
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    // Or specify the Unix socket directly in the request
+    let resp = client
+        .get("http://localhost/v1.41/containers/json")
+        .proxy(proxy)
+        .send()
+        .await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}
+
+#[cfg(not(unix))]
+fn main() {}

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

@@ -0,0 +1,304 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+
+use bytes::Bytes;
+use http_body::{Body as HttpBody, SizeHint};
+use http_body_util::{BodyExt, Either, combinators::BoxBody};
+use pin_project_lite::pin_project;
+#[cfg(feature = "stream")]
+use {tokio::fs::File, tokio_util::io::ReaderStream};
+
+use crate::error::{BoxError, Error};
+
+/// An request body.
+#[derive(Debug)]
+pub struct Body(Either<Bytes, BoxBody<Bytes, BoxError>>);
+
+pin_project! {
+    /// We can't use `map_frame()` because that loses the hint data (for good reason).
+    /// But we aren't transforming the data.
+    struct IntoBytesBody<B> {
+        #[pin]
+        inner: B,
+    }
+}
+
+// ===== impl Body =====
+
+impl Body {
+    /// Returns a reference to the internal data of the `Body`.
+    ///
+    /// `None` is returned, if the underlying data is a stream.
+    pub fn as_bytes(&self) -> Option<&[u8]> {
+        match &self.0 {
+            Either::Left(bytes) => Some(bytes.as_ref()),
+            Either::Right(..) => None,
+        }
+    }
+
+    /// Wrap a [`HttpBody`] in a box inside `Body`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::Body;
+    /// # use futures_util;
+    /// # fn main() {
+    /// let content = "hello,world!".to_string();
+    ///
+    /// let body = Body::wrap(content);
+    /// # }
+    /// ```
+    pub fn wrap<B>(inner: B) -> Body
+    where
+        B: HttpBody + Send + Sync + 'static,
+        B::Data: Into<Bytes>,
+        B::Error: Into<BoxError>,
+    {
+        Body(Either::Right(
+            IntoBytesBody { inner }.map_err(Into::into).boxed(),
+        ))
+    }
+
+    /// Wrap a futures `Stream` in a box inside `Body`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::Body;
+    /// # use futures_util;
+    /// # fn main() {
+    /// let chunks: Vec<Result<_, ::std::io::Error>> = vec![Ok("hello"), Ok(" "), Ok("world")];
+    ///
+    /// let stream = futures_util::stream::iter(chunks);
+    ///
+    /// let body = Body::wrap_stream(stream);
+    /// # }
+    /// ```
+    ///
+    /// # Optional
+    ///
+    /// This requires the `stream` feature to be enabled.
+    #[cfg(feature = "stream")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stream")))]
+    pub fn wrap_stream<S>(stream: S) -> Body
+    where
+        S: futures_util::stream::TryStream + Send + 'static,
+        S::Error: Into<BoxError>,
+        Bytes: From<S::Ok>,
+    {
+        Body::stream(stream)
+    }
+
+    #[cfg(any(feature = "stream", feature = "multipart"))]
+    pub(crate) fn stream<S>(stream: S) -> Body
+    where
+        S: futures_util::stream::TryStream + Send + 'static,
+        S::Error: Into<BoxError>,
+        Bytes: From<S::Ok>,
+    {
+        use futures_util::TryStreamExt;
+        use http_body::Frame;
+        use http_body_util::StreamBody;
+        use sync_wrapper::SyncStream;
+
+        let body = StreamBody::new(SyncStream::new(
+            stream
+                .map_ok(Bytes::from)
+                .map_ok(Frame::data)
+                .map_err(Into::into),
+        ));
+        Body(Either::Right(body.boxed()))
+    }
+
+    #[inline]
+    pub(crate) fn empty() -> Body {
+        Body::reusable(Bytes::new())
+    }
+
+    #[inline]
+    pub(crate) fn reusable(chunk: Bytes) -> Body {
+        Body(Either::Left(chunk))
+    }
+
+    #[cfg(feature = "multipart")]
+    pub(crate) fn content_length(&self) -> Option<u64> {
+        match self.0 {
+            Either::Left(ref bytes) => Some(bytes.len() as u64),
+            Either::Right(ref body) => body.size_hint().exact(),
+        }
+    }
+
+    pub(crate) fn try_clone(&self) -> Option<Body> {
+        match self.0 {
+            Either::Left(ref chunk) => Some(Body::reusable(chunk.clone())),
+            Either::Right { .. } => None,
+        }
+    }
+}
+
+impl Default for Body {
+    #[inline]
+    fn default() -> Body {
+        Body::empty()
+    }
+}
+
+impl From<BoxBody<Bytes, BoxError>> for Body {
+    #[inline]
+    fn from(body: BoxBody<Bytes, BoxError>) -> Self {
+        Self(Either::Right(body))
+    }
+}
+
+impl From<Bytes> for Body {
+    #[inline]
+    fn from(bytes: Bytes) -> Body {
+        Body::reusable(bytes)
+    }
+}
+
+impl From<Vec<u8>> for Body {
+    #[inline]
+    fn from(vec: Vec<u8>) -> Body {
+        Body::reusable(vec.into())
+    }
+}
+
+impl From<&'static [u8]> for Body {
+    #[inline]
+    fn from(s: &'static [u8]) -> Body {
+        Body::reusable(Bytes::from_static(s))
+    }
+}
+
+impl From<String> for Body {
+    #[inline]
+    fn from(s: String) -> Body {
+        Body::reusable(s.into())
+    }
+}
+
+impl From<&'static str> for Body {
+    #[inline]
+    fn from(s: &'static str) -> Body {
+        s.as_bytes().into()
+    }
+}
+
+#[cfg(feature = "stream")]
+impl From<File> for Body {
+    #[inline]
+    fn from(file: File) -> Body {
+        Body::wrap_stream(ReaderStream::new(file))
+    }
+}
+
+impl HttpBody for Body {
+    type Data = Bytes;
+    type Error = Error;
+
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        match self.0 {
+            Either::Left(ref mut bytes) => {
+                let out = bytes.split_off(0);
+                if out.is_empty() {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Ready(Some(Ok(http_body::Frame::data(out))))
+                }
+            }
+            Either::Right(ref mut body) => {
+                Poll::Ready(ready!(Pin::new(body).poll_frame(cx)).map(|opt_chunk| {
+                    opt_chunk.map_err(|err| match err.downcast::<Error>() {
+                        Ok(err) => *err,
+                        Err(err) => Error::body(err),
+                    })
+                }))
+            }
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> SizeHint {
+        match self.0 {
+            Either::Left(ref bytes) => SizeHint::with_exact(bytes.len() as u64),
+            Either::Right(ref body) => body.size_hint(),
+        }
+    }
+
+    #[inline]
+    fn is_end_stream(&self) -> bool {
+        match self.0 {
+            Either::Left(ref bytes) => bytes.is_empty(),
+            Either::Right(ref body) => body.is_end_stream(),
+        }
+    }
+}
+
+// ===== impl IntoBytesBody =====
+
+impl<B> HttpBody for IntoBytesBody<B>
+where
+    B: HttpBody,
+    B::Data: Into<Bytes>,
+{
+    type Data = Bytes;
+    type Error = B::Error;
+
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        match ready!(self.project().inner.poll_frame(cx)) {
+            Some(Ok(f)) => Poll::Ready(Some(Ok(f.map_data(Into::into)))),
+            Some(Err(e)) => Poll::Ready(Some(Err(e))),
+            None => Poll::Ready(None),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> SizeHint {
+        self.inner.size_hint()
+    }
+
+    #[inline]
+    fn is_end_stream(&self) -> bool {
+        self.inner.is_end_stream()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use http_body::Body as _;
+
+    use super::Body;
+
+    #[test]
+    fn test_as_bytes() {
+        let test_data = b"Test body";
+        let body = Body::from(&test_data[..]);
+        assert_eq!(body.as_bytes(), Some(&test_data[..]));
+    }
+
+    #[test]
+    fn body_exact_length() {
+        let empty_body = Body::empty();
+        assert!(empty_body.is_end_stream());
+        assert_eq!(empty_body.size_hint().exact(), Some(0));
+
+        let bytes_body = Body::reusable("abc".into());
+        assert!(!bytes_body.is_end_stream());
+        assert_eq!(bytes_body.size_hint().exact(), Some(3));
+
+        // can delegate even when wrapped
+        let stream_body = Body::wrap(empty_body);
+        assert!(stream_body.is_end_stream());
+        assert_eq!(stream_body.size_hint().exact(), Some(0));
+    }
+}