wreq-rb 0.6.0 → 0.6.2

data/ext/wreq_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wreq_rb"
-version = "0.6.0"
+version = "0.6.2"
 edition = "2021"
 publish = false
 
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
-wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
+wreq = { path = "../../vendor/wreq", version = "=0.16.1", features = [
   "cookies",
   "json",
   "gzip",
@@ -24,14 +24,17 @@ wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
   "query",
   "form",
 ] }
-wreq-util = { version = "=3.0.0-rc.12", features = ["emulation", "emulation-serde", "emulation-compression"] }
+wreq-util = { version = "=0.2.0", features = ["emulation", "emulation-serde", "emulation-compression"] }
 tokio = { version = "1", features = ["full"] }
 tokio-util = "0.7"
 serde_json = "1.0"
 bytes = "1"
 http = "1"
 
+[dev-dependencies]
+magnus = { version = "0.8", features = ["embed"] }
+
 [target.'cfg(target_os = "linux")'.dependencies]
-wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
+wreq = { path = "../../vendor/wreq", version = "=0.16.1", features = [
   "prefix-symbols",
 ] }

data/ext/wreq_rb/src/client.rs

@@ -47,7 +47,7 @@ fn runtime() -> &'static Runtime {
 /// # Safety
 /// The closure must NOT access any Ruby objects or call any Ruby C API.
 /// Extract all data from Ruby before calling this, convert results after.
-unsafe fn without_gvl<F, R>(f: F) -> R
+unsafe fn without_gvl<F, R>(f: F) -> Result<R, magnus::Error>
 where
     F: FnOnce(CancellationToken) -> R,
 {
@@ -89,19 +89,22 @@ where
     let data_ptr = &mut data as *mut CallData<F, R> as *mut c_void;
 
     unsafe {
-        rb_sys::rb_thread_call_without_gvl(
-            Some(call::<F, R>),
-            data_ptr,
-            Some(ubf::<F, R>),
-            data_ptr,
-        );
+        magnus::rb_sys::protect(|| {
+            rb_sys::rb_thread_call_without_gvl(
+                Some(call::<F, R>),
+                data_ptr,
+                Some(ubf::<F, R>),
+                data_ptr,
+            );
+            0
+        })?;
     }
 
     if let Some(payload) = data.panic_payload {
         panic::resume_unwind(payload);
     }
 
-    data.result.unwrap()
+    Ok(data.result.unwrap())
 }
 
 /// Collected response data as pure Rust types (no Ruby objects).
@@ -201,7 +204,7 @@ async fn execute_batch(reqs: Vec<wreq::RequestBuilder>, concurrency: usize) -> V
 // --------------------------------------------------------------------------
 
 /// The default browser profile to apply when none is specified.
-const DEFAULT_EMULATION: BrowserProfile = BrowserProfile::Chrome148;
+const DEFAULT_EMULATION: BrowserProfile = BrowserProfile::Chrome149;
 
 /// Parse a Ruby string like "chrome_143" into a BrowserProfile variant.
 fn parse_emulation(name: &str) -> Result<BrowserProfile, magnus::Error> {
@@ -288,12 +291,13 @@ impl Client {
                 builder = builder.default_headers(hmap);
             }
 
-            if let Some(t) = hash_get_float(&opts, "timeout")? {
-                builder = builder.timeout(Duration::from_secs_f64(t));
+            let timeout = hash_get_float(&opts, "timeout")?;
+            if let Some(timeout) = timeout {
+                builder = builder.timeout(Duration::from_secs_f64(timeout));
             }
 
-            if let Some(t) = hash_get_float(&opts, "connect_timeout")? {
-                builder = builder.connect_timeout(Duration::from_secs_f64(t));
+            if let Some(connect_timeout) = hash_get_float(&opts, "connect_timeout")?.or(timeout) {
+                builder = builder.connect_timeout(Duration::from_secs_f64(connect_timeout));
             }
 
             if let Some(t) = hash_get_float(&opts, "read_timeout")? {
@@ -489,7 +493,7 @@ impl Client {
                     }
                 })
             })
-        };
+        }?;
 
         let data = match outcome {
             RequestOutcome::Ok(d) => d,
@@ -545,7 +549,7 @@ impl Client {
                     }
                 })
             })
-        };
+        }?;
 
         let items = match outcome {
             BatchOutcome::Done(items) => items,
@@ -877,3 +881,89 @@ pub fn init(_ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+
+    static READY: AtomicBool = AtomicBool::new(false);
+    static LIVE: AtomicUsize = AtomicUsize::new(0);
+
+    struct DropProbe;
+
+    impl DropProbe {
+        fn new() -> Self {
+            LIVE.fetch_add(1, Ordering::SeqCst);
+            Self
+        }
+    }
+
+    impl Drop for DropProbe {
+        fn drop(&mut self) {
+            LIVE.fetch_sub(1, Ordering::SeqCst);
+        }
+    }
+
+    fn probe_ready() -> bool {
+        READY.load(Ordering::SeqCst)
+    }
+
+    fn drop_probe() -> Result<(), magnus::Error> {
+        let _caller_resource = DropProbe::new();
+        let result = unsafe {
+            without_gvl(|token| {
+                let _callback_resource = DropProbe::new();
+                READY.store(true, Ordering::SeqCst);
+                runtime().block_on(token.cancelled());
+                DropProbe::new()
+            })
+        }?;
+        drop(result);
+        Ok(())
+    }
+
+    #[test]
+    fn ruby_interrupts_drop_native_resources() {
+        let ruby = unsafe { magnus::embed::init() };
+        let result = unsafe { without_gvl(|_| DropProbe::new()) }.unwrap();
+        assert_eq!(LIVE.load(Ordering::SeqCst), 1);
+        drop(result);
+        assert_eq!(LIVE.load(Ordering::SeqCst), 0);
+
+        let panicked = panic::catch_unwind(|| unsafe {
+            without_gvl::<_, ()>(|_| {
+                let _resource = DropProbe::new();
+                panic!("probe panic");
+            })
+        });
+        assert!(panicked.is_err());
+        assert_eq!(LIVE.load(Ordering::SeqCst), 0);
+
+        ruby.define_global_function("wreq_drop_probe", function!(drop_probe, 0));
+        ruby.define_global_function("wreq_probe_ready", function!(probe_ready, 0));
+
+        for (interrupt, expected) in [
+            ("worker.kill", None),
+            ("worker.raise(RuntimeError, 'stop request')", Some("stop request")),
+        ] {
+            READY.store(false, Ordering::SeqCst);
+            let result: Option<String> = ruby.eval(&format!(
+                "worker = Thread.new do
+                   begin
+                     wreq_drop_probe
+                     'returned normally'
+                   rescue RuntimeError => error
+                     error.message
+                   end
+                 end
+                 Thread.pass until wreq_probe_ready
+                 {interrupt}
+                 worker.value"
+            )).unwrap();
+
+            assert_eq!(result.as_deref(), expected);
+            assert_eq!(LIVE.load(Ordering::SeqCst), 0, "resources leaked after {interrupt}");
+        }
+    }
+}

data/ext/wreq_rb/src/response.rs

@@ -5,7 +5,8 @@ use magnus::{
 use crate::error::generic_error;
 
 /// Wraps a wreq::Response in a Ruby-accessible type.
-#[magnus::wrap(class = "Wreq::Response", free_immediately)]
+#[derive(magnus::TypedData)]
+#[magnus(class = "Wreq::Response", free_immediately, size)]
 pub struct Response {
     status: u16,
     headers: Vec<(String, String)>,
@@ -26,7 +27,7 @@ impl Response {
         content_length: Option<u64>,
         transfer_size: Option<u64>,
     ) -> Self {
-        Self {
+        let response = Self {
             status,
             headers,
             body,
@@ -34,7 +35,18 @@ impl Response {
             version,
             content_length,
             transfer_size,
-        }
+        };
+        unsafe { Ruby::get_unchecked() }
+            .gc_adjust_memory_usage(response.heap_size() as isize);
+        response
+    }
+
+    fn heap_size(&self) -> usize {
+        self.body.capacity()
+            + self.url.capacity()
+            + self.version.capacity()
+            + self.headers.capacity() * std::mem::size_of::<(String, String)>()
+            + self.headers.iter().map(|(name, value)| name.capacity() + value.capacity()).sum::<usize>()
     }
 
     fn status(&self) -> u16 {
@@ -119,6 +131,19 @@ impl Response {
     }
 }
 
+impl magnus::DataTypeFunctions for Response {
+    fn size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.heap_size()
+    }
+}
+
+impl Drop for Response {
+    fn drop(&mut self) {
+        unsafe { Ruby::get_unchecked() }
+            .gc_adjust_memory_usage(-(self.heap_size() as isize));
+    }
+}
+
 pub fn init(ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus::Error> {
     let class = module.define_class("Response", ruby.class_object())?;
     class.define_method("status", method!(Response::status, 0))?;

data/lib/wreq-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wreq
-  VERSION = "0.6.0"
+  VERSION = "0.6.2"
 end

data/patches/0001-add-transfer-size-tracking.patch

@@ -1,5 +1,5 @@
 diff --git a/src/client.rs b/src/client.rs
-index 4abe25d8..76e709a8 100644
+index 214fe423..ccbdb0e9 100644
 --- a/src/client.rs
 +++ b/src/client.rs
 @@ -49,6 +49,7 @@ use self::{
@@ -10,18 +10,14 @@ index 4abe25d8..76e709a8 100644
      },
      request::{Request, RequestBuilder},
      response::Response,
-@@ -115,25 +116,30 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
+@@ -116,24 +117,26 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
+ 
  type ClientService = Timeout<
      ConfigService<
-         MaybeDecompression<
--            Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>>,
-+            TransferSizeService<
-+                Retry<
-+                    RetryPolicy,
-+                    FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>,
-+                >,
-+            >,
-         >,
+-        MaybeDecompression<Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>>>>,
++        MaybeDecompression<
++            TransferSizeService<Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>>>>,
++        >,
      >,
  >;
  
@@ -45,7 +41,7 @@ index 4abe25d8..76e709a8 100644
      BoxError,
  >;
  
-@@ -593,6 +599,10 @@ impl ClientBuilder {
+@@ -597,6 +600,10 @@ impl ClientBuilder {
                  })
                  .service(service);
  
@@ -56,7 +52,7 @@ index 4abe25d8..76e709a8 100644
              #[cfg(any(
                  feature = "gzip",
                  feature = "zstd",
-@@ -1585,7 +1595,7 @@ impl ClientBuilder {
+@@ -1607,7 +1614,7 @@ impl ClientBuilder {
          L: Layer<
                  BoxCloneSyncService<
                      http::Request<Body>,
@@ -65,7 +61,7 @@ index 4abe25d8..76e709a8 100644
                      BoxError,
                  >,
              > + Clone
-@@ -1594,7 +1604,7 @@ impl ClientBuilder {
+@@ -1616,7 +1623,7 @@ impl ClientBuilder {
              + 'static,
          L::Service: Service<
                  http::Request<Body>,
@@ -266,7 +262,7 @@ index 00000000..f155ec8d
 +    }
 +}
 diff --git a/src/client/response.rs b/src/client/response.rs
-index 3d3532af..ed478804 100644
+index 3d3532af..7d29ec45 100644
 --- a/src/client/response.rs
 +++ b/src/client/response.rs
 @@ -18,6 +18,7 @@ use mime::Mime;

data/vendor/wreq/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "wreq"
-version = "6.0.0-rc.29"
-description = "An ergonomic Rust HTTP Client with TLS fingerprint"
+version = "0.16.1"
+description = "An ergonomic, privacy-aware Rust HTTP Client"
 keywords = ["http", "client", "websocket", "ja3", "ja4"]
 categories = ["web-programming::http-client"]
 repository = "https://github.com/0x676e67/wreq"
@@ -10,8 +10,8 @@ authors = ["0x676e67 <gngppz@gmail.com>"]
 readme = "README.md"
 license = "Apache-2.0"
 edition = "2024"
-rust-version = "1.85"
-include = ["README.md", "LICENSE", "src/**/*.rs"]
+rust-version = "1.98"
+include = ["/README.md", "/LICENSE", "/src/**/*.rs"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -92,10 +92,10 @@ http = "1.4.0"
 http2 = "0.5.17"
 httparse = "1.10.1"
 http-body = "1.0.1"
-http-body-util = "0.1.3"
+http-body-util = "0.1.4"
 percent-encoding = "2.3.2"
 pin-project-lite = "0.2.17"
-futures-util = { version = "0.3.32", default-features = false }
+futures-util = { version = "0.3.33", default-features = false }
 socket2 = { version = "0.6.3", features = ["all"] }
 ipnet = "2.12.0"
 lru = "0.18.0"
@@ -103,7 +103,7 @@ btls = "0.5.6"
 btls-sys = "0.5.6"
 tokio-btls = "0.5.6"
 tokio = { version = "1.52.3", default-features = false }
-compio = { version = "0.19.0-rc.1", features = ["io", "io-compat"], optional = true }
+compio = { version = "0.19.2", features = ["io", "io-compat"], optional = true }
 wreq-rt = { version = "0.2.2-rc.2", default-features = false }
 wreq-proto = { version = "0.2.3", default-features = false }
 tower = { version = "0.5.3", default-features = false, features = [
@@ -174,7 +174,7 @@ tokio = { version = "1.0", default-features = false, features = [
     "macros",
     "rt-multi-thread",
 ] }
-compio = { version = "0.19.0-rc.1", features = ["macros", "net", "runtime", "time", "io", "io-compat"] }
+compio = { version = "0.19.2", features = ["macros", "net", "runtime", "time", "io", "io-compat"] }
 hyper = { version = "1.7.0", default-features = false, features = [
     "http1",
     "http2",
@@ -202,6 +202,7 @@ zstd = "0.13.3"
 sysinfo = { version = "0.39.1", default-features = false, features = ["system"] }
 criterion = { version = "0.8.2", features = ["async_tokio"] }
 reqwest = { version = "0.13.3", default-features = false, features = ["rustls", "stream", "http2"] }
+cyper = { version = "0.9.0",  default-features = false, features = ["rustls", "stream"] }
 
 [profile.release]
 codegen-units = 1

data/vendor/wreq/README.md

@@ -2,8 +2,8 @@
 
 [![CI](https://github.com/0x676e67/wreq/actions/workflows/ci.yml/badge.svg)](https://github.com/0x676e67/wreq/actions/workflows/ci.yml)
 [![Crates.io License](https://img.shields.io/crates/l/wreq)](https://github.com/0x676e67/wreq/blob/main/LICENSE)
-[![Crates.io MSRV](https://img.shields.io/crates/msrv/wreq?logo=rust)](https://crates.io/crates/wreq)
-[![crates.io](https://img.shields.io/crates/v/wreq.svg?logo=rust)](https://crates.io/crates/wreq)
+[![Crates.io MSRV](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fwreq%2Fversions%3Fsort%3Ddate%26per_page%3D1&query=%24.versions%5B0%5D.rust_version&suffix=.0&label=MSRV&color=blue&logo=rust)](https://crates.io/crates/wreq)
+[![crates.io](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fwreq&query=%24.crate.max_stable_version&prefix=v&label=crates.io&color=orange&logo=rust)](https://crates.io/crates/wreq)
 [![Discord chat][discord-badge]][discord-url]
 
 [discord-badge]: https://img.shields.io/discord/1486741856397164788.svg?logo=discord
@@ -35,8 +35,8 @@ The following example uses the [Tokio](https://tokio.rs) runtime with optional f
 ```toml
 [dependencies]
 tokio = { version = "1", features = ["full"] }
-wreq = "6.0.0-rc"
-wreq-util = "3.0.0-rc"
+wreq = "0.16"
+wreq-util = "0.2"
 ```
 
 And then the code:
@@ -53,7 +53,7 @@ async fn main() -> wreq::Result<()> {
         .build()?;
 
     // Use the API you're already familiar with
-    let resp = client.get("https://tls.peet.ws/api/all").send().await?;
+    let resp = client.get("https://pingly.us.kg/api/all").send().await?;
     println!("{}", resp.text().await?);
     Ok(())
 }

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

@@ -1,8 +1,10 @@
 use criterion::Criterion;
 
 use crate::support::{
-    BoxError, HttpVersion, Tls, client::bench_clients, current_thread_runtime,
-    multi_thread_runtime, server::with_server,
+    BoxError, HttpVersion, Tls,
+    client::bench_clients,
+    rt::{current_thread_runtime, multi_thread_runtime},
+    server::with_server,
 };
 
 pub const CURRENT_THREAD_LABEL: &str = "current_thread";
@@ -54,6 +56,7 @@ pub fn bench(
                 bench_clients(
                     &mut group,
                     current_thread_runtime,
+                    true,
                     addr,
                     tls,
                     http_version,
@@ -74,6 +77,7 @@ pub fn bench(
                 bench_clients(
                     &mut group,
                     multi_thread_runtime,
+                    false,
                     addr,
                     tls,
                     http_version,

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

@@ -2,10 +2,11 @@ use std::{convert::Infallible, net::SocketAddr, sync::Arc};
 
 use bytes::Bytes;
 use criterion::{BenchmarkGroup, measurement::WallTime};
+use futures::{StreamExt, TryStreamExt};
 use http_body_util::BodyExt;
 use tokio::{runtime::Runtime, sync::Semaphore};
 
-use super::{BoxError, HttpVersion, Tls};
+use super::{BoxError, HttpVersion, Tls, rt::CompioBenchExecutor};
 
 fn create_wreq_client(tls: Tls, http_version: HttpVersion) -> Result<wreq::Client, BoxError> {
     let builder = wreq::Client::builder()
@@ -35,6 +36,20 @@ fn create_reqwest_client(tls: Tls, http_version: HttpVersion) -> Result<reqwest:
     Ok(builder.build()?)
 }
 
+fn create_cyper_client(tls: Tls, http_version: HttpVersion) -> Result<cyper::Client, BoxError> {
+    let builder = cyper::Client::builder()
+        .no_proxy()
+        .redirect(cyper::redirect::Policy::none())
+        .danger_accept_invalid_certs(matches!(tls, Tls::Enabled));
+
+    let builder = match http_version {
+        HttpVersion::Http1 => builder,
+        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 {
@@ -59,6 +74,17 @@ async fn reqwest_body_assert(mut response: reqwest::Response, expected_body_size
     );
 }
 
+async fn cyper_body_assert(mut response: cyper::Response, expected_body_size: usize) {
+    let mut body_size = 0;
+    while let Some(Ok(chunk)) = response.next().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,
@@ -94,6 +120,16 @@ fn reqwest_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> req
     }
 }
 
+#[inline]
+fn cyper_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> cyper::Body {
+    if stream {
+        let stream = stream_from_bytes(body, chunk_size).map_err(|never| match never {});
+        cyper::Body::stream(stream)
+    } else {
+        cyper::Body::from(body)
+    }
+}
+
 async fn wreq_requests_concurrent(
     client: &wreq::Client,
     url: &str,
@@ -158,10 +194,44 @@ async fn reqwest_requests_concurrent(
     futures_util::future::join_all(handles).await;
 }
 
+async fn cyper_requests_concurrent(
+    client: &cyper::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)
+                .expect("Unexpected request failure")
+                .body(cyper_body(stream, body))
+                .send()
+                .await
+                .expect("Unexpected request failure");
+            cyper_body_assert(response, body.0.len()).await;
+        };
+        handles.push(compio::runtime::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,
+    include_cyper: bool,
     addr: SocketAddr,
     tls: Tls,
     http_version: HttpVersion,
@@ -211,6 +281,23 @@ pub fn bench_clients(
             })
         });
         ::std::mem::drop(client);
+
+        if include_cyper {
+            let compio_executor = CompioBenchExecutor::new()?;
+            let client = create_cyper_client(tls, http_version)?;
+            group.bench_function(make_benchmark_label::<cyper::Client>(stream), |b| {
+                b.to_async(&compio_executor).iter(|| {
+                    cyper_requests_concurrent(
+                        &client,
+                        &url,
+                        num_requests,
+                        concurrent_limit,
+                        body,
+                        stream,
+                    )
+                })
+            });
+        }
     }
 
     Ok(())

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

@@ -0,0 +1,34 @@
+use criterion::async_executor::AsyncExecutor;
+
+pub struct CompioBenchExecutor {
+    runtime: compio::runtime::Runtime,
+}
+
+impl CompioBenchExecutor {
+    pub fn new() -> std::io::Result<Self> {
+        Ok(Self {
+            runtime: compio::runtime::Runtime::new()?,
+        })
+    }
+}
+
+impl AsyncExecutor for &CompioBenchExecutor {
+    fn block_on<T>(&self, future: impl std::future::Future<Output = T>) -> T {
+        self.runtime.block_on(future)
+    }
+}
+
+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/bench/support/server.rs

@@ -20,7 +20,7 @@ use tokio::{
 };
 use tokio_btls::SslStream;
 
-use super::{BoxError, Tls, multi_thread_runtime};
+use super::{BoxError, Tls, rt::multi_thread_runtime};
 
 pub struct Server {
     listener: std::net::TcpListener,

data/vendor/wreq/bench/support.rs

@@ -1,5 +1,6 @@
 pub mod bench;
 pub mod client;
+pub mod rt;
 pub mod server;
 
 use std::fmt;
@@ -39,18 +40,3 @@ impl fmt::Display for Tls {
         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")
-}