Do not pass state in Config

src/agent.rs

@@ -245,12 +245,7 @@ impl Agent {
     }
 
     pub(crate) fn new_request_level_config(&self) -> RequestLevelConfig {
-        let mut config = self.config.as_ref().clone();
-
-        // Set flag indicating this is request level.
-        config.request_level = true;
-
-        RequestLevelConfig(config)
+        RequestLevelConfig(self.config.as_ref().clone())
     }
 
     /// Make a GET request using this agent.

src/config.rs

@@ -159,13 +159,6 @@ pub struct Config {
 
     // Chain built for middleware.
     pub(crate) middleware: MiddlewareChain,
-
-    // Techically not config, but here to pass as argument from
-    // RequestBuilder::force_send_body() to run()
-    pub(crate) force_send_body: bool,
-
-    // If this config instance is request level.
-    pub(crate) request_level: bool,
 }
 
 impl Config {
@@ -852,8 +845,6 @@ impl Default for Config {
             max_idle_connections_per_host: 3,
             max_idle_age: Duration::from_secs(15),
             middleware: MiddlewareChain::default(),
-            force_send_body: false,
-            request_level: false,
         }
     }
 }

src/request.rs

@@ -402,10 +402,9 @@ impl RequestBuilder<WithoutBody> {
     /// # Ok::<_, ureq::Error>(())
     /// ```
     pub fn force_send_body(mut self) -> RequestBuilder<WithBody> {
-        // This is how we communicate to run() that we want to disable
-        // the method-body-compliance check.
-        let config = self.request_level_config();
-        config.force_send_body = true;
+        if let Some(exts) = self.extensions_mut() {
+            exts.insert(ForceSendBody);
+        }
 
         RequestBuilder {
             agent: self.agent,
@@ -417,6 +416,9 @@ impl RequestBuilder<WithoutBody> {
     }
 }
 
+#[derive(Debug, Clone)]
+pub(crate) struct ForceSendBody;
+
 impl RequestBuilder<WithBody> {
     pub(crate) fn new<T>(agent: Agent, method: Method, uri: T) -> Self
     where

src/run.rs

@@ -13,6 +13,7 @@ use crate::body::ResponseInfo;
 use crate::config::{Config, RequestLevelConfig, DEFAULT_USER_AGENT};
 use crate::http;
 use crate::pool::Connection;
+use crate::request::ForceSendBody;
 use crate::response::{RedirectHistory, ResponseUri};
 use crate::timings::{CallTimings, CurrentTime};
 use crate::transport::time::{Duration, Instant};
@@ -33,12 +34,13 @@ pub(crate) fn run(
     let mut redirect_count = 0;
 
     // Configuration on the request level overrides the agent level.
-    let config = request
+    let (config, request_level) = request
         .extensions_mut()
         .remove::<RequestLevelConfig>()
-        .map(|rl| rl.0)
-        .map(Arc::new)
-        .unwrap_or_else(|| agent.config.clone());
+        .map(|rl| (Arc::new(rl.0), true))
+        .unwrap_or_else(|| (agent.config.clone(), false));
+
+    let force_send_body = request.extensions_mut().remove::<ForceSendBody>().is_some();
 
     let mut redirect_history: Option<Vec<Uri>> =
         config.save_redirect_history().then_some(Vec::new());
@@ -49,7 +51,7 @@ pub(crate) fn run(
 
     let mut flow = Flow::new(request)?;
 
-    if config.force_send_body {
+    if force_send_body {
         flow.send_body_despite_method();
     }
 
@@ -66,6 +68,7 @@ pub(crate) fn run(
         match flow_run(
             agent,
             &config,
+            request_level,
             flow,
             &mut body,
             redirect_count,
@@ -112,6 +115,7 @@ pub(crate) fn run(
 fn flow_run(
     agent: &Agent,
     config: &Config,
+    request_level: bool,
     mut flow: Flow<Prepare>,
     body: &mut SendBody,
     redirect_count: u32,
@@ -127,7 +131,7 @@ fn flow_run(
 
     add_headers(&mut flow, agent, config, body, &uri)?;
 
-    let mut connection = connect(agent, config, &uri, timings)?;
+    let mut connection = connect(agent, config, request_level, &uri, timings)?;
 
     let mut flow = flow.proceed();
 
@@ -336,6 +340,7 @@ fn add_headers(
 fn connect(
     agent: &Agent,
     config: &Config,
+    request_level: bool,
     wanted_uri: &Uri,
     timings: &mut CallTimings,
 ) -> Result<Connection, Error> {
@@ -363,6 +368,7 @@ fn connect(
         addrs,
         resolver: &*agent.resolver,
         config,
+        request_level,
         now: timings.now(),
         timeout: timings.next_timeout(Timeout::Connect),
         proxied,

src/tls/native_tls.rs

@@ -3,7 +3,6 @@ use std::fmt;
 use std::io::{Read, Write};
 use std::sync::{Arc, OnceLock};
 
-use crate::config::Config;
 use crate::tls::{RootCerts, TlsProvider};
 use crate::{transport::*, Error};
 use der::pem::LineEnding;
@@ -52,7 +51,7 @@ impl<In: Transport> Connector<In> for NativeTlsConnector {
 
         trace!("Try wrap TLS");
 
-        let connector = self.get_cached_native_tls_connector(details.config)?;
+        let connector = self.get_cached_native_tls_connector(details)?;
 
         let domain = details
             .uri
@@ -78,10 +77,13 @@ impl<In: Transport> Connector<In> for NativeTlsConnector {
 }
 
 impl NativeTlsConnector {
-    fn get_cached_native_tls_connector(&self, config: &Config) -> Result<Arc<TlsConnector>, Error> {
-        let tls_config = config.tls_config();
+    fn get_cached_native_tls_connector(
+        &self,
+        details: &ConnectionDetails,
+    ) -> Result<Arc<TlsConnector>, Error> {
+        let tls_config = details.config.tls_config();
 
-        let connector = if config.request_level {
+        let connector = if details.request_level {
             // If the TlsConfig is request level, it is not allowed to
             // initialize the self.config OnceLock, but it should
             // reuse the cached value if it is the same TlsConfig

src/tls/rustls.rs

@@ -9,7 +9,6 @@ use rustls::{ClientConfig, ClientConnection, RootCertStore, StreamOwned, ALL_VER
 use rustls_pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs1KeyDer, PrivatePkcs8KeyDer};
 use rustls_pki_types::{PrivateSec1KeyDer, ServerName};
 
-use crate::config::Config;
 use crate::tls::cert::KeyKind;
 use crate::tls::{RootCerts, TlsProvider};
 use crate::transport::{Buffers, ConnectionDetails, Connector, LazyBuffers};
@@ -57,7 +56,7 @@ impl<In: Transport> Connector<In> for RustlsConnector {
 
         trace!("Try wrap in TLS");
 
-        let config = self.get_cached_config(details.config);
+        let config = self.get_cached_config(details);
 
         let name_borrowed: ServerName<'_> = details
             .uri
@@ -92,10 +91,10 @@ impl<In: Transport> Connector<In> for RustlsConnector {
 }
 
 impl RustlsConnector {
-    fn get_cached_config(&self, config: &Config) -> Arc<ClientConfig> {
-        let tls_config = config.tls_config();
+    fn get_cached_config(&self, details: &ConnectionDetails) -> Arc<ClientConfig> {
+        let tls_config = details.config.tls_config();
 
-        if config.request_level {
+        if details.request_level {
             // If the TlsConfig is request level, it is not allowed to
             // initialize the self.config OnceLock, but it should
             // reuse the cached value if it is the same TlsConfig

src/unversioned/transport/mod.rs

@@ -183,9 +183,14 @@ pub struct ConnectionDetails<'a> {
     /// For CONNECT proxy, this is the address of the proxy server.
     pub addrs: ResolvedSocketAddrs,
 
-    /// The Agent configuration.
+    /// The configuration.
+    ///
+    /// Agent or Request level.
     pub config: &'a Config,
 
+    /// Whether the config is request level.
+    pub request_level: bool,
+
     /// The resolver configured on [`Agent`](crate::Agent).
     ///
     /// Typically the IP address of the host in the uri is already resolved to the `addr`