wreq-rb 0.4.0-aarch64-linux → 0.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f120dd910385609c611944ca7d93171058bba1ea8ba4a16e95dd1d77a5f5e9e3
-  data.tar.gz: 040bf96d8addb498772fce92f7267233f03d87aeabaf60723efd8f01dfb714f4
+  metadata.gz: ece22ccedbf255b890a3a7999ad5eed2ab4a7a8574b533e2b71cf2164bfd89e1
+  data.tar.gz: 736c338202b6fa4ff0dfaee437348941f841e2903182da23d621ddefa3681b61
 SHA512:
-  metadata.gz: 7fe68f42eeef23d296f15492036b2e13ae9f2c05c107f2a8d208da1e576bb35c79d0f048f41c81037505fb098816b5b1e4656d70621ca3349a588d1b75149784
-  data.tar.gz: dd6d4cbf5c65c03f7835431414d0c933a6fa0ab356951e5f59c1b288abe5b6058c4f2f3ec05fb66a9ad008bf77d406a64a52428221921c39c0309bd31e9a1fed
+  metadata.gz: 7c1f15b01a70a35c7f35d0b1219111471e066ece8f894c1e522741c97af2447f11416bebf59f6fa34932b8b8033d2635ccc783951bb527d4526c7d65f860310d
+  data.tar.gz: bd845b5191cb8b68564bab0c1dff30c47c62ec521cb271fd8c7ca922a6c6368634c6b1781a277ec37b9d7a0a4634ad2dc022ad557e6442f8852efc7aaeb0232c

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/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,31 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: wreq-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: aarch64-linux
 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: []
 description: An ergonomic Ruby HTTP client powered by Rust's wreq library, featuring
   TLS fingerprint emulation (JA3/JA4), HTTP/2 support, cookie handling, proxy support,
   and redirect policies.
 email: 
-executables: []
+executables:
+- wreq
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- exe/wreq
 - lib/wreq-rb.rb
 - lib/wreq-rb/version.rb
 - lib/wreq_rb/2.7/wreq_rb.so
 - lib/wreq_rb/3.3/wreq_rb.so
 - lib/wreq_rb/3.4/wreq_rb.so
 - patches/0001-add-transfer-size-tracking.patch
+- patches/0002-add-cancel-connections.patch
 - vendor/wreq/LICENSE
 - vendor/wreq/README.md
 homepage: https://github.com/serpapi/wreq-rb