wreq-rb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71608761c20fbf78bba7dee0c06b2518f6ed6ff843f755ea5df5e0a7bdc0c9a4
-  data.tar.gz: 84e1796d7cfc7bdb65dfb593a59b19c7cc482bc068fabfe108bf86e4df661acc
+  metadata.gz: e073dd8e896b2e9a72abc5d34c18fbdc22e70281f711809d48b927821371a88d
+  data.tar.gz: a9c9c86618a68e46c007b518587c57c057603312f6a9fcf276fa2dc075c919a8
 SHA512:
-  metadata.gz: 66afa069e1fe4ba4ea575507148a008021f59fbbefe53eb9433d123fd7caa36e956e340495914d159c7da69b9ce03773a1976af1c75c598ec763131cabc08e73
-  data.tar.gz: 87598598868608d50e6169d903c29cfc443f1e3439e4b20d8f81f974c95de6a247d11b272912ac880e4bae4377f72d1c9721e52bf7e774b9f0b74e6ec5f3e05c
+  metadata.gz: 6b04dc928f331472dc4ba7c597a4070952ee49900853134795a87f29527c1aa59418479ead50a8f4684f79854ae9b17f2c4ebbfe8c8ab1e9a509233f3936d53d
+  data.tar.gz: c105d0bec620ad3975020a5228950b4fe733e7f5314bbd78c8ea94747b35929b6a299340f866cbda41c62b3a6c2b98f57dfdcacd71d80f7eb5df1a768d138f5a

data/Cargo.lock

@@ -2537,7 +2537,7 @@ dependencies = [
 
 [[package]]
 name = "wreq_rb"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "bytes",
  "http",

data/README.md

@@ -77,9 +77,23 @@ client = Wreq::Client.new(
   zstd: true,                  # enable zstd decompression
   emulation: "chrome_143",     # browser emulation (enabled by default)
   emulation_os: "windows",     # OS emulation: windows, macos (default), linux, android, ios
+  header_order: [              # wire order of headers (names only, case-sensitive)
+    "host",                    # listed headers appear first in the given order, remaining
+    "user-agent",              # emulation headers follow.
+    "accept",
+  ],
   headers: {                   # default headers for all requests
     "Accept" => "application/json"
-  }
+  },
+  referer: true,               # auto-set Referer header on redirects (default: true)
+  pool_max_idle_per_host: 10,  # max idle connections per host
+  pool_max_size: 100,          # max total connections in the pool
+  tcp_nodelay: true,           # disable Nagle algorithm (default: true)
+  tcp_keepalive: 15,           # SO_KEEPALIVE interval in seconds (default: 15)
+  local_address: "1.2.3.4",    # bind outgoing connections to this source IP
+  tls_sni: true,               # send SNI in TLS handshake (default: true)
+  min_tls_version: "tls1.2",   # minimum TLS version: tls1.0, tls1.1, tls1.2, tls1.3
+  max_tls_version: "tls1.3",   # maximum TLS version
 )
 
 resp = client.get("https://api.example.com/data")
@@ -100,6 +114,19 @@ All methods are available on both `Wreq` (module-level) and `Wreq::Client` (inst
 | `head(url, **opts)` | HEAD request |
 | `options(url, **opts)` | OPTIONS request |
 
+### Cancelling Requests
+
+Call `cancel` on a client to abort all in-flight requests and close their underlying connections immediately:
+
+```ruby
+client = Wreq::Client.new
+
+# From another thread:
+t = Thread.new { client.get("https://slow.example.com/big-download") }
+sleep 1
+client.cancel  # all in-flight requests return with "request interrupted" error
+```
+
 ### Per-Request Options
 
 Pass an options hash as the second argument to any HTTP method:
@@ -128,7 +155,7 @@ resp = Wreq.get("https://tls.peet.ws/api/all")
 
 # Explicit browser emulation
 client = Wreq::Client.new(emulation: "firefox_146")
-client = Wreq::Client.new(emulation: "safari_18_5")
+client = Wreq::Client.new(emulation: "safari_18.5")
 client = Wreq::Client.new(emulation: "edge_142")
 
 # Disable emulation entirely
@@ -142,7 +169,7 @@ client = Wreq::Client.new(emulation: "chrome_145", emulation_os: "linux")
 client = Wreq::Client.new(emulation: "chrome_143", user_agent: "MyBot/1.0")
 
 # Per-request emulation override
-resp = client.get("https://example.com", emulation: "safari_26_2")
+resp = client.get("https://example.com", emulation: "safari_26.2")
 ```
 
 ### Supported Browsers

data/exe/wreq

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "wreq-rb"
+
+cfg = {
+  method:       nil,
+  headers:      {},
+  include:      false,
+  silent:       false,
+  redirect:     10,
+  verify_cert:  true,
+  verify_host:  true,
+  pretty:       false,
+}
+req = {}
+
+parser = OptionParser.new do |o|
+  o.banner = "Usage: wreq [METHOD] URL [options]"
+
+  o.separator ""
+  o.separator "Request:"
+
+  o.on("-X", "--request METHOD", "HTTP method (default: GET)") { |m| cfg[:method] = m.upcase }
+
+  o.on("-H", "--header LINE", 'Request header, e.g. "Accept: application/json" (repeatable)') do |h|
+    name, _, value = h.partition(":")
+    cfg[:headers][name.strip] = value.strip
+  end
+
+  o.on("-d", "--data DATA",
+       "Request body. Prefix with @ to read from file, e.g. @body.json") do |d|
+    cfg[:method] ||= "POST"
+    if d.start_with?("@")
+      path = d[1..]
+      abort "wreq: cannot read '#{path}': file not found" unless File.exist?(path)
+      req[:body] = File.binread(path)
+    else
+      req[:body] = d
+    end
+  end
+
+  o.on("--json DATA",
+       "JSON body (sets Content-Type: application/json). Prefix with @ for file.") do |d|
+    cfg[:method] ||= "POST"
+    raw = d.start_with?("@") ? File.read(d[1..]) : d
+    begin
+      req[:json] = JSON.parse(raw)
+    rescue JSON::ParserError => e
+      abort "wreq: invalid JSON: #{e.message}"
+    end
+  end
+
+  o.on("--form PAIR", "Form field as key=value (repeatable)") do |f|
+    cfg[:method] ||= "POST"
+    key, _, val = f.partition("=")
+    (req[:form] ||= {})[key] = val
+  end
+
+  o.on("-q", "--query PAIR", "Query parameter as key=value (repeatable)") do |q|
+    key, _, val = q.partition("=")
+    (req[:query] ||= {})[key] = val
+  end
+
+  o.separator ""
+  o.separator "Auth:"
+
+  o.on("-u", "--user USER[:PASS]", "Basic auth credentials") do |u|
+    user, _, pass = u.partition(":")
+    req[:basic] = [user, pass]
+  end
+
+  o.on("--bearer TOKEN", "Bearer token auth") { |t| req[:bearer] = t }
+
+  o.separator ""
+  o.separator "Output:"
+
+  o.on("-i", "--include", "Include response headers in stdout before the body") do
+    cfg[:include] = true
+  end
+
+  o.on("-s", "--silent", "Suppress body output") { cfg[:silent] = true }
+
+  o.on("-o", "--output FILE", "Write body to FILE") { |f| cfg[:output] = f }
+
+  o.on("--pretty", "Pretty-print JSON response bodies") { cfg[:pretty] = true }
+
+  o.separator ""
+  o.separator "Connection:"
+
+  o.on("-L", "--location", "Follow redirects (default: on, max 10)") { cfg[:redirect] = 10 }
+  o.on("--no-location", "Do not follow redirects") { cfg[:redirect] = false }
+  o.on("--max-redirects N", Integer, "Max redirects (default: 10)") { |n| cfg[:redirect] = n }
+
+  o.on("-k", "--insecure", "Skip TLS certificate verification") do
+    cfg[:verify_cert] = false
+    cfg[:verify_host] = false
+  end
+
+  o.on("-x", "--proxy URL", "Proxy URL (e.g. http://host:port)") { |p| cfg[:proxy] = p }
+
+  o.on("--local-address IP", "Bind outgoing connections to this source IP address") do |ip|
+    cfg[:local_address] = ip
+  end
+
+  o.on("--timeout SECS", Float, "Total timeout in seconds") { |t| cfg[:timeout] = t }
+  o.on("--connect-timeout SECS", Float, "Connection timeout in seconds") { |t| cfg[:connect_timeout] = t }
+
+  o.on("--http1", "Force HTTP/1.1") { cfg[:http1_only] = true }
+  o.on("--http2", "Force HTTP/2")   { cfg[:http2_only] = true }
+
+  o.separator ""
+  o.separator "Emulation:"
+
+  o.on("--emulation PROFILE",
+       "Browser emulation profile (e.g. chrome_145, firefox_147, safari_26.2)") do |e|
+    cfg[:emulation] = e
+  end
+
+  o.on("--emulation-os OS",
+       "Emulation OS override: windows, macos, linux, android, ios") do |os|
+    cfg[:emulation_os] = os
+  end
+
+  o.on("--no-emulation", "Disable browser emulation entirely") { cfg[:emulation] = false }
+
+  o.on("-A", "--user-agent UA", "Override User-Agent header") { |ua| cfg[:user_agent] = ua }
+
+  o.on("--cookie-store", "Enable persistent cookie jar for this request") { cfg[:cookie_store] = true }
+
+  o.separator ""
+
+  o.on("-V", "--version", "Print version and exit") { puts "wreq #{Wreq::VERSION}"; exit 0 }
+  o.on_tail("-h", "--help", "Show this help") { puts o; exit 0 }
+end
+
+args = ARGV.dup
+
+# Allow bare method as first positional arg: `wreq POST https://...`
+if args.first =~ /\A[A-Z]+\z/
+  cfg[:method] = args.shift
+end
+
+begin
+  parser.parse!(args)
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+  abort "wreq: #{e.message}\nRun 'wreq --help' for usage."
+end
+
+url = args.shift
+unless url
+  $stderr.puts parser
+  exit 1
+end
+
+cfg[:method] ||= "GET"
+
+# Build Wreq::Client options (connection/emulation settings only)
+CLIENT_KEYS = %i[emulation emulation_os user_agent proxy local_address timeout connect_timeout
+                 http1_only http2_only cookie_store https_only].freeze
+client_opts = cfg.slice(*CLIENT_KEYS).reject { |_, v| v.nil? }
+client_opts[:redirect]    = cfg[:redirect]
+client_opts[:verify_cert] = cfg[:verify_cert]
+client_opts[:verify_host] = cfg[:verify_host]
+
+client = Wreq::Client.new(**client_opts)
+
+# Per-request headers
+req[:headers] = cfg[:headers] unless cfg[:headers].empty?
+
+# Execute request
+begin
+  response = client.public_send(cfg[:method].downcase, url, **req)
+rescue NoMethodError
+  abort "wreq: unsupported HTTP method '#{cfg[:method]}'"
+rescue => e
+  abort "wreq: #{e.message}"
+end
+
+# -i: print response status + headers to stdout before body
+if cfg[:include]
+  puts "#{response.version} #{response.status}"
+  response.headers.each do |k, values|
+    Array(values).each { |v| puts "#{k}: #{v}" }
+  end
+  puts ""
+end
+
+# Output body
+unless cfg[:silent] || cfg[:method] == "HEAD"
+  if cfg[:output]
+    bytes = response.body_bytes.pack("C*")
+    File.binwrite(cfg[:output], bytes)
+    warn "Saved #{bytes.bytesize} bytes to #{cfg[:output]}"
+  else
+    body = response.body
+    if cfg[:pretty] && !body.nil? && !body.empty?
+      body = begin
+        JSON.pretty_generate(JSON.parse(body))
+      rescue JSON::ParserError
+        body
+      end
+    end
+    print body unless body.nil?
+    $stdout.puts if body && !body.empty? && !body.end_with?("\n")
+  end
+end
+
+exit response.success? ? 0 : 1

data/ext/wreq_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wreq_rb"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 publish = false
 

data/ext/wreq_rb/src/client.rs

@@ -10,7 +10,9 @@ use magnus::{
 };
 use tokio::runtime::Runtime;
 use tokio_util::sync::CancellationToken;
-use wreq::header::{HeaderMap, HeaderName, HeaderValue};
+use std::net::IpAddr;
+use wreq::header::{HeaderMap, HeaderName, HeaderValue, OrigHeaderMap};
+use wreq::tls::TlsVersion;
 use wreq_util::{Emulation as BrowserEmulation, EmulationOS, EmulationOption};
 
 use crate::error::{generic_error, to_magnus_error};
@@ -178,6 +180,7 @@ fn build_emulation_option(
 #[magnus::wrap(class = "Wreq::Client", free_immediately)]
 struct Client {
     inner: wreq::Client,
+    cancel_token: std::sync::Mutex<CancellationToken>,
 }
 
 impl Client {
@@ -192,6 +195,12 @@ impl Client {
         let mut builder = wreq::Client::builder();
 
         if let Some(opts) = opts {
+            // Apply header_order BEFORE emulation so the user's ordering takes precedence
+            if let Some(ary) = hash_get_array(&opts, "header_order")? {
+                let orig = array_to_orig_header_map(ary)?;
+                builder = builder.orig_headers(orig);
+            }
+
             if let Some(val) = hash_get_value(&opts, "emulation")? {
                 let ruby = unsafe { Ruby::get_unchecked() };
                 if val.is_kind_of(ruby.class_false_class()) {
@@ -293,12 +302,50 @@ impl Client {
             if let Some(v) = hash_get_bool(&opts, "zstd")? {
                 builder = builder.zstd(v);
             }
+
+            if let Some(v) = hash_get_bool(&opts, "referer")? {
+                builder = builder.referer(v);
+            }
+
+            if let Some(n) = hash_get_usize(&opts, "pool_max_idle_per_host")? {
+                builder = builder.pool_max_idle_per_host(n);
+            }
+
+            if let Some(n) = hash_get_u32(&opts, "pool_max_size")? {
+                builder = builder.pool_max_size(n);
+            }
+
+            if let Some(v) = hash_get_bool(&opts, "tcp_nodelay")? {
+                builder = builder.tcp_nodelay(v);
+            }
+
+            if let Some(t) = hash_get_float(&opts, "tcp_keepalive")? {
+                builder = builder.tcp_keepalive(Duration::from_secs_f64(t));
+            }
+
+            if let Some(addr_str) = hash_get_string(&opts, "local_address")? {
+                let addr: IpAddr = addr_str.parse()
+                    .map_err(|_| generic_error(format!("invalid IP address: '{}'", addr_str)))?;
+                builder = builder.local_address(addr);
+            }
+
+            if let Some(v) = hash_get_bool(&opts, "tls_sni")? {
+                builder = builder.tls_sni(v);
+            }
+
+            if let Some(s) = hash_get_string(&opts, "min_tls_version")? {
+                builder = builder.min_tls_version(parse_tls_version(&s)?);
+            }
+
+            if let Some(s) = hash_get_string(&opts, "max_tls_version")? {
+                builder = builder.max_tls_version(parse_tls_version(&s)?);
+            }
         } else {
             builder = builder.emulation(DEFAULT_EMULATION);
         }
 
         let client = builder.build().map_err(to_magnus_error)?;
-        Ok(Client { inner: client })
+        Ok(Client { inner: client, cancel_token: std::sync::Mutex::new(CancellationToken::new()) })
     }
 
     /// client.get(url) or client.get(url, opts)
@@ -330,6 +377,19 @@ impl Client {
         self.execute_method("OPTIONS", args)
     }
 
+    fn cancel(&self) {
+        // Replace the cancel token first so new requests use a fresh token,
+        // then cancel the old one to unblock all current in-flight select!s.
+        let old_token = {
+            let mut guard = self.cancel_token.lock().unwrap_or_else(|e| e.into_inner());
+            let old = guard.clone();
+            *guard = CancellationToken::new();
+            old
+        };
+        old_token.cancel();
+        self.inner.cancel_connections();
+    }
+
     fn execute_method(&self, method_str: &str, args: &[Value]) -> Result<Response, magnus::Error> {
         let url: String = if args.is_empty() {
             return Err(generic_error("url is required"));
@@ -353,13 +413,16 @@ impl Client {
             req = apply_request_options(req, &opts)?;
         }
 
+        let client_token = self.cancel_token.lock().unwrap_or_else(|e| e.into_inner()).clone();
+
         // Release the GVL so other Ruby threads can run during I/O.
         let outcome: RequestOutcome = unsafe {
-            without_gvl(|cancel| {
+            without_gvl(|thread_token| {
                 runtime().block_on(async {
                     tokio::select! {
                         biased;
-                        _ = cancel.cancelled() => RequestOutcome::Interrupted,
+                        _ = thread_token.cancelled() => RequestOutcome::Interrupted,
+                        _ = client_token.cancelled() => RequestOutcome::Interrupted,
                         res = execute_request(req) => match res {
                             Ok(data) => RequestOutcome::Ok(data),
                             Err(e) => RequestOutcome::Err(e),
@@ -529,6 +592,32 @@ fn hash_get_bool(hash: &RHash, key: &str) -> Result<Option<bool>, magnus::Error>
     }
 }
 
+fn hash_get_usize(hash: &RHash, key: &str) -> Result<Option<usize>, magnus::Error> {
+    match hash_get_value(hash, key)? {
+        Some(v) => Ok(Some(TryConvert::try_convert(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn hash_get_u32(hash: &RHash, key: &str) -> Result<Option<u32>, magnus::Error> {
+    match hash_get_value(hash, key)? {
+        Some(v) => Ok(Some(TryConvert::try_convert(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn parse_tls_version(s: &str) -> Result<TlsVersion, magnus::Error> {
+    match s {
+        "tls1.0" | "tls_1_0" | "1.0" => Ok(TlsVersion::TLS_1_0),
+        "tls1.1" | "tls_1_1" | "1.1" => Ok(TlsVersion::TLS_1_1),
+        "tls1.2" | "tls_1_2" | "1.2" => Ok(TlsVersion::TLS_1_2),
+        "tls1.3" | "tls_1_3" | "1.3" => Ok(TlsVersion::TLS_1_3),
+        _ => Err(generic_error(format!(
+            "unknown TLS version '{}'. Use: 'tls1.2', 'tls1.3'", s
+        ))),
+    }
+}
+
 fn hash_get_hash(hash: &RHash, key: &str) -> Result<Option<RHash>, magnus::Error> {
     match hash_get_value(hash, key)? {
         Some(v) => Ok(Some(RHash::try_convert(v)?)),
@@ -536,6 +625,27 @@ fn hash_get_hash(hash: &RHash, key: &str) -> Result<Option<RHash>, magnus::Error
     }
 }
 
+fn hash_get_array(hash: &RHash, key: &str) -> Result<Option<RArray>, magnus::Error> {
+    match hash_get_value(hash, key)? {
+        Some(v) => Ok(Some(RArray::try_convert(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn array_to_orig_header_map(ary: RArray) -> Result<OrigHeaderMap, magnus::Error> {
+    let mut orig = OrigHeaderMap::with_capacity(ary.len());
+    for elem in ary.into_iter() {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let name_str: String = if elem.is_kind_of(ruby.class_symbol()) {
+            elem.funcall("to_s", ())?  
+        } else {
+            TryConvert::try_convert(elem)?
+        };
+        orig.insert(name_str);
+    }
+    Ok(orig)
+}
+
 fn hash_to_header_map(hash: &RHash) -> Result<HeaderMap, magnus::Error> {
     let mut hmap = HeaderMap::new();
     hash.foreach(|k: Value, v: Value| {
@@ -589,6 +699,7 @@ pub fn init(_ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus
     client_class.define_method("delete", method!(Client::delete, -1))?;
     client_class.define_method("head", method!(Client::head, -1))?;
     client_class.define_method("options", method!(Client::options, -1))?;
+    client_class.define_method("cancel", method!(Client::cancel, 0))?;
 
     module.define_module_function("get", function!(wreq_get, -1))?;
     module.define_module_function("post", function!(wreq_post, -1))?;

data/lib/wreq-rb/version.rb

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

data/patches/0002-add-cancel-connections.patch

@@ -0,0 +1,181 @@
+diff --git a/src/client/http.rs b/src/client/http.rs
+index 462c77d0..6231e700 100644
+--- a/src/client/http.rs
++++ b/src/client/http.rs
+@@ -171,6 +171,7 @@ type ClientRef = Either<ClientService, BoxedClientService>;
+ #[derive(Clone)]
+ pub struct Client {
+     inner: Arc<ClientRef>,
++    cancel_connections: Arc<dyn Fn() + Send + Sync>,
+ }
+ 
+ /// A [`ClientBuilder`] can be used to create a [`Client`] with custom configuration.
+@@ -439,6 +440,14 @@ impl Client {
+         let fut = Oneshot::new(self.inner.as_ref().clone(), req);
+         Pending::request(uri, fut)
+     }
++
++    /// Cancel all background connection tasks immediately.
++    ///
++    /// This force-drops every tracked H1/H2 connection task, causing the
++    /// underlying TCP socket to close abruptly.
++    pub fn cancel_connections(&self) {
++        (self.cancel_connections)()
++    }
+ }
+ 
+ impl tower::Service<Request> for Client {
+@@ -495,7 +504,7 @@ impl ClientBuilder {
+         }
+ 
+         // Create base client service
+-        let service = {
++        let (service, cancel_connections) = {
+             let (tls_options, http1_options, http2_options) = config.transport_options.into();
+ 
+             let resolver = {
+@@ -555,7 +564,7 @@ impl ClientBuilder {
+                 .build(config.connector_layers)?;
+ 
+             // Build client
+-            HttpClient::builder(TokioExecutor::new())
++            let http_client = HttpClient::builder(TokioExecutor::new())
+                 .http1_options(http1_options)
+                 .http2_options(http2_options)
+                 .http2_only(matches!(config.http_version_pref, HttpVersionPref::Http2))
+@@ -564,8 +573,10 @@ impl ClientBuilder {
+                 .pool_idle_timeout(config.pool_idle_timeout)
+                 .pool_max_idle_per_host(config.pool_max_idle_per_host)
+                 .pool_max_size(config.pool_max_size)
+-                .build(connector)
+-                .map_err(Into::into as _)
++                .build(connector);
++            // Capture abort fn before tower layers consume the client
++            let cancel_connections = http_client.cancel_connections_fn();
++            (http_client.map_err(Into::into as _), cancel_connections)
+         };
+ 
+         // Configured client service with layers
+@@ -633,6 +644,7 @@ impl ClientBuilder {
+ 
+         Ok(Client {
+             inner: Arc::new(client),
++            cancel_connections,
+         })
+     }
+ 
+diff --git a/src/client/http/client.rs b/src/client/http/client.rs
+index a29c52dd..7f6ce68f 100644
+--- a/src/client/http/client.rs
++++ b/src/client/http/client.rs
+@@ -10,7 +10,7 @@ use std::{
+     future::Future,
+     num::NonZeroU32,
+     pin::Pin,
+-    sync::Arc,
++    sync::{Arc, Mutex},
+     task::{self, Poll},
+     time::Duration,
+ };
+@@ -119,6 +119,7 @@ pub struct HttpClient<C, B> {
+     h1_builder: conn::http1::Builder,
+     h2_builder: conn::http2::Builder<Exec>,
+     pool: pool::Pool<PoolClient<B>, ConnectIdentity>,
++    conn_abort_handles: Arc<Mutex<Vec<tokio::task::AbortHandle>>>,
+ }
+ 
+ #[derive(Clone, Copy)]
+@@ -452,8 +453,8 @@ where
+     + Send
+     + Unpin
+     + 'static {
+-        let executor = self.exec.clone();
+         let pool = self.pool.clone();
++        let conn_abort_handles = self.conn_abort_handles.clone();
+ 
+         let h1_builder = self.h1_builder.clone();
+         let h2_builder = self.h2_builder.clone();
+@@ -513,10 +514,17 @@ where
+                                     trace!(
+                                         "http2 handshake complete, spawning background dispatcher task"
+                                     );
+-                                    executor.execute(
+-                                        conn.map_err(|_e| debug!("client connection error: {}", _e))
+-                                            .map(|_| ()),
+-                                    );
++                                    let h2_conn_future = conn
++                                        .map_err(|_e| debug!("client connection error: {}", _e))
++                                        .map(|_| ());
++                                    let abort_handle = tokio::spawn(h2_conn_future).abort_handle();
++                                    {
++                                        let mut handles = conn_abort_handles.lock().unwrap_or_else(|e| e.into_inner());
++                                        if handles.len() >= 64 {
++                                            handles.retain(|h| !h.is_finished());
++                                        }
++                                        handles.push(abort_handle);
++                                    }
+ 
+                                     // Wait for 'conn' to ready up before we
+                                     // declare this tx as usable
+@@ -544,8 +552,7 @@ where
+                                     // Spawn the connection task in the background using the executor.
+                                     // The task manages the HTTP/1.1 connection, including upgrades (e.g., WebSocket).
+                                     // Errors are sent via err_tx to ensure they can be checked if the sender (tx) fails.
+-                                    executor.execute(
+-                                        conn.with_upgrades()
++                                    let h1_conn_future = conn.with_upgrades()
+                                                 .map_err(|e| {
+                                                 // Log the connection error at debug level for diagnostic purposes.
+                                                 debug!("client connection error: {:?}", e);
+@@ -555,8 +562,15 @@ where
+                                                 // (e.g., if the receiver is dropped, which is handled later).
+                                                 let _ = err_tx.send(e);
+                                             })
+-                                            .map(|_| ()),
+-                                    );
++                                            .map(|_| ());
++                                    let abort_handle = tokio::spawn(h1_conn_future).abort_handle();
++                                    {
++                                        let mut handles = conn_abort_handles.lock().unwrap_or_else(|e| e.into_inner());
++                                        if handles.len() >= 64 {
++                                            handles.retain(|h| !h.is_finished());
++                                        }
++                                        handles.push(abort_handle);
++                                    }
+ 
+                                     // Log that the client is waiting for the connection to be ready.
+                                     // Readiness indicates the sender (tx) can accept a request without blocking. More actions
+@@ -682,10 +696,25 @@ impl<C: Clone, B> Clone for HttpClient<C, B> {
+             h2_builder: self.h2_builder.clone(),
+             connector: self.connector.clone(),
+             pool: self.pool.clone(),
++            conn_abort_handles: self.conn_abort_handles.clone(),
+         }
+     }
+ }
+ 
++impl<C, B> HttpClient<C, B> {
++    /// Returns a closure that cancels all tracked connection tasks when called.
++    /// Each call drains the handle list and aborts every stored task.
++    pub fn cancel_connections_fn(&self) -> Arc<dyn Fn() + Send + Sync + 'static> {
++        let handles = self.conn_abort_handles.clone();
++        Arc::new(move || {
++            let mut guard = handles.lock().unwrap_or_else(|e| e.into_inner());
++            for handle in guard.drain(..) {
++                handle.abort();
++            }
++        })
++    }
++}
++
+ /// A pooled HTTP connection that can send requests
+ struct PoolClient<B> {
+     conn_info: Connected,
+@@ -998,6 +1027,7 @@ impl Builder {
+             h2_builder: self.h2_builder,
+             connector,
+             pool: pool::Pool::new(self.pool_config, exec, timer),
++            conn_abort_handles: Arc::new(Mutex::new(Vec::new())),
+         }
+     }
+ }

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: wreq-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Yicheng Zhou
 - Illia Zub
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2026-03-02 00:00:00.000000000 Z
+date: 2026-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -29,7 +29,8 @@ description: An ergonomic Ruby HTTP client powered by Rust's wreq library, featu
   TLS fingerprint emulation (JA3/JA4), HTTP/2 support, cookie handling, proxy support,
   and redirect policies.
 email:
-executables: []
+executables:
+- wreq
 extensions:
 - ext/wreq_rb/extconf.rb
 extra_rdoc_files: []
@@ -37,6 +38,7 @@ files:
 - Cargo.lock
 - Cargo.toml
 - README.md
+- exe/wreq
 - ext/wreq_rb/Cargo.toml
 - ext/wreq_rb/extconf.rb
 - ext/wreq_rb/src/client.rs
@@ -46,6 +48,7 @@ files:
 - lib/wreq-rb.rb
 - lib/wreq-rb/version.rb
 - patches/0001-add-transfer-size-tracking.patch
+- patches/0002-add-cancel-connections.patch
 - vendor/wreq/Cargo.toml
 - vendor/wreq/LICENSE
 - vendor/wreq/README.md