wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/bench/http2.rs

@@ -0,0 +1,25 @@
+//! HTTP/2 benchmark
+
+mod support;
+
+use std::time::Duration;
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use support::{HttpVersion, Tls, bench};
+
+const NUM_REQUESTS_TO_SEND: usize = 500;
+
+#[inline]
+fn bench(c: &mut Criterion) {
+    bench::bench(c, Tls::Disabled, HttpVersion::Http2, NUM_REQUESTS_TO_SEND)
+        .expect("Failed to run HTTP/2 benchmark server")
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default()
+        .sample_size(10)
+        .warm_up_time(Duration::from_secs(3));
+    targets = bench
+);
+criterion_main!(benches);

data/vendor/wreq/bench/http2_over_tls.rs

@@ -0,0 +1,25 @@
+//! HTTP/2 over TLS benchmark
+
+mod support;
+
+use std::time::Duration;
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use support::{HttpVersion, Tls, bench};
+
+const NUM_REQUESTS_TO_SEND: usize = 500;
+
+#[inline]
+fn bench(c: &mut Criterion) {
+    bench::bench(c, Tls::Enabled, HttpVersion::Http2, NUM_REQUESTS_TO_SEND)
+        .expect("Failed to run HTTP/2 over TLS benchmark server")
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default()
+        .sample_size(10)
+        .warm_up_time(Duration::from_secs(3));
+    targets = bench
+);
+criterion_main!(benches);

data/vendor/wreq/bench/support/bench.rs

@@ -0,0 +1,91 @@
+use criterion::Criterion;
+
+use crate::support::{
+    BoxError, HttpVersion, Tls, client::bench_clients, current_thread_runtime,
+    multi_thread_runtime, server::with_server,
+};
+
+pub const CURRENT_THREAD_LABEL: &str = "current_thread";
+pub const MULTI_THREAD_LABEL: &str = "multi_thread";
+pub const CONCURRENT_CASES: &[usize] = &[10, 50, 100, 150];
+
+/// Recommended chunk sizes for real-world network scenarios:
+///   - 16 KB: Matches standard TCP buffers, ideal for HTTP/2 frames.
+///   - 32 KB: For large HTTP payloads, fits modern socket buffers.
+///   - 64 KB: Default Linux buffer size, optimized for large uploads.
+///   - 128 KB: For high-throughput, large-scale transfers.
+///   - 256 KB: Bulk data, maximum throughput on fast networks.
+///
+/// For benchmarking latency-sensitive and high-throughput transfers.
+pub const BODY_CASES: [(&[u8], usize); 7] = [
+    (&[b'a'; 1024], 1024),                  // 1 KB, chunk 1 KB
+    (&[b'a'; 10 * 1024], 10 * 1024),        // 10 KB, chunk 10 KB
+    (&[b'a'; 64 * 1024], 16 * 1024),        // 64 KB, chunk 16 KB
+    (&[b'a'; 128 * 1024], 32 * 1024),       // 128 KB, chunk 32 KB
+    (&[b'a'; 1024 * 1024], 64 * 1024),      // 1 MB, chunk 64 KB
+    (&[b'a'; 2 * 1024 * 1024], 128 * 1024), // 2 MB, chunk 128 KB
+    (&[b'a'; 4 * 1024 * 1024], 256 * 1024), // 4 MB, chunk 256 KB
+];
+
+pub fn bench(
+    c: &mut Criterion,
+    tls: Tls,
+    http_version: HttpVersion,
+    num_requests: usize,
+) -> Result<(), BoxError> {
+    const OS: &str = std::env::consts::OS;
+    const ARCH: &str = std::env::consts::ARCH;
+
+    let system = sysinfo::System::new_all();
+    let cpu_model = system
+        .cpus()
+        .first()
+        .map_or("n/a", |cpu| cpu.brand().trim_start().trim_end());
+
+    for &concurrent_limit in CONCURRENT_CASES {
+        for body in BODY_CASES {
+            with_server(tls, |addr| {
+                // single-threaded client
+                let mut group = c.benchmark_group(format!(
+                    "{cpu_model}/{OS}_{ARCH}/{CURRENT_THREAD_LABEL}/{tls}/{http_version}/{concurrent_limit}/{}KB",
+                    body.0.len() / 1024,
+                ));
+
+                bench_clients(
+                    &mut group,
+                    current_thread_runtime,
+                    addr,
+                    tls,
+                    http_version,
+                    num_requests,
+                    concurrent_limit,
+                    body,
+                )?;
+                group.finish();
+                Ok(())
+            })?;
+
+            with_server(tls, |addr| {
+                // multi-threaded client
+                let mut group = c.benchmark_group(format!(
+                    "{cpu_model}/{OS}_{ARCH}/{MULTI_THREAD_LABEL}/{tls}/{http_version}/{concurrent_limit}/{}KB",
+                    body.0.len() / 1024,
+                ));
+                bench_clients(
+                    &mut group,
+                    multi_thread_runtime,
+                    addr,
+                    tls,
+                    http_version,
+                    num_requests,
+                    concurrent_limit,
+                    body,
+                )?;
+                group.finish();
+                Ok(())
+            })?;
+        }
+    }
+
+    Ok(())
+}

data/vendor/wreq/bench/support/client.rs

@@ -0,0 +1,217 @@
+use std::{convert::Infallible, net::SocketAddr, sync::Arc};
+
+use bytes::Bytes;
+use criterion::{BenchmarkGroup, measurement::WallTime};
+use http_body_util::BodyExt;
+use tokio::{runtime::Runtime, sync::Semaphore};
+
+use super::{BoxError, HttpVersion, Tls};
+
+fn create_wreq_client(tls: Tls, http_version: HttpVersion) -> Result<wreq::Client, BoxError> {
+    let builder = wreq::Client::builder()
+        .no_proxy()
+        .redirect(wreq::redirect::Policy::none())
+        .tls_cert_verification(!matches!(tls, Tls::Enabled));
+
+    let builder = match http_version {
+        HttpVersion::Http1 => builder.http1_only(),
+        HttpVersion::Http2 => builder.http2_only(),
+    };
+
+    Ok(builder.build()?)
+}
+
+fn create_reqwest_client(tls: Tls, http_version: HttpVersion) -> Result<reqwest::Client, BoxError> {
+    let builder = reqwest::Client::builder()
+        .no_proxy()
+        .redirect(reqwest::redirect::Policy::none())
+        .danger_accept_invalid_certs(matches!(tls, Tls::Enabled));
+
+    let builder = match http_version {
+        HttpVersion::Http1 => builder.http1_only(),
+        HttpVersion::Http2 => builder.http2_prior_knowledge(),
+    };
+
+    Ok(builder.build()?)
+}
+
+async fn wreq_body_assert(mut response: wreq::Response, expected_body_size: usize) {
+    let mut body_size = 0;
+    while let Some(Ok(chunk)) = response.frame().await {
+        if let Ok(chunk) = chunk.into_data() {
+            body_size += chunk.len();
+        }
+    }
+    assert!(
+        body_size == expected_body_size,
+        "Unexpected response body: got {body_size} bytes, expected {expected_body_size} bytes"
+    );
+}
+
+async fn reqwest_body_assert(mut response: reqwest::Response, expected_body_size: usize) {
+    let mut body_size = 0;
+    while let Ok(Some(chunk)) = response.chunk().await {
+        body_size += chunk.len();
+    }
+    assert!(
+        body_size == expected_body_size,
+        "Unexpected response body: got {body_size} bytes, expected {expected_body_size} bytes"
+    );
+}
+
+fn stream_from_bytes(
+    body: &'static [u8],
+    chunk_size: usize,
+) -> impl futures_util::stream::TryStream<Ok = Bytes, Error = Infallible> + Send + 'static {
+    futures_util::stream::unfold((body, 0), move |(body, offset)| async move {
+        if offset >= body.len() {
+            None
+        } else {
+            let end = (offset + chunk_size).min(body.len());
+            let chunk = Bytes::from_static(&body[offset..end]);
+            Some((Ok::<Bytes, Infallible>(chunk), (body, end)))
+        }
+    })
+}
+
+#[inline]
+fn wreq_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> wreq::Body {
+    if stream {
+        let stream = stream_from_bytes(body, chunk_size);
+        wreq::Body::wrap_stream(stream)
+    } else {
+        wreq::Body::from(body)
+    }
+}
+
+#[inline]
+fn reqwest_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> reqwest::Body {
+    if stream {
+        let stream = stream_from_bytes(body, chunk_size);
+        reqwest::Body::wrap_stream(stream)
+    } else {
+        reqwest::Body::from(body)
+    }
+}
+
+async fn wreq_requests_concurrent(
+    client: &wreq::Client,
+    url: &str,
+    num_requests: usize,
+    concurrent_limit: usize,
+    body: (&'static [u8], usize),
+    stream: bool,
+) {
+    let semaphore = Arc::new(Semaphore::new(concurrent_limit));
+    let mut handles = Vec::with_capacity(num_requests);
+    for _ in 0..num_requests {
+        let client = client.clone();
+        let url = url.to_string();
+        let semaphore = semaphore.clone();
+        let fut = async move {
+            let _permit = semaphore
+                .acquire()
+                .await
+                .expect("Semaphore should be acquirable");
+            let response = client
+                .post(url)
+                .body(wreq_body(stream, body))
+                .send()
+                .await
+                .expect("Unexpected request failure");
+            wreq_body_assert(response, body.0.len()).await;
+        };
+        handles.push(tokio::spawn(fut));
+    }
+    futures_util::future::join_all(handles).await;
+}
+
+async fn reqwest_requests_concurrent(
+    client: &reqwest::Client,
+    url: &str,
+    num_requests: usize,
+    concurrent_limit: usize,
+    body: (&'static [u8], usize),
+    stream: bool,
+) {
+    let semaphore = Arc::new(Semaphore::new(concurrent_limit));
+    let mut handles = Vec::with_capacity(num_requests);
+    for _ in 0..num_requests {
+        let client = client.clone();
+        let url = url.to_string();
+        let semaphore = semaphore.clone();
+        let fut = async move {
+            let _permit = semaphore
+                .acquire()
+                .await
+                .expect("Semaphore should be acquirable");
+            let response = client
+                .post(url)
+                .body(reqwest_body(stream, body))
+                .send()
+                .await
+                .expect("Unexpected request failure");
+            reqwest_body_assert(response, body.0.len()).await;
+        };
+        handles.push(tokio::spawn(fut));
+    }
+    futures_util::future::join_all(handles).await;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn bench_clients(
+    group: &mut BenchmarkGroup<'_, WallTime>,
+    rt: fn() -> Runtime,
+    addr: SocketAddr,
+    tls: Tls,
+    http_version: HttpVersion,
+    num_requests: usize,
+    concurrent_limit: usize,
+    body: (&'static [u8], usize),
+) -> Result<(), BoxError> {
+    let url = format!("{tls}://{addr}");
+
+    fn make_benchmark_label<T: ?Sized>(stream: bool) -> String {
+        let client = std::any::type_name::<T>()
+            .split("::")
+            .next()
+            .expect("Type name should contain at least one segment");
+
+        let body_type = if stream { "stream" } else { "full" };
+        format!("{body_type}/{client}")
+    }
+
+    for stream in [false, true] {
+        let client = create_wreq_client(tls, http_version)?;
+        group.bench_function(make_benchmark_label::<wreq::Client>(stream), |b| {
+            b.to_async(rt()).iter(|| {
+                wreq_requests_concurrent(
+                    &client,
+                    &url,
+                    num_requests,
+                    concurrent_limit,
+                    body,
+                    stream,
+                )
+            })
+        });
+        ::std::mem::drop(client);
+
+        let client = create_reqwest_client(tls, http_version)?;
+        group.bench_function(make_benchmark_label::<reqwest::Client>(stream), |b| {
+            b.to_async(rt()).iter(|| {
+                reqwest_requests_concurrent(
+                    &client,
+                    &url,
+                    num_requests,
+                    concurrent_limit,
+                    body,
+                    stream,
+                )
+            })
+        });
+        ::std::mem::drop(client);
+    }
+
+    Ok(())
+}

data/vendor/wreq/bench/support/server.rs

@@ -0,0 +1,188 @@
+use std::{convert::Infallible, io, net::SocketAddr, pin::Pin, sync::Arc, time::Duration};
+
+use btls::{
+    pkey::PKey,
+    ssl::{Ssl, SslAcceptor, SslMethod},
+    x509::X509,
+};
+use bytes::Bytes;
+use http_body_util::{BodyExt, Collected, Full};
+use hyper::{body::Incoming, service::service_fn};
+use hyper_util::{
+    rt::{TokioExecutor, TokioIo, TokioTimer},
+    server::conn::auto::Builder,
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    net::{TcpListener, TcpStream},
+    sync::oneshot,
+    task::JoinSet,
+};
+use tokio_btls::SslStream;
+
+use super::{BoxError, Tls, multi_thread_runtime};
+
+pub struct Server {
+    listener: std::net::TcpListener,
+    tls_acceptor: Option<Arc<SslAcceptor>>,
+    builder: Builder<TokioExecutor>,
+}
+
+impl Server {
+    pub fn new(tls: Tls) -> Result<Self, BoxError> {
+        let tls_acceptor = match tls {
+            Tls::Enabled => {
+                let mut builder = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls())?;
+
+                let cert = X509::from_der(include_bytes!("../../tests/support/server.cert"))?;
+                let key =
+                    PKey::private_key_from_der(include_bytes!("../../tests/support/server.key"))?;
+
+                builder.set_certificate(&cert)?;
+                builder.set_private_key(&key)?;
+                builder.check_private_key()?;
+
+                Some(Arc::new(builder.build()))
+            }
+            Tls::Disabled => None,
+        };
+
+        let mut builder = Builder::new(TokioExecutor::new());
+        builder.http1().timer(TokioTimer::new()).keep_alive(true);
+        builder
+            .http2()
+            .timer(TokioTimer::new())
+            .keep_alive_interval(Duration::from_secs(30));
+
+        let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
+        listener.set_nonblocking(true)?;
+
+        Ok(Server {
+            listener,
+            tls_acceptor,
+            builder,
+        })
+    }
+
+    fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.listener.local_addr()
+    }
+
+    async fn run(self, mut shutdown: oneshot::Receiver<()>) -> Result<(), BoxError> {
+        let mut join_set = JoinSet::new();
+        let listener = TcpListener::from_std(self.listener)?;
+
+        loop {
+            tokio::select! {
+                _ = &mut shutdown => {
+                    break;
+                }
+                accept = listener.accept() => {
+                    if let Ok((socket, _peer_addr)) = accept {
+                        let tls_acceptor = self.tls_acceptor.clone();
+                        let builder = self.builder.clone();
+                        join_set.spawn(async move {
+                            handle_connection(socket, tls_acceptor, builder).await;
+                        });
+                    }
+                }
+            }
+        }
+
+        while let Some(result) = join_set.join_next().await {
+            if let Err(e) = result {
+                eprintln!("connection task failed: {e}");
+            }
+        }
+
+        // Tokio internally accepts TCP connections while the TCPListener is active;
+        // drop the listener to immediately refuse connections rather than letting
+        // them hang.
+        ::std::mem::drop(listener);
+        Ok(())
+    }
+}
+
+pub struct Handle {
+    shutdown: oneshot::Sender<()>,
+    join: std::thread::JoinHandle<()>,
+}
+
+impl Handle {
+    pub fn shutdown(self) {
+        let _ = self.shutdown.send(());
+        let _ = self.join.join();
+    }
+}
+
+pub fn with_server<F>(tls: Tls, f: F) -> Result<(), BoxError>
+where
+    F: FnOnce(SocketAddr) -> Result<(), BoxError>,
+{
+    let server = Server::new(tls)?;
+    let addr = server.local_addr()?;
+
+    let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+    let join = std::thread::spawn(move || {
+        let rt = multi_thread_runtime();
+        rt.block_on(server.run(shutdown_rx))
+            .expect("Failed to run server with shutdown");
+    });
+
+    std::thread::sleep(Duration::from_millis(100));
+
+    let handle = Handle {
+        shutdown: shutdown_tx,
+        join,
+    };
+
+    f(addr)?;
+    handle.shutdown();
+
+    std::thread::sleep(Duration::from_millis(100));
+    Ok(())
+}
+
+async fn serve<S>(builder: Builder<TokioExecutor>, stream: S)
+where
+    S: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+    let _ = builder
+        .serve_connection(
+            TokioIo::new(stream),
+            service_fn(|req: http::Request<Incoming>| async {
+                let bytes = req
+                    .into_body()
+                    .collect()
+                    .await
+                    .map(Collected::<Bytes>::to_bytes);
+                let bytes = bytes.unwrap_or_else(|_| Bytes::new());
+                Ok::<_, Infallible>(http::Response::new(Full::new(bytes)))
+            }),
+        )
+        .await;
+}
+
+async fn handle_connection(
+    socket: TcpStream,
+    tls_acceptor: Option<Arc<SslAcceptor>>,
+    builder: Builder<TokioExecutor>,
+) {
+    if let Some(acceptor) = tls_acceptor {
+        let ssl = Ssl::new(acceptor.context()).expect("failed to create Ssl");
+        let mut stream = SslStream::new(ssl, socket).expect("failed to create SslStream");
+
+        // The client (or its connection pool) may proactively close the connection,
+        // especially during benchmarks or when cleaning up idle connections.
+        // This can cause TLS handshake failures (e.g., ConnectionReset, ConnectionAborted).
+        // Such errors are expected and should be handled gracefully to avoid panicking
+        // and to ensure the server remains robust under load.
+        if Pin::new(&mut stream).accept().await.is_err() {
+            return;
+        }
+        serve(builder, stream).await;
+    } else {
+        serve(builder, socket).await;
+    }
+}

data/vendor/wreq/bench/support.rs

@@ -0,0 +1,56 @@
+pub mod bench;
+pub mod client;
+pub mod server;
+
+use std::fmt;
+
+pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
+
+#[allow(unused)]
+#[derive(Clone, Copy, Debug)]
+pub enum HttpVersion {
+    Http1,
+    Http2,
+}
+
+impl fmt::Display for HttpVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = match self {
+            HttpVersion::Http1 => "h1",
+            HttpVersion::Http2 => "h2",
+        };
+        f.write_str(value)
+    }
+}
+
+#[allow(unused)]
+#[derive(Clone, Copy, Debug)]
+pub enum Tls {
+    Enabled,
+    Disabled,
+}
+
+impl fmt::Display for Tls {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = match self {
+            Tls::Enabled => "https",
+            Tls::Disabled => "http",
+        };
+        f.write_str(value)
+    }
+}
+
+pub fn current_thread_runtime() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to build current-thread runtime")
+}
+
+pub fn multi_thread_runtime() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(4)
+        .enable_all()
+        .build()
+        .expect("Failed to build multi-thread runtime")
+}

data/vendor/wreq/examples/cert_store.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use wreq::{
     Client,
-    tls::{CertStore, TlsInfo},
+    tls::{TlsInfo, trust::CertStore},
 };
 
 /// Certificate Store Example
@@ -39,7 +39,7 @@ use wreq::{
 async fn main() -> wreq::Result<()> {
     // Create a client with a custom certificate store using webpki-roots
     let client = Client::builder()
-        .cert_store(CertStore::from_der_certs(
+        .tls_cert_store(CertStore::from_der_certs(
             webpki_root_certs::TLS_SERVER_ROOT_CERTS,
         )?)
         .build()?;
@@ -51,7 +51,7 @@ async fn main() -> wreq::Result<()> {
     // Skip certificate verification for self-signed certificates
     let client = Client::builder()
         .tls_info(true)
-        .cert_verification(false)
+        .tls_cert_verification(false)
         .build()?;
 
     // Use the API you're already familiar with
@@ -63,7 +63,7 @@ async fn main() -> wreq::Result<()> {
 
             // Create a client with self-signed certificate store
             let client = Client::builder()
-                .cert_store(self_signed_store)
+                .tls_cert_store(self_signed_store)
                 .connect_timeout(Duration::from_secs(10))
                 .build()?;
 

data/vendor/wreq/examples/{emulation.rs → emulate.rs}

@@ -102,12 +102,12 @@ async fn main() -> wreq::Result<()> {
         .http2_options(http2)
         .headers(headers)
         .orig_headers(orig_headers)
-        .build();
+        .build(Default::default());
 
     // Build a client with emulation config
     let client = Client::builder()
         .emulation(emulation)
-        .cert_verification(false)
+        .tls_cert_verification(false)
         .build()?;
 
     // Use the API you're already familiar with

data/vendor/wreq/examples/http2_websocket.rs

@@ -6,13 +6,13 @@
 //! ```
 
 use futures_util::{SinkExt, StreamExt, TryStreamExt};
-use wreq::{header, ws::message::Message};
+use wreq::{Version, header, ws::message::Message};
 
 #[tokio::main]
 async fn main() -> wreq::Result<()> {
     // Use the API you're already familiar with
     let resp = wreq::websocket("wss://127.0.0.1:3000/ws")
-        .force_http2()
+        .version(Version::HTTP_2)
         .header(header::USER_AGENT, env!("CARGO_PKG_NAME"))
         .read_buffer_size(1024 * 1024)
         .send()

data/vendor/wreq/examples/keylog.rs

@@ -1,11 +1,11 @@
-use wreq::tls::KeyLog;
+use wreq::tls::keylog::KeyLog;
 
 #[tokio::main]
 async fn main() -> wreq::Result<()> {
     // Build a client
     let client = wreq::Client::builder()
-        .keylog(KeyLog::from_file("keylog.txt"))
-        .cert_verification(false)
+        .tls_keylog(KeyLog::from_file("keylog.txt"))
+        .tls_cert_verification(false)
         .build()?;
 
     // Use the API you're already familiar with