AWS SDK

rev. 8158c52aaf18ca396e77f487169df4a7c09c250d

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/examples/custom-dns.rs

@@ -1,1 +26,35 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use aws_smithy_http_client::{
     pool::{Client as PoolClient, ConnectionPool},
     tls::{self, rustls_provider::CryptoMode},
     Builder,
 };
 use aws_smithy_runtime_api::client::dns::{DnsFuture, ResolveDns};
 use std::net::{IpAddr, Ipv4Addr};
-13
 #[derive(Debug, Clone)]
 struct StaticResolver;
-16
 impl ResolveDns for StaticResolver {
     fn resolve_dns<'a>(&'a self, _name: &'a str) -> DnsFuture<'a> {
         DnsFuture::ready(Ok(vec![IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))]))
-20
+    }
-21
+}
-22
 fn main() {
     let _client = Builder::new()
     let _legacy_client = Builder::new()
         .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
         .build_with_resolver(StaticResolver);
-+
     let pool = ConnectionPool::builder()
         .dns_resolver(StaticResolver)
         .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
         .build_https()
         .expect("valid connection pool");
     let _partitioned_client =
         PoolClient::new(&pool).expect("pool contains the anonymous partition");
-35
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client.rs

@@ -1,1 +53,55 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5

 mod dns;
 pub mod pool;
 /// Proxy configuration
 pub mod proxy;
 mod timeout;
 /// TLS connector(s)
 pub mod tls;
-13
 pub(crate) mod connect;
-15
 use self::connect::ConnectPath;
 use crate::cfg::cfg_tls;
 use crate::tls::TlsContext;
 use aws_smithy_async::future::timeout::TimedOutError;
 use aws_smithy_async::rt::sleep::{default_async_sleep, AsyncSleep, SharedAsyncSleep};
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::connection::CaptureSmithyConnection;
 use aws_smithy_runtime_api::client::connection::ConnectionMetadata;
 use aws_smithy_runtime_api::client::connector_metadata::ConnectorMetadata;
 use aws_smithy_runtime_api::client::dns::ResolveDnsError;
 use aws_smithy_runtime_api::client::http::{
     HttpClient, HttpConnector, HttpConnectorFuture, HttpConnectorSettings, SharedHttpClient,
     SharedHttpConnector,
 };
 use aws_smithy_runtime_api::client::orchestrator::{HttpRequest, HttpResponse};
 use aws_smithy_runtime_api::client::result::ConnectorError;
 use aws_smithy_runtime_api::client::runtime_components::{
     RuntimeComponents, RuntimeComponentsBuilder,
 };
 use aws_smithy_runtime_api::shared::IntoShared;

↧ Expand context

 use aws_smithy_types::body::SdkBody;
 use aws_smithy_types::config_bag::ConfigBag;
 use aws_smithy_types::error::display::DisplayErrorContext;
 use aws_smithy_types::retry::ErrorKind;
 use client::connect::Connection;
 use h2::Reason;
 use http_1x::{Extensions, Uri};
 use hyper::rt::{Read, Write};
 use hyper_util::client::legacy as client;
 use hyper_util::client::legacy::connect::dns::GaiResolver;
 use hyper_util::client::legacy::connect::{
     capture_connection, CaptureConnection, Connect, HttpConnector as HyperHttpConnector, HttpInfo,
 };
 use hyper_util::client::proxy::matcher::Matcher;
 use hyper_util::rt::{TokioExecutor, TokioTimer};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt;
 use std::sync::RwLock;

@@ -489,491 +550,553 @@

↥ Expand context

         self
-492
+    }
-493
+}
-494
 /// Adapter to use a Hyper 1.0-based Client as an `HttpConnector`
 ///
 /// This adapter also enables TCP `CONNECT` and HTTP `READ` timeouts via [`Connector::builder`].
 struct Adapter<C> {
     client: timeout::HttpReadTimeout<
         hyper_util::client::legacy::Client<timeout::ConnectTimeout<C>, SdkBody>,
     >,
     proxy_matcher: Option<Matcher>,
-503
+}
-504
 impl<C> fmt::Debug for Adapter<C> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Adapter")
             .field("client", &"** hyper client **")
             .field("proxy_matcher", &self.proxy_matcher.is_some())
             .finish()

-511
+    }
-512
+}
-513
 /// Extract a smithy connection from a hyper CaptureConnection
 fn extract_smithy_connection(capture_conn: &CaptureConnection) -> Option<ConnectionMetadata> {
     let capture_conn = capture_conn.clone();
     if let Some(conn) = capture_conn.clone().connection_metadata().as_ref() {
         let mut extensions = Extensions::new();
         conn.get_extras(&mut extensions);
         let http_info = extensions.get::<HttpInfo>();
         let connect_path = ConnectPath::from_connected(conn, &extensions);
         let mut builder = ConnectionMetadata::builder()
             .proxied(conn.is_proxied())
             .proxied(connect_path.is_proxied())
             .poison_fn(move || match capture_conn.connection_metadata().as_ref() {
                 Some(conn) => conn.poison(),
                 None => tracing::trace!("no connection existed to poison"),
             });
-528
         builder
             .set_local_addr(http_info.map(|info| info.local_addr()))
             .set_remote_addr(http_info.map(|info| info.remote_addr()));
-532
         let smithy_connection = builder.build();

↧ Expand context

-534
         Some(smithy_connection)
     } else {
         None
-538
+    }
-539
+}
-540
 fn new_tokio_hyper_builder(
     pool_idle_timeout: Option<Option<Duration>>,
     pool_max_idle_per_host: Option<usize>,
 ) -> hyper_util::client::legacy::Builder {
     let mut builder = hyper_util::client::legacy::Builder::new(TokioExecutor::new());
     // Explicitly setting the pool_timer is required for connection timeouts to work.
     builder.pool_timer(TokioTimer::new());
-548
     if let Some(pool_idle_timeout) = pool_idle_timeout {
         builder.pool_idle_timeout(pool_idle_timeout);
-551
+    }
-552
     if let Some(max_idle) = pool_max_idle_per_host {

@@ -610,613 +669,676 @@

↥ Expand context

             capture_smithy_connection
                 .set_connection_retriever(move || extract_smithy_connection(&capture_connection));
-615
+        }
         let mut client = self.client.clone();
         use tower::Service;
         let fut = client.call(request);
         HttpConnectorFuture::new(async move {
             let response = fut
                 .await
                 .map_err(downcast_error)?
                 .map(SdkBody::from_body_1_x);
             match HttpResponse::try_from(response) {
                 Ok(response) => Ok(response),
                 Err(err) => Err(ConnectorError::other(err.into(), None)),
-627
+            }
         })
-629
+    }
-630
+}
-631
 /// Downcast errors coming out of hyper into an appropriate `ConnectorError`

 fn downcast_error(err: BoxError) -> ConnectorError {
     // is a `TimedOutError` (from aws_smithy_async::timeout) in the chain? if it is, this is a timeout
     if find_source::<TimedOutError>(err.as_ref()).is_some() {
         return ConnectorError::timeout(err);
-637
+    }
     // is the top of chain error actually already a `ConnectorError`? return that directly
     let err = match err.downcast::<ConnectorError>() {
         Ok(connector_error) => return *connector_error,
         Err(box_error) => box_error,
     };
     // DNS resolution is part of connection establishment and is retryable as I/O.
     if find_source::<ResolveDnsError>(err.as_ref()).is_some() {
         return ConnectorError::io(err);
-+
+    }
     // generally, the top of chain will probably be a hyper error. Go through a set of hyper specific
     // error classifications
     let err = match find_source::<hyper::Error>(err.as_ref()) {
         Some(hyper_error) => return to_connector_error(hyper_error)(err),
         None => match find_source::<hyper_util::client::legacy::Error>(err.as_ref()) {
             Some(hyper_util_err) => {
                 if hyper_util_err.is_connect()
                     || find_source::<std::io::Error>(hyper_util_err).is_some()
-655
+                {
                     return ConnectorError::io(err);

↧ Expand context

-657
+                }
                 err
-659
+            }
             None => err,
         },
     };
-663
     // otherwise, we have no idea!
     ConnectorError::other(err, None)
-666
+}
-667
 /// Convert a [`hyper::Error`] into a [`ConnectorError`]
 fn to_connector_error(err: &hyper::Error) -> fn(BoxError) -> ConnectorError {
     if err.is_timeout() || find_source::<timeout::HttpTimeoutError>(err).is_some() {
         return ConnectorError::timeout;
-672
+    }
     if err.is_user() {
         return ConnectorError::user;
-675
+    }
     if err.is_closed() || err.is_canceled() || find_source::<std::io::Error>(err).is_some() {

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/connect.rs

@@ -1,1 +164,249 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 use crate::client::connect;
 use crate::proxy;
 use aws_smithy_runtime_api::box_error::BoxError;
 use http_1x::Uri;
 use http_1x::{Extensions, HeaderMap, HeaderValue, Uri};
 use hyper::rt::{Read, ReadBufCursor, Write};
 use hyper_util::client::legacy::connect::{Connected, Connection};
 use hyper_util::client::proxy::matcher::Matcher;
 use pin_project_lite::pin_project;
 use std::fmt;
 use std::future::Future;
 use std::io;
 use std::io::IoSlice;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-20
 pub(crate) trait AsyncConn:
     Read + Write + Connection + Send + Sync + Unpin + 'static
-23
+{
-24
+}
-25
 impl<T: Read + Write + Connection + Send + Sync + Unpin + 'static> AsyncConn for T {}
-27
 pub(crate) type BoxConn = Box<dyn AsyncConn>;
-29
 // Future for connecting
 pub(crate) type Connecting = Pin<Box<dyn Future<Output = Result<Conn, BoxError>> + Send>>;
-32
 /// Authorization selected for cleartext HTTP requests sent through a proxy.
 #[derive(Clone)]
 pub(crate) struct ProxyAuthorization(HeaderValue);
-+
 impl fmt::Debug for ProxyAuthorization {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("ProxyAuthorization(** redacted **)")
-+
+    }
-+
+}
-+
 impl ProxyAuthorization {
     pub(crate) fn new(value: HeaderValue) -> Self {
         Self(value)
-+
+    }
-+
     /// Applies the selected authorization unless the caller supplied one.
     pub(crate) fn apply(&self, headers: &mut HeaderMap) {
         headers
             .entry(http_1x::header::PROXY_AUTHORIZATION)
             .or_insert_with(|| self.0.clone());
-+
+    }
-+
+}
-+
 /// How an established transport reaches its origin.
 #[derive(Clone, Debug)]
 pub(crate) enum ConnectPath {
     /// The transport reaches the origin without a proxy.
     Direct,
     /// HTTP/1 requests are sent to a forward proxy in absolute form.
     ForwardProxy {
         authorization: Option<ProxyAuthorization>,
     },
     /// The transport reaches the origin through an established CONNECT tunnel.
     #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
     ProxyTunnel,
-+
+}
-+
 impl ConnectPath {
     pub(crate) fn forward_proxy(authorization: Option<HeaderValue>) -> Self {
         Self::ForwardProxy {
             authorization: authorization.map(ProxyAuthorization::new),
-+
+        }
-+
+    }
-+
     /// Recovers the full path when available and preserves custom connector behavior.
     pub(crate) fn from_connected(connected: &Connected, extras: &Extensions) -> Self {
         extras.get::<Self>().cloned().unwrap_or_else(|| {
             if connected.is_proxied() {
                 Self::forward_proxy(None)
             } else {
                 Self::Direct
-+
+            }
         })
-+
+    }
-+
     /// Returns whether a proxy participates in the established transport.
     pub(crate) fn is_proxied(&self) -> bool {
         !matches!(self, Self::Direct)
-+
+    }
-+
     /// Returns whether HTTP/1 requests require an absolute-form target.
     pub(crate) fn uses_absolute_form(&self) -> bool {
         matches!(self, Self::ForwardProxy { .. })
-+
+    }
-+
     /// Applies forwarding credentials to an HTTP/1 request.
     pub(crate) fn apply_proxy_authorization(&self, headers: &mut HeaderMap) {
         if let Self::ForwardProxy {
             authorization: Some(authorization),
         } = self
-+
+        {
             authorization.apply(headers);
-+
+        }
-+
+    }
-+
+}
-+
 pin_project! {
     pub(crate) struct Conn {
         #[pin]
         pub(super)inner: BoxConn,
         pub(super) is_proxy: bool,
         pub(super) connect_path: ConnectPath,
-114
+    }
-115
+}
-116
 impl Connection for Conn {
     fn connected(&self) -> Connected {
         self.inner.connected().proxy(self.is_proxy)
         self.inner
             .connected()
             .proxy(self.connect_path.uses_absolute_form())
             .extra(self.connect_path.clone())
-123
+    }
-124
+}
-125
 impl Read for Conn {
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: ReadBufCursor<'_>,
     ) -> Poll<io::Result<()>> {
         let this = self.project();
         Read::poll_read(this.inner, cx, buf)
-134
+    }
-135
+}
-136
 impl Write for Conn {
     fn poll_write(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<Result<usize, io::Error>> {
         let this = self.project();
         Write::poll_write(this.inner, cx, buf)
-145
+    }
-146
     fn poll_write_vectored(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         bufs: &[IoSlice<'_>],
     ) -> Poll<Result<usize, io::Error>> {
         let this = self.project();
         Write::poll_write_vectored(this.inner, cx, bufs)
-154
+    }
-155
     fn is_write_vectored(&self) -> bool {
         self.inner.is_write_vectored()
-158
+    }
-159
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
         let this = self.project();
         Write::poll_flush(this.inner, cx)
-163
+    }
-164
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
         let this = self.project();
         Write::poll_shutdown(this.inner, cx)
-168
+    }
-169
+}
-170
 /// HTTP-only proxy connector for handling HTTP requests through HTTP proxies
 ///
 /// This connector handles the HTTP proxy logic when no TLS provider is selected,
 /// including request URL modification and proxy authentication.
 #[derive(Debug, Clone)]
 pub(crate) struct HttpProxyConnector<C> {
     inner: C,
     proxy_config: proxy::ProxyConfig,
     proxy_matcher: Option<Arc<Matcher>>,
-179
+}
-180
 impl<C> HttpProxyConnector<C> {
     pub(crate) fn new(inner: C, proxy_config: proxy::ProxyConfig) -> Self {
         let proxy_matcher = if proxy_config.is_disabled() {
             None
         } else {
             Some(Arc::new(proxy_config.into_hyper_util_matcher()))
         };
         Self {
             inner,
             proxy_config,
             proxy_matcher,
-191
+        }
-192
+    }
-193
+}
-194
 impl<C> tower::Service<Uri> for HttpProxyConnector<C>
 where
     C: tower::Service<Uri> + Clone + Send + 'static,
     C::Response: hyper::rt::Read
         + hyper::rt::Write
         + hyper_util::client::legacy::connect::Connection
         + Send
         + Sync
         + Unpin
         + 'static,
     C::Future: Send + 'static,
     C::Error: Into<BoxError>,
-207
+{
     type Response = connect::Conn;
     type Error = BoxError;
     type Future = connect::Connecting;
-211
     fn poll_ready(
         &mut self,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Result<(), Self::Error>> {
         self.inner.poll_ready(cx).map_err(Into::into)
-217
+    }
-218
     fn call(&mut self, dst: Uri) -> Self::Future {
         // Check if this request should be proxied
         let proxy_intercept = if !self.proxy_config.is_disabled() {
             let matcher = self.proxy_config.clone().into_hyper_util_matcher();
             matcher.intercept(&dst)
         } else {
             None
         };
         let proxy_intercept = self
             .proxy_matcher
             .as_ref()
             .and_then(|matcher| matcher.intercept(&dst));
-224
         if let Some(intercept) = proxy_intercept {
             // HTTP through proxy: Connect to proxy server
             let proxy_uri = intercept.uri().clone();
             let connect_path = ConnectPath::forward_proxy(intercept.basic_auth().cloned());
             let fut = self.inner.call(proxy_uri);
             Box::pin(async move {
                 let conn = fut.await.map_err(Into::into)?;
                 Ok(connect::Conn {
                     inner: Box::new(conn),
                     is_proxy: true,
                     connect_path,
                 })
             })
         } else {
             // Direct connection
             let fut = self.inner.call(dst);
             Box::pin(async move {
                 let conn = fut.await.map_err(Into::into)?;
                 Ok(connect::Conn {
                     inner: Box::new(conn),
                     is_proxy: false,
                     connect_path: ConnectPath::Direct,
                 })
             })
-247
+        }
-248
+    }
-249
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/builder.rs

@@ -1,1 +60,67 @@

↥ Expand context

  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Construction and validation for [`ConnectionPool`].
-7
 use super::establish::{self, TransportFactory};
 use super::maintenance::MaintenanceConfig;
 use super::registry::{AdmissionPolicy, PartitionRegistry, PartitionRegistryError};
 use super::{ConnectionPool, ConnectionReuseScope, Partition, PoolConfig, PoolInner};
 use crate::client::connect::HttpProxyConnector;
 use crate::client::dns::HyperUtilResolver;
 use crate::client::{TlsProviderSelected, TlsUnset};
 use crate::proxy::ProxyConfig;
 use crate::sync::Arc;
 use crate::tls::{self, TlsContext};
 use aws_smithy_async::rt::sleep::{default_async_sleep, AsyncSleep, SharedAsyncSleep};
 use aws_smithy_async::time::{SharedTimeSource, TimeSource};
 #[cfg(any(
     all(test, feature = "rt-tokio"),
     all(feature = "test-util", aws_sdk_unstable)
 ))]
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::dns::{ResolveDns, SharedDnsResolver};
 use aws_smithy_runtime_api::shared::IntoShared;
 #[cfg(any(
     all(test, feature = "rt-tokio"),
     all(feature = "test-util", aws_sdk_unstable)
 ))]
 use http_1x::Uri;
 use hyper_util::client::legacy::connect::dns::GaiResolver;
 use hyper_util::client::legacy::connect::dns::Name;
 use hyper_util::client::legacy::connect::HttpConnector;
 use std::error::Error;
 use std::fmt;
 use std::net::SocketAddr;
 use std::num::NonZeroUsize;
 use std::sync::atomic::AtomicU64;
 use std::time::Duration;
 #[cfg(any(
     all(test, feature = "rt-tokio"),
     all(feature = "test-util", aws_sdk_unstable)
 ))]
 use tower::Service;
-46
 /// Default duration for retaining an idle reusable connection.

↧ Expand context

 const DEFAULT_IDLE_TIMEOUT: Duration = Duration::from_secs(90);
-49
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 enum TriStateOption<T> {
     /// No option was set by the user, so construction applies its default.
     #[default]
     NotSet,
     /// The option was explicitly unset, so construction does not apply a default.
     ExplicitlyUnset,
     /// The caller supplied this value.
     Set(T),
-59
+}
-60
 impl<T> TriStateOption<T> {
     /// Preserves the public nested-option setter contract internally.
     fn from_nested(value: Option<Option<T>>) -> Self {
         match value {
             None => Self::NotSet,
             Some(None) => Self::ExplicitlyUnset,
             Some(Some(value)) => Self::Set(value),

@@ -63,70 +153,184 @@

↥ Expand context

-70
     /// Resolves the setting, applying `default` only when it was never set.
     fn resolve(self, default: Option<T>) -> Option<T> {
         match self {
             Self::NotSet => default,
             Self::ExplicitlyUnset => None,
             Self::Set(value) => Some(value),
-77
+        }
-78
+    }
-79
+}
-80
 /// Builds a partition-aware connection pool.
 #[derive(Clone)]
 pub struct Builder<Tls = TlsUnset> {
     /// Idle retention setting, including explicit disablement.
     idle_timeout: TriStateOption<Duration>,
     /// Clock used to assign and evaluate idle deadlines.
     time_source: Option<SharedTimeSource>,
     /// Runtime timer used by idle maintenance.
     sleep_impl: Option<SharedAsyncSleep>,

     /// Whether newly created TCP sockets disable Nagle's algorithm.
     tcp_nodelay: bool,
     /// TCP keepalive setting, including explicit disablement.
     tcp_keepalive: TriStateOption<Duration>,
     /// Optional live-connection limit per scheme, host, and port.
     max_connections_per_host: Option<usize>,
     /// Partitions allowed to reuse each other's connections.
     reuse_scope: ConnectionReuseScope,
     /// Complete explicit partition set, or `None` for anonymous topology.
     partitions: Option<Vec<Partition>>,
     /// Pool-wide proxy selection, authentication, and bypass policy.
     proxy_config: ProxyConfig,
     /// Caller-supplied DNS resolver, or `None` for the client default.
     dns_resolver: Option<SharedDnsResolver>,
     /// TLS typestate carried into protocol-specific terminal builders.
     tls: Tls,
-106
+}
-107
 impl Default for Builder<TlsUnset> {
     fn default() -> Self {
         Self {
             idle_timeout: TriStateOption::NotSet,
             time_source: None,
             sleep_impl: None,
             tcp_nodelay: true,
             tcp_keepalive: TriStateOption::NotSet,
             max_connections_per_host: None,
             reuse_scope: ConnectionReuseScope::default(),
             partitions: None,
             proxy_config: ProxyConfig::disabled(),
             dns_resolver: None,
             tls: TlsUnset {},
-122
+        }
-123
+    }
-124
+}
-125
 impl<Tls: fmt::Debug> fmt::Debug for Builder<Tls> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Builder")
             .field("idle_timeout", &self.idle_timeout)
             .field("time_source", &self.time_source)
             .field("sleep_impl", &self.sleep_impl)
             .field("tcp_nodelay", &self.tcp_nodelay)
             .field("tcp_keepalive", &self.tcp_keepalive)
             .field("max_connections_per_host", &self.max_connections_per_host)
             .field("reuse_scope", &self.reuse_scope)
             .field("partitions", &self.partitions.as_ref().map(Vec::len))
             .field(
                 "proxy_config",
                 &if self.proxy_config.is_disabled() {
                     "disabled"
                 } else if self.proxy_config.is_from_env() {
                     "environment"
                 } else {
                     "configured"
                 },
-+
+            )
             .field(
                 "dns_resolver",
                 &if self.dns_resolver.is_some() {
                     "custom"
                 } else {
                     "default"
                 },
-+
+            )
             .field("tls", &self.tls)
             .finish()
-157
+    }
-158
+}
-159
 impl<Tls> Builder<Tls> {
     /// Sets how long a reusable idle connection remains in the pool.
     ///
     /// Passing `None` disables idle expiration. When unset, the pool uses a
     /// 90-second timeout.

↧ Expand context

     pub fn idle_timeout(mut self, timeout: impl Into<Option<Duration>>) -> Self {
         self.idle_timeout = match timeout.into() {
             Some(timeout) => TriStateOption::Set(timeout),
             None => TriStateOption::ExplicitlyUnset,
         };
         self
-171
+    }
-172
     /// Mutably sets the idle timeout.
     ///
     /// The outer `None` restores the default; `Some(None)` disables expiry.
     pub fn set_idle_timeout(&mut self, timeout: Option<Option<Duration>>) -> &mut Self {
         self.idle_timeout = TriStateOption::from_nested(timeout);
         self
-179
+    }
-180
     /// Sets the clock used by pool maintenance.
     pub fn time_source(mut self, source: impl TimeSource + 'static) -> Self {
         self.time_source = Some(SharedTimeSource::new(source));
         self

@@ -212,243 +425,542 @@

↥ Expand context

     /// Mutably sets the live-connection bound described by
     /// [`Builder::max_connections_per_host`].
     pub fn set_max_connections_per_host(&mut self, limit: Option<usize>) -> &mut Self {
         self.max_connections_per_host = limit;
         self
-248
+    }
-249
     /// Selects which partitions may reuse each other's connections.
     pub fn connection_reuse_scope(mut self, scope: ConnectionReuseScope) -> Self {
         self.reuse_scope = scope;
         self
-254
+    }
-255
     /// Mutably selects the connection reuse scope.
     pub fn set_connection_reuse_scope(&mut self, scope: ConnectionReuseScope) -> &mut Self {
         self.reuse_scope = scope;
         self
-260
+    }
-261
     /// Declares the complete explicit partition set.

     pub fn partitions(mut self, partitions: impl IntoIterator<Item = Partition>) -> Self {
         self.partitions = Some(partitions.into_iter().collect());
         self
-266
+    }
-267
     /// Mutably declares or clears the explicit partition set.
     pub fn set_partitions(&mut self, partitions: Option<Vec<Partition>>) -> &mut Self {
         self.partitions = partitions;
         self
-272
+    }
-+
     /// Configures proxy selection for every connection established by this pool.
     ///
     /// The configuration applies across every partition. Proxying is disabled
     /// unless this method is called.
     pub fn proxy_config(mut self, config: ProxyConfig) -> Self {
         self.proxy_config = config;
         self
-+
+    }
-+
     /// Mutably configures pool-wide proxy selection.
     ///
     /// Passing `None` disables proxying.
     pub fn set_proxy_config(&mut self, config: Option<ProxyConfig>) -> &mut Self {
         self.proxy_config = config.unwrap_or_else(ProxyConfig::disabled);
         self
-+
+    }
-+
     /// Configures the DNS resolver used by connections established by this pool.
     ///
     /// The resolver applies across every partition. When unset, the client uses
     /// its default resolver, which currently delegates to the operating system.
     pub fn dns_resolver(mut self, resolver: impl ResolveDns + 'static) -> Self {
         self.dns_resolver = Some(resolver.into_shared());
         self
-+
+    }
-+
     /// Mutably configures the pool-wide DNS resolver.
     ///
     /// Passing `None` restores the client default.
     pub fn set_dns_resolver(&mut self, resolver: Option<SharedDnsResolver>) -> &mut Self {
         self.dns_resolver = resolver;
         self
-+
+    }
-307
+}
-308
 impl Builder<TlsUnset> {
     /// Selects the TLS provider used by HTTPS pool connections.
     pub fn tls_provider(self, provider: tls::Provider) -> Builder<TlsProviderSelected> {
         Builder {
             idle_timeout: self.idle_timeout,
             time_source: self.time_source,
             sleep_impl: self.sleep_impl,
             tcp_nodelay: self.tcp_nodelay,
             tcp_keepalive: self.tcp_keepalive,
             max_connections_per_host: self.max_connections_per_host,
             reuse_scope: self.reuse_scope,
             partitions: self.partitions,
             proxy_config: self.proxy_config,
             dns_resolver: self.dns_resolver,
             tls: TlsProviderSelected {
                 provider,
                 context: TlsContext::default(),
             },
-327
+        }
-328
+    }
-329
+}
-330
 crate::cfg::cfg_tls! {
     impl Builder<TlsProviderSelected> {
         /// Sets provider-specific TLS configuration for HTTPS connections.
         pub fn tls_context(mut self, context: TlsContext) -> Self {
             self.tls.context = context;
             self
-337
+        }
-338
         /// Mutably sets provider-specific TLS configuration.
         pub fn set_tls_context(&mut self, context: TlsContext) -> &mut Self {
             self.tls.context = context;
             self
-343
+        }
-344
         /// Builds a pool whose connector performs TLS and ALPN negotiation.
         ///
         /// This builder currently creates direct connections. Proxy routing
         /// remains available through the existing `Connector` API.
         pub fn build_https(self) -> Result<ConnectionPool, BuildError> {
             let resolver = self.dns_resolver.clone();
             match resolver {
                 Some(resolver) => {
                     self.build_https_with_resolver(HyperUtilResolver { resolver })
-+
+                }
                 None => self.build_https_with_resolver(GaiResolver::new()),
-+
+            }
-+
+        }
-+
         /// Builds an HTTPS transport around one concrete Hyper resolver.
         fn build_https_with_resolver<R>(self, resolver: R) -> Result<ConnectionPool, BuildError>
         where
             R: tower::Service<Name> + Clone + Send + Sync + 'static,
             R::Response: Iterator<Item = SocketAddr>,
             R::Future: Send,
             R::Error: Into<Box<dyn Error + Send + Sync>>,
-+
+        {
             validate_default_connector_interfaces(self.partitions.as_deref())?;
             let provider = self.tls.provider.clone();
             let context = self.tls.context.clone();
             let proxy_config = self.proxy_config.clone();
             match provider {
                 #[cfg(feature = "__rustls")]
                 tls::Provider::Rustls(crypto_mode) => {
                     let tcp_nodelay = self.tcp_nodelay;
                     let tcp_keepalive = self.tcp_keepalive.clone().resolve(None);
                     let transport = establish::from_cached_interface_connector(
                         move |interface, alpn_protocols| {
                             let mut connector =
                                 HttpConnector::new_with_resolver(GaiResolver::new());
                                 HttpConnector::new_with_resolver(resolver.clone());
                             connector.set_nodelay(tcp_nodelay);
                             connector.set_keepalive(tcp_keepalive);
                             set_default_connector_interface(&mut connector, interface);
                             tls::rustls_provider::build_connector::wrap_connector_with_alpn(
                                 connector,
                                 crypto_mode.clone(),
                                 &context,
                                 crate::proxy::ProxyConfig::disabled(),
                                 proxy_config.clone(),
                                 alpn_protocols,
-386
+                            )
                         },
                         true,
                     );
                     self.build_with_transport(transport)
-391
+                }
                 #[cfg(feature = "s2n-tls")]
                 tls::Provider::S2nTls => {
                     let tcp_nodelay = self.tcp_nodelay;
                     let tcp_keepalive = self.tcp_keepalive.clone().resolve(None);
                     let transport = establish::from_cached_interface_connector(
                         move |interface, _alpn_protocols| {
                             let mut connector =
                                 HttpConnector::new_with_resolver(GaiResolver::new());
                                 HttpConnector::new_with_resolver(resolver.clone());
                             connector.set_nodelay(tcp_nodelay);
                             connector.set_keepalive(tcp_keepalive);
                             set_default_connector_interface(&mut connector, interface);
                             tls::s2n_tls_provider::build_connector::wrap_connector(
                                 connector,
                                 &context,
                                 crate::proxy::ProxyConfig::disabled(),
                                 proxy_config.clone(),
-407
+                            )
                         },
                         false,
                     );
                     self.build_with_transport(transport)
-412
+                }
-413
+            }
-414
+        }
-415
+    }
-416
+}
-417
 impl Builder<TlsUnset> {
     /// Builds a pool for cleartext HTTP connections.
     #[doc(hidden)]
     pub fn build_http(self) -> Result<ConnectionPool, BuildError> {
         let resolver = self.dns_resolver.clone();
         match resolver {
             Some(resolver) => self.build_http_with_resolver(HyperUtilResolver { resolver }),
             None => self.build_http_with_resolver(GaiResolver::new()),
-+
+        }
-+
+    }
-+
     /// Builds a cleartext transport around one concrete Hyper resolver.
     fn build_http_with_resolver<R>(self, resolver: R) -> Result<ConnectionPool, BuildError>
     where
         R: tower::Service<Name> + Clone + Send + Sync + 'static,
         R::Response: Iterator<Item = SocketAddr>,
         R::Future: Send,
         R::Error: Into<Box<dyn Error + Send + Sync>>,
-+
+    {
         validate_default_connector_interfaces(self.partitions.as_deref())?;
         let mut connector = HttpConnector::new_with_resolver(GaiResolver::new());
         connector.set_nodelay(self.tcp_nodelay);
         connector.set_keepalive(self.tcp_keepalive.clone().resolve(None));
         let transport = establish::from_interface_connector(move |interface| {
             let mut connector = connector.clone();
             set_default_connector_interface(&mut connector, interface);
             connector
         });
         let tcp_nodelay = self.tcp_nodelay;
         let tcp_keepalive = self.tcp_keepalive.clone().resolve(None);
         let proxy_config = self.proxy_config.clone();
         let transport = if proxy_config.is_disabled() {
             establish::from_interface_connector(move |interface| {
                 let mut connector = HttpConnector::new_with_resolver(resolver.clone());
                 connector.set_nodelay(tcp_nodelay);
                 connector.set_keepalive(tcp_keepalive);
                 set_default_connector_interface(&mut connector, interface);
                 connector
             })
         } else {
             establish::from_interface_connector(move |interface| {
                 let mut connector = HttpConnector::new_with_resolver(resolver.clone());
                 connector.set_nodelay(tcp_nodelay);
                 connector.set_keepalive(tcp_keepalive);
                 set_default_connector_interface(&mut connector, interface);
                 HttpProxyConnector::new(connector, proxy_config.clone())
             })
         };
         self.build_with_transport(transport)
-458
+    }
-459
     /// Builds a pool around a test transport connector.
     #[cfg(all(feature = "test-util", aws_sdk_unstable))]
     #[doc(hidden)]
     pub fn build_http_with_tcp_connector<C, IO>(
         self,
         connector: C,
     ) -> Result<ConnectionPool, BuildError>
     where
         C: Service<Uri, Response = IO> + Clone + Send + Sync + 'static,
         C::Error: Into<BoxError>,
         C::Future: Send + 'static,
         IO: hyper::rt::Read
             + hyper::rt::Write
             + hyper_util::client::legacy::connect::Connection
             + Send
             + Sync
             + Unpin
             + 'static,
-478
+    {
         self.build_with_transport(establish::from_connector(connector))
-480
+    }
-481
     #[cfg(all(test, feature = "rt-tokio"))]
     pub(super) fn build_with_connector<C, IO>(
         self,
         connector: C,
     ) -> Result<ConnectionPool, BuildError>
     where
         C: Service<Uri, Response = IO> + Clone + Send + Sync + 'static,
         C::Error: Into<BoxError>,
         C::Future: Send + 'static,
         IO: hyper::rt::Read
             + hyper::rt::Write
             + hyper_util::client::legacy::connect::Connection
             + Send
             + Sync
             + Unpin
             + 'static,
-498
+    {
         self.build_with_transport(establish::from_connector(connector))
-500
+    }
-501
+}
-502
 impl<Tls> Builder<Tls> {
     /// Builds a pool with a transport supplied by a pool-internal test.
     #[cfg(test)]
     pub(super) fn build_with_transport_for_test(
         self,
         transport: std::sync::Arc<dyn TransportFactory>,
     ) -> Result<ConnectionPool, BuildError> {
         self.build_with_transport(transport)
-+
+    }
-+
     /// Validates pool policy and installs the type-erased transport factory.
     fn build_with_transport(
         self,
         transport: std::sync::Arc<dyn TransportFactory>,
     ) -> Result<ConnectionPool, BuildError> {
         let max_connections_per_host = match self.max_connections_per_host {
             Some(0) => {
                 return Err(BuildError::new(
                     "max_connections_per_host must be greater than zero",
                 ))

↧ Expand context

-523
+            }
             Some(limit) => NonZeroUsize::new(limit),
             None => None,
         };
         let idle_timeout = self.idle_timeout.resolve(Some(DEFAULT_IDLE_TIMEOUT));
         let time_source = self.time_source.unwrap_or_default();
         let sleep_impl = self.sleep_impl.or_else(default_async_sleep);
         if idle_timeout.is_some() && sleep_impl.is_none() {
             return Err(BuildError::new(
                 "idle_timeout requires an async sleep implementation",
             ));
-534
+        }
         let maintenance = MaintenanceConfig {
             idle_timeout,
             time_source: time_source.clone(),
             sleep: sleep_impl.clone(),
         };
         let admission_policy = max_connections_per_host
             .map(|limit| AdmissionPolicy::new(limit, transport.can_guarantee_http1()));
         let registry = PartitionRegistry::new(

@@ -509,626 +666,839 @@

↥ Expand context

     target_os = "android",
     target_os = "fuchsia",
     target_os = "illumos",
     target_os = "ios",
     target_os = "linux",
     target_os = "macos",
     target_os = "solaris",
     target_os = "tvos",
     target_os = "visionos",
     target_os = "watchos",
 )))]
 fn validate_default_connector_interfaces(
     _partitions: Option<&[Partition]>,
 ) -> Result<(), BuildError> {
     Ok(())
-641
+}
-642
 /// Applies this partition's interface to the default connector.
 #[cfg(any(
     target_os = "android",

     target_os = "fuchsia",
     target_os = "illumos",
     target_os = "ios",
     target_os = "linux",
     target_os = "macos",
     target_os = "solaris",
     target_os = "tvos",
     target_os = "visionos",
     target_os = "watchos",
 ))]
 fn set_default_connector_interface(
     connector: &mut HttpConnector<GaiResolver>,
     interface: Option<&str>,
 ) {
 fn set_default_connector_interface<R>(connector: &mut HttpConnector<R>, interface: Option<&str>) {
     if let Some(interface) = interface {
         connector.set_interface(interface);
-659
+    }
-660
+}
-661
 /// Leaves the default connector unchanged on unsupported targets.
 #[cfg(not(any(
     target_os = "android",
     target_os = "fuchsia",
     target_os = "illumos",
     target_os = "ios",
     target_os = "linux",
     target_os = "macos",
     target_os = "solaris",
     target_os = "tvos",
     target_os = "visionos",
     target_os = "watchos",
 )))]
 fn set_default_connector_interface(
     _connector: &mut HttpConnector<GaiResolver>,
     _interface: Option<&str>,
 ) {
 fn set_default_connector_interface<R>(_connector: &mut HttpConnector<R>, _interface: Option<&str>) {
-676
+}
-677
 #[cfg(all(test, not(smithy_http_client_loom)))]
 mod tests {
     use super::*;
     use crate::client::pool::{DriverSpawner, PartitionId};
     use std::future::Future;
     use std::net::IpAddr;
     use std::pin::Pin;
-685
     #[derive(Debug)]
     struct PendingSleep;
-688
     impl AsyncSleep for PendingSleep {
         fn sleep(&self, _duration: Duration) -> aws_smithy_async::rt::sleep::Sleep {
             aws_smithy_async::rt::sleep::Sleep::new(std::future::pending())
-692
+        }
-693
+    }
-694
     #[derive(Debug)]
     struct TestSpawner;
-697
     impl DriverSpawner for TestSpawner {
         fn spawn(&self, driver: Pin<Box<dyn Future<Output = ()> + Send + 'static>>) {
             drop(driver);
-701
+        }
-702
+    }
-703
     #[derive(Debug)]
     struct EmptyDnsResolver;
-+
     impl ResolveDns for EmptyDnsResolver {
         fn resolve_dns<'a>(
             &'a self,
             _name: &'a str,
         ) -> aws_smithy_runtime_api::client::dns::DnsFuture<'a> {
             aws_smithy_runtime_api::client::dns::DnsFuture::ready(Ok(Vec::<IpAddr>::new()))
-+
+        }
-+
+    }
-+
     fn partition(index: usize) -> Partition {
         Partition::new(PartitionId::from_index(index), TestSpawner)
-718
+    }
-719
     #[test]
     fn builder_preserves_unset_disabled_and_configured_settings() {
         let mut builder = Builder::default();
         assert_eq!(TriStateOption::NotSet, builder.idle_timeout);
         assert_eq!(TriStateOption::NotSet, builder.tcp_keepalive);
         assert!(builder.tcp_nodelay);
         assert_eq!(None, builder.max_connections_per_host);
         assert!(builder.partitions.is_none());
         assert!(builder.proxy_config.is_disabled());
         assert!(builder.dns_resolver.is_none());
-730
         builder.set_idle_timeout(Some(None));
         builder.set_tcp_keepalive(Some(None));
         assert_eq!(TriStateOption::ExplicitlyUnset, builder.idle_timeout);
         assert_eq!(TriStateOption::ExplicitlyUnset, builder.tcp_keepalive);
-735
         builder.set_idle_timeout(Some(Some(Duration::from_secs(5))));
         builder.set_tcp_keepalive(Some(Some(Duration::from_secs(10))));
         builder.set_tcp_nodelay(false);
         builder.set_max_connections_per_host(Some(3));
         builder.set_partitions(Some(vec![partition(7)]));
         assert_eq!(
             TriStateOption::Set(Duration::from_secs(5)),
             builder.idle_timeout
         );
         assert_eq!(
             TriStateOption::Set(Duration::from_secs(10)),
             builder.tcp_keepalive
         );
         assert!(!builder.tcp_nodelay);
         assert_eq!(Some(3), builder.max_connections_per_host);
         assert_eq!(1, builder.partitions.as_ref().unwrap().len());
-752
         builder.set_idle_timeout(None);
         builder.set_tcp_keepalive(None);
         builder.set_max_connections_per_host(None);
         builder.set_partitions(None);
         assert_eq!(TriStateOption::NotSet, builder.idle_timeout);
         assert_eq!(TriStateOption::NotSet, builder.tcp_keepalive);
         assert_eq!(None, builder.max_connections_per_host);
         assert!(builder.partitions.is_none());
-761
+    }
-762
     #[test]
     fn proxy_and_dns_settings_set_reset_and_redact() {
         let mut builder = Builder::default();
         builder.set_proxy_config(Some(
             ProxyConfig::http("http://proxy.test:8080")
                 .unwrap()
                 .with_basic_auth("secret-user", "secret-password"),
         ));
         builder.set_dns_resolver(Some(SharedDnsResolver::new(EmptyDnsResolver)));
-+
         assert!(!builder.proxy_config.is_disabled());
         assert!(builder.dns_resolver.is_some());
         let debug = format!("{builder:?}");
         assert!(debug.contains("configured"));
         assert!(debug.contains("custom"));
         assert!(!debug.contains("secret-user"));
         assert!(!debug.contains("secret-password"));
-+
         builder.set_proxy_config(None);
         builder.set_dns_resolver(None);
         assert!(builder.proxy_config.is_disabled());
         assert!(builder.dns_resolver.is_none());
-+
+    }
-+
     #[cfg(feature = "rustls-ring")]
     #[test]
     fn tls_selection_preserves_proxy_and_dns_settings() {
         let builder = Builder::default()
             .proxy_config(
                 ProxyConfig::http("http://proxy.test:8080")
                     .unwrap()
                     .with_basic_auth("secret-user", "secret-password"),
-+
+            )
             .dns_resolver(EmptyDnsResolver)
             .tls_provider(tls::Provider::rustls(
                 tls::rustls_provider::CryptoMode::Ring,
             ));
-+
         assert!(!builder.proxy_config.is_disabled());
         assert!(builder.dns_resolver.is_some());
         let debug = format!("{builder:?}");
         assert!(debug.contains("configured"));
         assert!(debug.contains("custom"));
         assert!(!debug.contains("secret-user"));
         assert!(!debug.contains("secret-password"));
-+
+    }
-+
     #[test]
     fn terminal_build_resolves_the_default_idle_timeout() {
         let pool = Builder::default()
             .sleep_impl(PendingSleep)
             .build_http()
             .unwrap();
-816
         assert_eq!(
             Some(Duration::from_secs(90)),
             pool.inner.config.idle_timeout

↧ Expand context

         );
-821
+    }
-822
     #[test]
     fn terminal_build_preserves_explicitly_disabled_idle_timeout() {
         let pool = Builder::default().idle_timeout(None).build_http().unwrap();
-826
         assert_eq!(None, pool.inner.config.idle_timeout);
-828
+    }
-829
     #[test]
     #[cfg(any(
         target_os = "android",
         target_os = "fuchsia",
         target_os = "illumos",
         target_os = "ios",
         target_os = "linux",
         target_os = "macos",
         target_os = "solaris",
         target_os = "tvos",

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/client.rs

@@ -1,1 +51,55 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */

-5
 //! Partition-bound handles for Smithy HTTP operations.
-7
 use super::partition::PartitionId;
 use super::registry::PartitionState;
 use super::ConnectionPool;
 use crate::client::downcast_error;
 use crate::client::timeout::{self, TimeoutKind};
 use crate::sync::Arc;
 use aws_smithy_async::rt::sleep::{default_async_sleep, SharedAsyncSleep};
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::connector_metadata::ConnectorMetadata;
 use aws_smithy_runtime_api::client::http::{
     HttpClient, HttpConnector, HttpConnectorFuture, HttpConnectorSettings, SharedHttpConnector,
 };
 use aws_smithy_runtime_api::client::orchestrator::{HttpRequest, HttpResponse};
 use aws_smithy_runtime_api::client::result::ConnectorError;
 use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
 use aws_smithy_runtime_api::client::runtime_components::{
     RuntimeComponents, RuntimeComponentsBuilder,
 };
 use aws_smithy_types::config_bag::ConfigBag;
 use std::borrow::Cow;
 use std::error::Error;
 use std::fmt;
 use std::time::Duration;
-30
 /// Smithy HTTP client bound to one connection-pool partition.
 ///
 /// Construction resolves the partition once. Every request uses that partition
 /// for establishment placement and local reuse, while the configured reuse
 /// scope may permit dispatch through a peer partition's connection. Cloning a

↧ Expand context

 /// client shares the pool, resolved partition state, and reusable connections.
 #[derive(Clone)]
 pub struct Client {
     /// Shared connection pool and immutable policy.
     pool: ConnectionPool,
     /// Resolved runtime and network placement for this client.
     partition: Arc<PartitionState>,
-43
+}
-44
 impl Client {
     /// Creates a client for a pool built without explicit partitions.
     ///
     /// # Errors
     ///
     /// Returns [`ClientBuildError`] when the pool contains only explicit
     /// partitions.
     pub fn new(pool: &ConnectionPool) -> Result<Self, ClientBuildError> {
         Self::from_partition(pool, PartitionId::ANONYMOUS)
-54
+    }
-55

@@ -56,60 +115,130 @@

↥ Expand context

     ///
     /// # Errors
     ///
     /// Returns [`ClientBuildError`] when the pool does not contain `id`.
     pub fn from_partition(
         pool: &ConnectionPool,
         id: PartitionId,
     ) -> Result<Self, ClientBuildError> {
         let partition = pool
             .inner
             .registry
             .partition(id)
             .ok_or_else(|| ClientBuildError::invalid_partition(id))?;
         Ok(Self {
             pool: pool.clone(),
             partition,
         })
-77
+    }
-78
+}
-79

 impl fmt::Debug for Client {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Client")
             .field("partition", &self.partition.id())
             .field("pool", &self.pool)
             .finish_non_exhaustive()
-86
+    }
-87
+}
-88
 impl HttpClient for Client {
     fn validate_base_client_config(
         &self,
         _: &RuntimeComponentsBuilder,
         _: &ConfigBag,
     ) -> Result<(), BoxError> {
         self.pool
             .inner
             .transport
             .initialize_for_partition(&self.partition)
-+
+    }
-+
     fn http_connector(
         &self,
         settings: &HttpConnectorSettings,
         components: &RuntimeComponents,
     ) -> SharedHttpConnector {
         let connect_timeout = settings.connect_timeout();
         let read_timeout = settings.read_timeout();
         let sleep = components.sleep_impl().or_else(default_async_sleep);
-109
         SharedHttpConnector::new(PoolConnector {

↧ Expand context

             pool: self.pool.clone(),
             partition: self.partition.clone(),
             connect_timeout,
             read_timeout,
             sleep,
         })
-117
+    }
-118
     fn connector_metadata(&self) -> Option<ConnectorMetadata> {
         Some(ConnectorMetadata::new("hyper", Some(Cow::Borrowed("1.x"))))
-121
+    }
-122
+}
-123
 /// Error returned when a [`Client`] cannot be resolved from a pool.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ClientBuildError {
     /// Construction failure represented without exposing the internal enum.
     kind: ClientBuildErrorKind,
-129
+}
-130

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/connection.rs

@@ -1,1 +47,48 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Protocol-independent connection lifetime.
 //!

 //! [`ConnectionState`] serializes dispatch commitment with logical close.
 //! [`DispatchGuard`] accounts for accepted requests.
 //! [`PhysicalConnectionGuard`] follows root I/O until the client releases its
 //! physical connection handle, including transfer through a protocol upgrade.
 //! The operating system may continue TCP teardown afterward. Logical close
 //! returns bounded capacity without waiting for either lifetime to finish.
-14
 use super::admission::CapacityLease;
 use super::origin::OriginKey;
 use super::partition::PartitionId;
 use crate::client::connect::ConnectPath;
 use crate::sync::{Arc, Mutex};
 pub use aws_smithy_runtime_api::client::connection::ConnectionId;
 use aws_smithy_runtime_api::client::connection::ConnectionMetadata;
 use http_1x::Extensions;
 use hyper::rt::{Read, ReadBufCursor, Write};
 use hyper_util::client::legacy::connect::{Connected, Connection, HttpInfo};
 use pin_project_lite::pin_project;
 use std::fmt;
 use std::io::{self, IoSlice};
 use std::net::SocketAddr;

↧ Expand context

 use std::pin::Pin;
 use std::task::{Context, Poll};
-31
 /// Why a connection stopped accepting new work.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[non_exhaustive]
 pub enum CloseReason {
     /// The connection exceeded its configured idle timeout.
     IdleTimeout,
     /// The connection was explicitly marked unsafe for reuse.
     Poisoned,
     /// The protocol driver or peer closed the connection.
     ProtocolClosed,
     /// HTTP/1 did not prove a complete reusable message boundary.
     IncompleteH1Exchange,
     /// The transport left HTTP/1 pool ownership through an upgrade.
     Upgraded,
     /// The connection closed to move bounded capacity to another cell.
     Reclaimed,
     /// The connection pool was dropped.

@@ -51,52 +200,202 @@

↥ Expand context

-52
+}
-53
 /// Protocol selected for one installed physical connection.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(super) enum NegotiatedProtocol {
     /// HTTP/1.1 with one exclusive request sender.
     Http1,
     /// HTTP/2 with a multiplexed request sender.
     Http2,
-61
+}
-62
 /// Immutable identity and transport facts shared by a connection's owners.
 ///
 /// The protocol record, request metadata, tracing, and lifecycle events
 /// all retain this one allocation rather than reconstructing origin or address
 /// data at each transition.
 #[derive(Debug)]
 pub(super) struct ConnectionInfo {
     /// Stable identity assigned by the owning pool.
     id: ConnectionId,

     /// Canonical origin this connection may serve.
     origin: OriginKey,
     /// Partition that retains the transport and protocol driver.
     owner_partition: PartitionId,
     /// Protocol selected by configuration or ALPN.
     protocol: NegotiatedProtocol,
     /// Local socket address reported by the connector, when available.
     local_addr: Option<SocketAddr>,
     /// Remote socket address reported by the connector, when available.
     remote_addr: Option<SocketAddr>,
     /// Whether the transport reaches the origin through a proxy.
     proxied: bool,
     /// How the established transport reaches its origin.
     connect_path: ConnectPath,
     /// Connector metadata copied into every response on this connection.
     connected: Connected,
-86
+}
-87
 impl ConnectionInfo {
     /// Captures immutable facts after transport negotiation selects a protocol.
     pub(super) fn new(
         id: ConnectionId,
         origin: OriginKey,
         owner_partition: PartitionId,
         protocol: NegotiatedProtocol,
         connected: Connected,
     ) -> Arc<Self> {
         let mut extras = Extensions::new();
         connected.get_extras(&mut extras);
         let http_info = extras.get::<HttpInfo>();
         let connect_path = ConnectPath::from_connected(&connected, &extras);
         Arc::new(Self {
             id,
             origin,
             owner_partition,
             protocol,
             local_addr: http_info.map(HttpInfo::local_addr),
             remote_addr: http_info.map(HttpInfo::remote_addr),
             proxied: connected.is_proxied(),
             connect_path,
             connected,
         })
-111
+    }
-112
     /// Returns the pool-assigned physical connection identity.
     pub(super) fn id(&self) -> ConnectionId {
         self.id
-116
+    }
-117
     /// Returns the canonical origin this connection may serve.
     pub(super) fn origin(&self) -> &OriginKey {
         &self.origin
-121
+    }
-122
     /// Returns the partition that owns this connection's I/O and driver.
     pub(super) fn owner_partition(&self) -> PartitionId {
         self.owner_partition
-126
+    }
-127
     /// Returns the established HTTP protocol.
     pub(super) fn protocol(&self) -> NegotiatedProtocol {
         self.protocol
-131
+    }
-132
     /// Returns the connector-reported local socket address.
     #[cfg(test)]
     pub(super) fn local_addr(&self) -> Option<SocketAddr> {
         self.local_addr
-137
+    }
-138
     /// Returns the connector-reported remote socket address.
     #[cfg(test)]
     pub(super) fn remote_addr(&self) -> Option<SocketAddr> {
         self.remote_addr
-143
+    }
-144
     /// Returns whether the origin is reached through a proxy.
     pub(super) fn is_proxied(&self) -> bool {
         self.proxied
     /// Returns how this connection reaches its origin.
     pub(super) fn connect_path(&self) -> &ConnectPath {
         &self.connect_path
-148
+    }
-149
     /// Copies connector-provided values into a response extension map.
     pub(super) fn apply_connector_extras(&self, extensions: &mut Extensions) {
         self.connected.get_extras(extensions);
-153
+    }
-154
     /// Builds Smithy metadata with close authority for this H1 record.
     pub(super) fn metadata(&self, close: super::cell::h1::H1CloseHandle) -> ConnectionMetadata {
         let mut builder = ConnectionMetadata::builder()
             .proxied(self.proxied)
             .proxied(self.connect_path.is_proxied())
             .connection_id(self.id)
             .poison_fn(move || {
                 close.close(CloseReason::Poisoned);
             });
         builder
             .set_local_addr(self.local_addr)
             .set_remote_addr(self.remote_addr);
         builder.build()
-167
+    }
-168
     /// Builds Smithy metadata with close authority for this H2 generation.
     pub(super) fn h2_metadata(&self, close: super::cell::h2::H2CloseHandle) -> ConnectionMetadata {
         let mut builder = ConnectionMetadata::builder()
             .proxied(self.proxied)
             .proxied(self.connect_path.is_proxied())
             .connection_id(self.id)
             .poison_fn(move || {
                 close.close(CloseReason::Poisoned);
             });
         builder
             .set_local_addr(self.local_addr)
             .set_remote_addr(self.remote_addr);
         builder.build()
-181
+    }
-182

↧ Expand context

     /// Creates synthetic HTTP/1 information for state-machine tests.
     #[cfg(test)]
     pub(super) fn for_test(id: ConnectionId, owner_partition: PartitionId) -> Arc<Self> {
         Self::new(
             id,
             OriginKey::from_parts(http_1x::uri::Scheme::HTTPS, "example.com", None)
                 .expect("synthetic test origin is valid"),
             owner_partition,
             NegotiatedProtocol::Http1,
             Connected::new(),
-193
+        )
-194
+    }
-195
+}
-196
 /// Shared connection ownership from negotiated transport through close.
 pub(super) struct ConnectionState {
     /// Identity and transport facts shared with metadata and lifecycle events.
     info: Arc<ConnectionInfo>,
     /// Dispatch, logical-close, and physical-connection completion state.
     lifecycle: Mutex<ConnectionLifecycle>,

@@ -724,726 +784,786 @@

↥ Expand context

         assert_eq!(PartitionId::from_index(0), connection.owner_partition());
         assert!(!connection.probe().physical_connection_complete);
         physical.release();
         assert!(connection.probe().physical_connection_complete);
-730
+    }
-731
     #[test]
     fn connection_state_retains_immutable_connection_info() {
         #[derive(Clone, Debug, Eq, PartialEq)]
         struct ConnectorMarker(&'static str);
-736
         let origin =
             OriginKey::from_parts(http_1x::uri::Scheme::HTTPS, "example.com", None).unwrap();
         let info = ConnectionInfo::new(
             ConnectionId::new(7),
             origin.clone(),
             PartitionId::from_index(2),
             NegotiatedProtocol::Http1,
             Connected::new()
                 .proxy(true)

                 .extra(ConnectorMarker("connector-extra")),
         );
         let (connection, _physical) = ConnectionState::unbounded(info);
-749
         assert_eq!(ConnectionId::new(7), connection.info().id());
         assert_eq!(&origin, connection.info().origin());
         assert_eq!(PartitionId::from_index(2), connection.owner_partition());
         assert_eq!(NegotiatedProtocol::Http1, connection.info().protocol());
         assert_eq!(None, connection.info().local_addr());
         assert_eq!(None, connection.info().remote_addr());
         assert!(connection.info().is_proxied());
         assert!(connection.info().connect_path().is_proxied());
         let mut extensions = Extensions::new();
         connection.info().apply_connector_extras(&mut extensions);
         assert_eq!(
             Some(&ConnectorMarker("connector-extra")),
             extensions.get::<ConnectorMarker>()
         );
-763
+    }
-764
     #[test]
     fn dropping_connection_io_completes_physical_connection_ownership() {

↧ Expand context

         let (connection, physical) = ConnectionState::unbounded(test_info(1));
         let io = ConnectionIo::new("transport", physical);
         assert_eq!(&"transport", io.get_ref());
         assert!(!connection.probe().physical_connection_complete);
-771
         drop(io);
-773
         assert!(connection.probe().physical_connection_complete);
-775
+    }
-776
+}
-777
 #[cfg(all(test, smithy_http_client_loom))]
 mod loom_tests {
     use super::*;
     use crate::client::pool::admission::OriginAdmission;
     use std::num::NonZeroUsize;
-783
     fn test_info(id: u64) -> Arc<ConnectionInfo> {
         ConnectionInfo::for_test(ConnectionId::new(id), PartitionId::from_index(0))
-786
+    }

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/dispatch/h1.rs

@@ -44,44 +104,106 @@

↥ Expand context

     context: &AcquisitionContext,
     mut request: Request<SdkBody>,
     mut selection: H1Selection,
 ) -> Result<H1DispatchOutcome, ConnectorError> {
     let request_method = request.method().clone();
     let reused = selection.is_reused();
     let connection = selection.connection().clone();
     let close_handle = selection.close_handle();
     let captured_metadata = request
         .extensions()
         .get::<CaptureSmithyConnection>()
         .cloned()
         .map(|capture| {
             let metadata = connection.info().metadata(close_handle.clone());
             let captured = metadata.clone();
             capture.set_connection_retriever(move || Some(captured.clone()));
             metadata
         });
-62
     if request.version() == Version::HTTP_2 {

         let metadata =
             captured_metadata.unwrap_or_else(|| connection.info().metadata(close_handle));
         return Err(ConnectorError::user(
             "an HTTP/2 request cannot use an HTTP/1 connection".into(),
-68
+        )
         .with_connection(metadata));
-70
+    }
-71
     add_host_header(&mut request, &context.absolute_uri)
         .map_err(|error| ConnectorError::user(error.into()))?;
     rewrite_h1_request_target(&mut request, connection.info().is_proxied());
     let connect_path = connection.info().connect_path();
     connect_path.apply_proxy_authorization(request.headers_mut());
     rewrite_h1_request_target(&mut request, connect_path.uses_absolute_form());
-77
     // Commit against logical close before transferring the request to
     // Hyper. A close that wins this race leaves the request untouched.
     let Some(dispatch) = ConnectionState::try_commit_dispatch(&connection) else {
         tracing::trace!(
             connection_id = %connection.id(),
             request_partition = ?context.partition.id(),
             connection_partition = ?connection.owner_partition(),
             origin_scheme = %connection.info().origin().scheme(),
             origin_host = connection.info().origin().host(),

↧ Expand context

             origin_port = ?connection.info().origin().port(),
             "HTTP/1 selection became stale before dispatch"
         );
         *request.uri_mut() = context.absolute_uri.clone();
         selection.retire_connection(CloseReason::ProtocolClosed);
         return Ok(H1DispatchOutcome::NotAccepted(request));
     };
     let send = selection.sender_mut().hyper_mut().try_send_request(request);
-95
     let exchange = selection.into_exchange();
     match send.await {
         Ok(mut response) => {
             // Response-body ownership keeps both the accepted dispatch
             // and exclusive request handle out of the pool until Hyper
             // proves a complete message boundary.
             connection
                 .info()
                 .apply_connector_extras(response.extensions_mut());
             Ok(H1DispatchOutcome::Response(guard_h1_response(
                 response,

@@ -396,398 +455,458 @@

↥ Expand context

     let value =
         http_1x::HeaderValue::from_str(&host).map_err(RequestDispatchError::InvalidHostHeader)?;
     request.headers_mut().insert(http_1x::header::HOST, value);
     request.extensions_mut().insert(H1HostHeaderInserted);
     Ok(())
-403
+}
-404
 /// Rewrites an absolute URI into the request target required by HTTP/1.
 fn rewrite_h1_request_target(request: &mut Request<SdkBody>, is_proxied: bool) {
     use http_1x::uri::Parts;
-408
     if request.method() == Method::CONNECT {
         if let Some(authority) = request.uri().authority().cloned() {
             let mut parts = Parts::default();
             parts.authority = Some(authority);
             *request.uri_mut() = Uri::from_parts(parts).expect("request authority is a valid URI");
-414
+        }
         return;
-416
+    }
     if is_proxied {

         return;
-419
+    }
     let mut parts = Parts::default();
     parts.path_and_query = request.uri().path_and_query().cloned();
     *request.uri_mut() = Uri::from_parts(parts).expect("request path and query are a valid URI");
-423
+}
-424
 #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
 mod tests {
     use super::*;
     use crate::client::connect::ConnectPath;
     use crate::client::pool::cell::h1::H1Sender;
     use crate::client::pool::cell::OriginCell;
     use crate::client::pool::connection::ConnectionInfo;
     use crate::client::pool::dispatch::RequestOptions;
     use crate::client::pool::registry::PartitionState;
     use crate::client::pool::{
         Client, ConnectionId, ConnectionPool, ConnectionReuseScope, Partition, PartitionId,
         TokioDriverSpawner,
     };
     use crate::client::timeout::test::{NeverConnects, NeverReplies};

↧ Expand context

     use crate::sync::Arc;
     use aws_smithy_async::rt::sleep::TokioSleep;
     use aws_smithy_runtime_api::client::connection::CaptureSmithyConnection;
     use aws_smithy_runtime_api::client::http::{HttpClient, HttpConnector, HttpConnectorSettings};
     use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
     use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
     use http_body_util::BodyExt;
     use hyper_util::client::legacy::connect::{Connected, Connection};
     use hyper_util::rt::TokioIo;
     use std::future::Future;
     use std::io::{self, IoSlice};
     use std::sync::atomic::{AtomicUsize, Ordering};
     use std::task::{Context, Poll};
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::net::{TcpListener, TcpStream};
     use tokio::sync::Notify;
     use tower::Service;
-456
     #[derive(Debug)]
     struct DroppingSpawner;

@@ -799,802 +858,887 @@

↥ Expand context

             ("IPv6 default port", "http://[::1]:80/", None, "[::1]"),
-803
+            (
                 "IPv6 explicit port",
                 "http://[::1]:8080/",
                 None,
                 "[::1]:8080",
             ),
         ];
-810
         for (name, uri, existing, expected) in cases {
             let absolute_uri: Uri = uri.parse().unwrap();
             let mut request = Request::get(absolute_uri.clone())
                 .body(SdkBody::empty())
                 .unwrap();
             if let Some(existing) = existing {
                 request
                     .headers_mut()
                     .insert(http_1x::header::HOST, existing.parse().unwrap());
-820
+            }
-821

             add_host_header(&mut request, &absolute_uri).unwrap();
-823
             assert_eq!(
                 expected,
                 request.headers()[http_1x::header::HOST].to_str().unwrap(),
                 "{name}"
             );
-829
+        }
-830
+    }
-831
     #[test]
     fn forward_proxy_authorization_preserves_a_caller_value() {
         let connect_path =
             ConnectPath::forward_proxy(Some(http_1x::HeaderValue::from_static("Basic connector")));
         let caller_value = http_1x::HeaderValue::from_static("Basic caller");
-+
         let mut request = Request::get("http://example.com/")
             .body(SdkBody::empty())
             .unwrap();
         connect_path.apply_proxy_authorization(request.headers_mut());
         assert_eq!(
             request.headers()[http_1x::header::PROXY_AUTHORIZATION],
             "Basic connector"
         );
-+
         let mut request = Request::get("http://example.com/")
             .header(http_1x::header::PROXY_AUTHORIZATION, caller_value.clone())
             .body(SdkBody::empty())
             .unwrap();
         connect_path.apply_proxy_authorization(request.headers_mut());
         assert_eq!(
             request.headers().get(http_1x::header::PROXY_AUTHORIZATION),
             Some(&caller_value)
         );
-+
+    }
-+
     #[test]
     fn h1_request_target_uses_the_required_wire_form() {
         let cases = [
-861
+            (
                 "CONNECT",
                 Method::CONNECT,
                 "http://example.com:8443/ignored",
                 false,
                 "example.com:8443",
             ),

↧ Expand context

-868
+            (
                 "direct",
                 Method::GET,
                 "http://example.com/path?key=value",
                 false,
                 "/path?key=value",
             ),
-875
+            (
                 "proxy",
                 Method::GET,
                 "http://example.com/path?key=value",
                 true,
                 "http://example.com/path?key=value",
             ),
         ];
-883
         for (name, method, uri, is_proxied, expected) in cases {
             let mut request = Request::builder()
                 .method(method)
                 .uri(uri)

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/establish/transport.rs

@@ -1,1 +46,47 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */

-5
 //! Transport connection policy below HTTP protocol establishment.
 //!
 //! This module owns the boundary from a pool connection attempt to connected
 //! I/O with a negotiated protocol. [`TransportConnectContext`] keeps placement,
 //! timeout, and ALPN inputs together. A factory may delegate DNS, proxy, TLS,
 //! and ALPN to an injected connector, but it must report whether an HTTP/1-only
 //! attempt is enforceable before admission may reclaim an idle H2 connection.
 //!
 //! Cached factories retain configured connector services, not connections or
 //! DNS results. Network I/O begins only when [`TransportFactory::connect`] is
 //! called.
 //! DNS results. Base client validation initializes those services for the
 //! selected partition without network I/O. Network I/O begins only when
 //! [`TransportFactory::connect`] is called.
-18
 use super::super::admission::ProtocolRequirement;
 use super::super::registry::PartitionState;
 use crate::client::connect::{AsyncConn, BoxConn};
 use crate::client::timeout::{self, TimeoutKind};
 use aws_smithy_async::rt::sleep::SharedAsyncSleep;
 use aws_smithy_runtime_api::box_error::BoxError;
 use http_1x::Uri;
 use std::future::{poll_fn, Future};
 use std::pin::Pin;

↧ Expand context

 use std::sync::Arc as StdArc;
 use std::time::Duration;
 use tower::Service;
-31
 /// Timeout policy for one transport connection operation.
 ///
 /// Connector readiness completes before this timeout starts. Keeping the
 /// duration and timer together lets request acquisition pass one complete
 /// timeout value into transport construction.
 #[derive(Clone, Debug)]
 pub(in crate::client::pool) struct TransportTimeout {
     /// Maximum duration of the connector's connection future.
     duration: Duration,
     /// Runtime timer used to enforce the deadline.
     sleep: SharedAsyncSleep,
-43
+}
-44
 impl TransportTimeout {
     /// Creates a timeout enforced by the supplied runtime timer.
     pub(in crate::client::pool) fn new(duration: Duration, sleep: SharedAsyncSleep) -> Self {

@@ -74,75 +133,144 @@

↥ Expand context

-75
+}
-76
 impl<'a> TransportConnectContext<'a> {
     /// Creates transport inputs after request protocol classification.
     pub(super) fn new(
         partition: &'a PartitionState,
         uri: Uri,
         timeout: Option<TransportTimeout>,
         requirement: ProtocolRequirement,
     ) -> Self {
         Self {
             partition,
             uri,
             timeout,
             alpn_protocols: alpn_protocols(requirement),
-90
+        }
-91
+    }
-92
+}
-93
 /// Future returned by a type-erased transport factory.

 type TransportFuture = Pin<Box<dyn Future<Output = Result<BoxConn, BoxError>> + Send + 'static>>;
-96
 /// Type-erased transport construction below HTTP protocol establishment.
 ///
 /// A pool retains one factory. The concrete connector remains responsible for
 /// the transport stages it implements and for returning connector metadata.
 /// Protocol establishment consumes the resulting [`BoxConn`].
 pub(in crate::client::pool) trait TransportFactory:
     Send + Sync + 'static
-104
+{
     /// Initializes connector services used by one partition.
     ///
     /// Initialization must be idempotent and must not perform DNS resolution
     /// or network I/O. Factories without retained initialization state may use
     /// the default no-op implementation.
     fn initialize_for_partition(&self, partition: &PartitionState) -> Result<(), BoxError> {
         let _ = partition;
         Ok(())
-+
+    }
-+
     /// Returns whether an H1-required attempt is guaranteed to negotiate H1.
     fn can_guarantee_http1(&self) -> bool;
-117
     /// Creates one partition-bound transport.
     ///
     /// Connector readiness completes before the connection timeout starts.
     fn connect(&self, context: TransportConnectContext<'_>) -> TransportFuture;
-122
+}
-123
 /// Connector factory whose concrete service is selected by interface.

↧ Expand context

 struct ServiceTransportFactory<F> {
     /// Builds a connector with the selected network-interface binding.
     connector_for_interface: F,
     /// Whether every H1-required connection is guaranteed to negotiate H1.
     can_guarantee_http1: bool,
-130
+}
-131
 impl<F, C, IO> TransportFactory for ServiceTransportFactory<F>
 where
     F: Fn(Option<&str>) -> C + Send + Sync + 'static,
     C: Service<Uri, Response = IO> + Send + 'static,
     C::Error: Into<BoxError>,
     C::Future: Send + 'static,
     IO: AsyncConn,
-139
+{
     fn can_guarantee_http1(&self) -> bool {
         self.can_guarantee_http1
-142
+    }
-143
     fn connect(&self, context: TransportConnectContext<'_>) -> TransportFuture {

@@ -180,191 +0,569 @@

↥ Expand context

     connector_for_interface: F,
 ) -> StdArc<dyn TransportFactory>
 where
     F: Fn(Option<&str>) -> C + Send + Sync + 'static,
     C: Service<Uri, Response = IO> + Send + 'static,
     C::Error: Into<BoxError>,
     C::Future: Send + 'static,
     IO: AsyncConn,
-199
+{
     service_factory(connector_for_interface, true)
-201
+}
-202
 /// Erases a service connector and its HTTP/1 negotiation guarantee.
 fn service_factory<F, C, IO>(
     connector_for_interface: F,
     can_guarantee_http1: bool,
 ) -> StdArc<dyn TransportFactory>
 where
     F: Fn(Option<&str>) -> C + Send + Sync + 'static,
     C: Service<Uri, Response = IO> + Send + 'static,

     C::Error: Into<BoxError>,
     C::Future: Send + 'static,
     IO: AsyncConn,
-214
+{
     StdArc::new(ServiceTransportFactory {
         connector_for_interface,
         can_guarantee_http1,
     })
-219
+}
-220
 /// Identifies one configured connector service in the TLS transport cache.
 ///
 /// Partition identity is deliberately absent. Partitions with equal interface
 /// bindings use the same connector configuration and therefore share entries.
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 struct ConnectorCacheKey {
     /// Network-interface binding applied before connect.
     interface: Option<StdArc<str>>,
     /// Protocol offer installed in the TLS connector.
     alpn_protocols: AlpnProtocols,
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 impl ConnectorCacheKey {
     /// Derives the connector configuration used by one partition and offer.
     fn for_partition(partition: &PartitionState, alpn_protocols: AlpnProtocols) -> Self {
         Self {
             interface: partition.interface().cloned(),
             alpn_protocols,
-+
+        }
-+
+    }
-+
     /// Returns the borrowed interface name expected by connector builders.
     fn interface(&self) -> Option<&str> {
         self.interface.as_deref()
-+
+    }
-+
+}
-+
 /// Retains configured TLS connector services by placement and ALPN offer.
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 struct CachedTransportFactory<F, C> {
     /// Constructs a connector service for one exact cache key.
     factory: F,
     /// Whether every H1-required connection is guaranteed to negotiate H1.
     can_guarantee_http1: bool,
     /// Connector services constructed during client validation or first use.
     connectors: crate::sync::Mutex<std::collections::HashMap<ConnectorCacheKey, C>>,
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 impl<F, C> CachedTransportFactory<F, C>
 where
     F: Fn(Option<&str>, AlpnProtocols) -> C,
     C: Clone,
-+
+{
     /// Returns the retained connector for one partition and protocol offer.
     fn connector(&self, partition: &PartitionState, alpn_protocols: AlpnProtocols) -> C {
         let key = ConnectorCacheKey::for_partition(partition, alpn_protocols);
         match self.connectors.lock().entry(key) {
             std::collections::hash_map::Entry::Occupied(entry) => entry.get().clone(),
             std::collections::hash_map::Entry::Vacant(entry) => {
                 let connector = (self.factory)(entry.key().interface(), entry.key().alpn_protocols);
                 entry.insert(connector).clone()
-+
+            }
-+
+        }
-+
+    }
-+
     /// Materializes every connector variant this partition may select.
     fn initialize_connectors_for_partition(&self, partition: &PartitionState) {
         drop(self.connector(partition, HTTP_ALPN_PROTOCOLS));
         drop(self.connector(partition, HTTP1_ALPN_PROTOCOLS));
-+
+    }
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 impl<F, C, IO> TransportFactory for CachedTransportFactory<F, C>
 where
     F: Fn(Option<&str>, AlpnProtocols) -> C + Send + Sync + 'static,
     C: Service<Uri, Response = IO> + Clone + Send + Sync + 'static,
     C::Error: Into<BoxError>,
     C::Future: Send + 'static,
     IO: AsyncConn,
-+
+{
     fn initialize_for_partition(&self, partition: &PartitionState) -> Result<(), BoxError> {
         self.initialize_connectors_for_partition(partition);
         Ok(())
-+
+    }
-+
     fn can_guarantee_http1(&self) -> bool {
         self.can_guarantee_http1
-+
+    }
-+
     fn connect(&self, context: TransportConnectContext<'_>) -> TransportFuture {
         let TransportConnectContext {
             partition,
             uri,
             timeout,
             alpn_protocols,
         } = context;
         let mut connector = self.connector(partition, alpn_protocols);
         Box::pin(async move {
             poll_fn(|cx| connector.poll_ready(cx))
                 .await
                 .map_err(Into::into)?;
             let connect = connector.call(uri);
             let io = timeout::maybe_timeout_future(
                 connect,
                 timeout.as_ref().map(|timeout| timeout.duration),
                 timeout.as_ref().map(|timeout| &timeout.sleep),
                 TimeoutKind::Connect,
-+
+            )
             .await?;
             Ok(Box::new(io) as BoxConn)
         })
-+
+    }
-+
+}
-+
 /// Erases and caches configured TLS connector services.
 ///
 /// Interface placement is immutable for a partition. The first request for
 /// each `(interface, ALPN offer)` constructs its connector while holding the
 /// cache lock; later requests clone that retained connector. Provider
 /// Interface placement is immutable for a partition. Client validation
 /// constructs both ALPN variants for the selected partition while holding the
 /// cache lock; later requests clone the retained connector. Provider
 /// configuration and certificate loading therefore occur at most once for
 /// each placement and offer rather than once per connection.
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 pub(in crate::client::pool) fn from_cached_interface_connector<F, C, IO>(
     connector_for_interface: F,
     can_guarantee_http1: bool,
 ) -> StdArc<dyn TransportFactory>
 where
     F: Fn(Option<&str>, AlpnProtocols) -> C + Send + Sync + 'static,
     C: Service<Uri, Response = IO> + Clone + Send + Sync + 'static,
     C::Error: Into<BoxError>,
     C::Future: Send + 'static,
     IO: AsyncConn,
-347
+{
     struct CachedTransportFactory<F, C> {
         factory: F,
         can_guarantee_http1: bool,
         connectors:
             crate::sync::Mutex<std::collections::HashMap<(Option<String>, AlpnProtocols), C>>,
--
+    }
--
     impl<F, C, IO> TransportFactory for CachedTransportFactory<F, C>
     where
         F: Fn(Option<&str>, AlpnProtocols) -> C + Send + Sync + 'static,
         C: Service<Uri, Response = IO> + Clone + Send + Sync + 'static,
         C::Error: Into<BoxError>,
         C::Future: Send + 'static,
         IO: AsyncConn,
--
+    {
         fn can_guarantee_http1(&self) -> bool {
             self.can_guarantee_http1
--
+        }
--
         fn connect(&self, context: TransportConnectContext<'_>) -> TransportFuture {
             let TransportConnectContext {
                 partition,
                 uri,
                 timeout,
                 alpn_protocols,
             } = context;
             let interface = partition.interface().map(|value| value.to_string());
             let mut connector = self
                 .connectors
                 .lock()
                 .entry((interface.clone(), alpn_protocols))
                 .or_insert_with(|| (self.factory)(interface.as_deref(), alpn_protocols))
                 .clone();
             Box::pin(async move {
                 poll_fn(|cx| connector.poll_ready(cx))
                     .await
                     .map_err(Into::into)?;
                 let connect = connector.call(uri);
                 let io = timeout::maybe_timeout_future(
                     connect,
                     timeout.as_ref().map(|timeout| timeout.duration),
                     timeout.as_ref().map(|timeout| &timeout.sleep),
                     TimeoutKind::Connect,
--
+                )
                 .await?;
                 Ok(Box::new(io) as BoxConn)
             })
--
+        }
--
+    }
--
     StdArc::new(CachedTransportFactory {
         factory: connector_for_interface,
         can_guarantee_http1,
         connectors: crate::sync::Mutex::new(std::collections::HashMap::new()),
     })
-353
+}
-354
 /// Selects the ALPN offer that preserves the request's wire semantics.
 fn alpn_protocols(requirement: ProtocolRequirement) -> AlpnProtocols {
     match requirement {
         ProtocolRequirement::H1Required => HTTP1_ALPN_PROTOCOLS,
         ProtocolRequirement::H1Compatible | ProtocolRequirement::H2Required => HTTP_ALPN_PROTOCOLS,
-360
+    }
-361
+}
-+
 #[cfg(all(
     test,
     any(feature = "__rustls", feature = "s2n-tls"),
     any(
         target_os = "android",
         target_os = "fuchsia",
         target_os = "illumos",
         target_os = "ios",
         target_os = "linux",
         target_os = "macos",
         target_os = "solaris",
         target_os = "tvos",
         target_os = "visionos",
         target_os = "watchos",
-+
+    )
 ))]
 mod tests {
     use super::*;
     use crate::client::pool::maintenance::MaintenanceConfig;
     use crate::client::pool::partition::{
         ConnectionReuseScope, DriverSpawner, Partition, PartitionId,
     };
     use crate::client::pool::registry::PartitionRegistry;
     use aws_smithy_runtime_api::client::http::HttpClient;
     use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
     use aws_smithy_types::config_bag::ConfigBag;
-+
     use std::sync::{Arc, Mutex};
-+
     #[derive(Debug)]
     struct TestSpawner;
-+
     impl DriverSpawner for TestSpawner {
         fn spawn(&self, _: Pin<Box<dyn Future<Output = ()> + Send + 'static>>) {}
-+
+    }
-+
     struct InitializationRecorder {
         partitions: Arc<Mutex<Vec<PartitionId>>>,
-+
+    }
-+
     impl TransportFactory for InitializationRecorder {
         fn initialize_for_partition(&self, partition: &PartitionState) -> Result<(), BoxError> {
             self.partitions
                 .lock()
                 .expect("initialization log is not poisoned")
                 .push(partition.id());
             Ok(())
-+
+        }
-+
         fn can_guarantee_http1(&self) -> bool {
             true
-+
+        }
-+
         fn connect(&self, _: TransportConnectContext<'_>) -> TransportFuture {
             Box::pin(async { panic!("client validation must not start a connection") })
-+
+        }
-+
+    }
-+
     type Construction = (Option<String>, AlpnProtocols);
-+
     struct CachedFactoryFixture<F> {
         factory: CachedTransportFactory<F, usize>,
         constructions: Arc<Mutex<Vec<Construction>>>,
-+
+    }
-+
     fn recording_factory() -> CachedFactoryFixture<impl Fn(Option<&str>, AlpnProtocols) -> usize> {
         let constructions = Arc::new(Mutex::new(Vec::new()));
         let observed = constructions.clone();
         let factory = move |interface: Option<&str>, alpn_protocols: AlpnProtocols| {
             let mut constructions = observed.lock().expect("construction log is not poisoned");
             constructions.push((interface.map(str::to_owned), alpn_protocols));
             constructions.len()
         };
         CachedFactoryFixture {
             factory: CachedTransportFactory {
                 factory,
                 can_guarantee_http1: true,
                 connectors: crate::sync::Mutex::new(std::collections::HashMap::new()),
             },
             constructions,
-+
+        }
-+
+    }
-+
     fn registry(partitions: Option<Vec<Partition>>) -> PartitionRegistry {
         PartitionRegistry::new(
             partitions,
             ConnectionReuseScope::Partition,
             None,
             MaintenanceConfig::default(),
-+
+        )
         .expect("valid partition registry")
-+
+    }
-+
     #[test]
     fn client_validation_initializes_its_selected_partition() {
         let selected = PartitionId::from_index(7);
         let initialized = Arc::new(Mutex::new(Vec::new()));
         let pool = crate::client::pool::builder::Builder::default()
             .partitions([Partition::new(selected, TestSpawner)])
             .build_with_transport_for_test(Arc::new(InitializationRecorder {
                 partitions: initialized.clone(),
             }))
             .expect("valid test pool");
         let client = crate::client::pool::Client::from_partition(&pool, selected)
             .expect("selected partition exists");
-+
         client
             .validate_base_client_config(&RuntimeComponentsBuilder::for_tests(), &ConfigBag::base())
             .expect("transport initialization succeeds");
-+
         assert_eq!(
             vec![selected],
             *initialized
                 .lock()
                 .expect("initialization log is not poisoned")
         );
-+
+    }
-+
     #[test]
     fn initialization_constructs_each_alpn_variant_once() {
         let partition = registry(None)
             .partition(PartitionId::ANONYMOUS)
             .expect("anonymous partition exists");
         let fixture = recording_factory();
-+
         fixture
             .factory
             .initialize_connectors_for_partition(&partition);
         fixture
             .factory
             .initialize_connectors_for_partition(&partition);
-+
         let constructions = fixture
             .constructions
             .lock()
             .expect("construction log is not poisoned");
         assert_eq!(2, constructions.len());
         assert_eq!(None, constructions[0].0);
         assert_eq!(HTTP_ALPN_PROTOCOLS, constructions[0].1);
         assert_eq!(HTTP1_ALPN_PROTOCOLS, constructions[1].1);
         assert_eq!(2, fixture.factory.connectors.lock().len());
-+
+    }
-+
     #[test]
     fn equal_interface_bindings_share_connector_entries() {
         let first = PartitionId::from_index(1);
         let second = PartitionId::from_index(2);
         let registry = registry(Some(vec![
             Partition::new(first, TestSpawner).interface("interface-a"),
             Partition::new(second, TestSpawner).interface("interface-a"),
         ]));
         let fixture = recording_factory();
-+
         fixture.factory.initialize_connectors_for_partition(
             &registry.partition(first).expect("first partition exists"),
         );
         fixture.factory.initialize_connectors_for_partition(
             &registry.partition(second).expect("second partition exists"),
         );
-+
         let constructions = fixture
             .constructions
             .lock()
             .expect("construction log is not poisoned");
         assert_eq!(
-+
+            [
                 (Some("interface-a".to_string()), HTTP_ALPN_PROTOCOLS),
                 (Some("interface-a".to_string()), HTTP1_ALPN_PROTOCOLS),
             ],
             constructions.as_slice()
         );
         assert_eq!(2, fixture.factory.connectors.lock().len());
-+
+    }
-+
     #[test]
     fn distinct_interface_bindings_use_distinct_connector_entries() {
         let first = PartitionId::from_index(1);
         let second = PartitionId::from_index(2);
         let registry = registry(Some(vec![
             Partition::new(first, TestSpawner).interface("interface-a"),
             Partition::new(second, TestSpawner).interface("interface-b"),
         ]));
         let fixture = recording_factory();
-+
         fixture.factory.initialize_connectors_for_partition(
             &registry.partition(first).expect("first partition exists"),
         );
         fixture.factory.initialize_connectors_for_partition(
             &registry.partition(second).expect("second partition exists"),
         );
-+
         let constructions = fixture
             .constructions
             .lock()
             .expect("construction log is not poisoned");
         assert_eq!(
-+
+            [
                 (Some("interface-a".to_string()), HTTP_ALPN_PROTOCOLS),
                 (Some("interface-a".to_string()), HTTP1_ALPN_PROTOCOLS),
                 (Some("interface-b".to_string()), HTTP_ALPN_PROTOCOLS),
                 (Some("interface-b".to_string()), HTTP1_ALPN_PROTOCOLS),
             ],
             constructions.as_slice()
         );
         assert_eq!(4, fixture.factory.connectors.lock().len());
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/tls/rustls_provider.rs

@@ -318,318 +378,378 @@

↥ Expand context

             conn,
             crypto_mode,
             tls_context,
             proxy_config,
             &[b"h2", b"http/1.1"],
-323
+        )
-324
+    }
-325
     /// Wraps an HTTP connector with the ALPN offer selected for one pool attempt.
     pub(crate) fn wrap_connector_with_alpn<R>(
         mut conn: HttpConnector<R>,
         crypto_mode: CryptoMode,
         tls_context: &TlsContext,
         proxy_config: crate::client::proxy::ProxyConfig,
         alpn_protocols: &[&[u8]],
     ) -> super::connect::RustTlsConnector<R> {
         let mut client_config = create_rustls_client_config(crypto_mode, tls_context);
         client_config.alpn_protocols = alpn_protocols
             .iter()
             .map(|protocol| protocol.to_vec())

             .collect();
         conn.enforce_http(false);
         let https_connector =
             hyper_rustls::HttpsConnector::from((conn, client_config.clone()));
-342
         super::connect::RustTlsConnector::new(https_connector, client_config, proxy_config)
-344
+    }
-345
+}
-346
 pub(crate) mod connect {
     use crate::client::connect::{Conn, Connecting};
     use crate::client::connect::{Conn, ConnectPath, Connecting};
     use crate::client::proxy::ProxyConfig;
     use aws_smithy_runtime_api::box_error::BoxError;
     use http_1x::uri::Scheme;
     use http_1x::Uri;
     use hyper::rt::{Read, ReadBufCursor, Write};
     use hyper_rustls::MaybeHttpsStream;
     use hyper_util::client::legacy::connect::{Connected, Connection, HttpConnector};
     use hyper_util::client::proxy::matcher::Matcher;
     use hyper_util::rt::TokioIo;
     use pin_project_lite::pin_project;

↧ Expand context

     use std::error::Error;
     use std::sync::Arc;
     use std::{
         io::{self, IoSlice},
         pin::Pin,
         task::{Context, Poll},
     };
     use tokio::io::{AsyncRead, AsyncWrite};
     use tokio::net::TcpStream;
     use tokio_rustls::client::TlsStream;
     use tower::Service;
-370
     #[derive(Debug, Clone)]
     pub(crate) struct RustTlsConnector<R> {
         https: hyper_rustls::HttpsConnector<HttpConnector<R>>,
         tls_config: Arc<rustls::ClientConfig>,
         proxy_matcher: Option<Arc<Matcher>>, // Pre-computed for performance
-376
+    }
-377
     impl<R> RustTlsConnector<R> {

@@ -422,422 +554,555 @@

↥ Expand context

-422
             if let Some(intercept) = proxy_intercept {
                 if dst.scheme() == Some(&Scheme::HTTPS) {
                     // HTTPS through HTTP proxy: Use CONNECT tunneling + manual TLS
                     self.handle_https_through_proxy(dst, intercept)
                 } else {
                     // HTTP through proxy: Direct connection to proxy
                     self.handle_http_through_proxy(dst, intercept)
-430
+                }
             } else {
                 // Direct connection: Use the existing HTTPS connector
                 self.handle_direct_connection(dst)
-434
+            }
-435
+        }
-436
+    }
-437
     impl<R> RustTlsConnector<R>
     where
         R: Clone + Send + Sync + 'static,
         R: Service<hyper_util::client::legacy::connect::dns::Name>,

         R::Response: Iterator<Item = std::net::SocketAddr>,
         R::Future: Send,
         R::Error: Into<Box<dyn Error + Send + Sync>>,
-445
+    {
         fn handle_direct_connection(&mut self, dst: Uri) -> Connecting {
             let fut = self.https.call(dst);
             Box::pin(async move {
                 let conn = fut.await?;
                 Ok(Conn {
                     inner: Box::new(conn),
                     is_proxy: false,
                     connect_path: ConnectPath::Direct,
                 })
             })
-455
+        }
-456
         fn handle_http_through_proxy(
             &mut self,
             _dst: Uri,
             intercept: hyper_util::client::proxy::matcher::Intercept,
         ) -> Connecting {
             // For HTTP through proxy, connect to the proxy and let it handle the request
             let proxy_uri = intercept.uri().clone();
             let connect_path = ConnectPath::forward_proxy(intercept.basic_auth().cloned());
             let fut = self.https.call(proxy_uri);
             Box::pin(async move {
                 let conn = fut.await?;
                 Ok(Conn {
                     inner: Box::new(conn),
                     is_proxy: true,
                     connect_path,
                 })
             })
-473
+        }
-474
         fn handle_https_through_proxy(
             &mut self,
             dst: Uri,
             intercept: hyper_util::client::proxy::matcher::Intercept,
         ) -> Connecting {
             use rustls_pki_types::ServerName as RustlsServerName;
             // For HTTPS through HTTP proxy, we need to:
             // 1. Establish CONNECT tunnel using the HTTPS connector
             // 2. Perform manual TLS handshake over the tunneled stream
-484
             let tunnel = hyper_util::client::legacy::connect::proxy::Tunnel::new(
                 intercept.uri().clone(),
                 self.https.clone(),
             );
-489
             // Configure tunnel with authentication if present
             let mut tunnel = if let Some(auth) = intercept.basic_auth() {
                 tunnel.with_auth(auth.clone())
             } else {
                 tunnel
             };
-496
             let tls_config = self.tls_config.clone();
             let dst_clone = dst.clone();
-499
             Box::pin(async move {
                 // Establish CONNECT tunnel
                 tracing::trace!("tunneling HTTPS over proxy");
                 let tunneled = tunnel
                     .call(dst_clone.clone())
                     .await
                     .map_err(|e| BoxError::from(format!("CONNECT tunnel failed: {e}")))?;
-507
                 // Stage 2: Manual TLS handshake over tunneled stream
                 let host = dst_clone
                     .host()
                     .ok_or("missing host in URI for TLS handshake")?;
-512
                 let server_name = RustlsServerName::try_from(host.to_owned()).map_err(|e| {
                     BoxError::from(format!("invalid server name for TLS handshake: {e}"))
                 })?;
-516
                 let tls_connector = tokio_rustls::TlsConnector::from(tls_config)
                     .connect(server_name, TokioIo::new(tunneled))
                     .await?;
-520
                 Ok(Conn {
                     inner: Box::new(RustTlsConn {
                         inner: TokioIo::new(tls_connector),
                     }),
                     is_proxy: true,
                     connect_path: ConnectPath::ProxyTunnel,
                 })
             })
-528
+        }
-529
+    }
-530
     pin_project! {
         pub(crate) struct RustTlsConn<T> {
             #[pin] pub(super) inner: TokioIo<TlsStream<T>>
-534
+        }
-535
+    }

↧ Expand context

-536
     impl Connection for RustTlsConn<TokioIo<TokioIo<TcpStream>>> {
         fn connected(&self) -> Connected {
             if self.inner.inner().get_ref().1.alpn_protocol() == Some(b"h2") {
                 self.inner
                     .inner()
                     .get_ref()
                     .0
                     .inner()
                     .connected()
                     .negotiated_h2()
             } else {
                 self.inner.inner().get_ref().0.inner().connected()
-549
+            }
-550
+        }
-551
+    }
-552
     impl Connection for RustTlsConn<TokioIo<MaybeHttpsStream<TokioIo<TcpStream>>>> {
         fn connected(&self) -> Connected {
             if self.inner.inner().get_ref().1.alpn_protocol() == Some(b"h2") {

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/tls/s2n_tls_provider.rs

@@ -209,209 +269,269 @@

↥ Expand context

             // Must not match the domain itself
             assert!(!matches_host_name("example.com", "*.example.com"));
-211
+        }
-212
         #[test]
         fn no_match() {
             assert!(!matches_host_name("other.com", "example.com"));
             assert!(!matches_host_name("foo.other.com", "*.example.com"));
-217
+        }
-218
         #[test]
         fn ip_address_exact_match() {
             assert!(matches_host_name("127.0.0.1", "127.0.0.1"));
             assert!(matches_host_name("::1", "::1"));
-223
+        }
-224
         #[test]
         fn partial_wildcard_not_supported() {
             // RFC 6125 §6.4.3 rule 3 is a MAY — intentionally unsupported,
             // matching s2n-tls's default behavior.

             assert!(!matches_host_name("baz1.example.com", "baz*.example.com"));
             assert!(!matches_host_name(
                 "foo.bar.example.com",
                 "foo.*.example.com"
             ));
-234
+        }
-235
+    }
-236
+}
-237
 pub(crate) mod connect {
     use crate::client::connect::{Conn, Connecting};
     use crate::client::connect::{Conn, ConnectPath, Connecting};
     use crate::client::proxy::ProxyConfig;
     use aws_smithy_runtime_api::box_error::BoxError;
     use http_1x::uri::Scheme;
     use http_1x::Uri;
     use hyper_util::client::legacy::connect::{Connected, Connection, HttpConnector};
     use hyper_util::client::proxy::matcher::Matcher;
     use hyper_util::rt::TokioIo;
     use std::error::Error;
     use std::sync::Arc;
     use std::{

↧ Expand context

         io::IoSlice,
         pin::Pin,
         task::{Context, Poll},
     };
     use tower::Service;
-255
     #[derive(Clone)]
     pub(crate) struct S2nTlsConnector<R> {
         https: s2n_tls_hyper::connector::HttpsConnector<HttpConnector<R>>,
         tls_config: s2n_tls::config::Config,
         proxy_matcher: Option<Arc<Matcher>>, // Pre-computed for performance
-261
+    }
-262
     impl<R> S2nTlsConnector<R> {
         pub(super) fn new(
             https: s2n_tls_hyper::connector::HttpsConnector<HttpConnector<R>>,
             tls_config: s2n_tls::config::Config,
             proxy_config: ProxyConfig,
         ) -> Self {
             // Pre-compute the proxy matcher once during construction

@@ -307,307 +437,438 @@

↥ Expand context

-307
             if let Some(intercept) = proxy_intercept {
                 if dst.scheme() == Some(&Scheme::HTTPS) {
                     // HTTPS through HTTP proxy: Use CONNECT tunneling + manual TLS
                     self.handle_https_through_proxy(dst, intercept)
                 } else {
                     // HTTP through proxy: Direct connection to proxy
                     self.handle_http_through_proxy(dst, intercept)
-315
+                }
             } else {
                 // Direct connection: Use the existing HTTPS connector
                 self.handle_direct_connection(dst)
-319
+            }
-320
+        }
-321
+    }
-322
     impl<R> S2nTlsConnector<R>
     where
         R: Clone + Send + Sync + 'static,
         R: Service<hyper_util::client::legacy::connect::dns::Name>,

         R::Response: Iterator<Item = std::net::SocketAddr>,
         R::Future: Send,
         R::Error: Into<Box<dyn Error + Send + Sync>>,
-330
+    {
         fn handle_direct_connection(&mut self, dst: Uri) -> Connecting {
             let fut = self.https.call(dst);
             Box::pin(async move {
                 let conn = fut.await?;
                 Ok(Conn {
                     inner: Box::new(conn),
                     is_proxy: false,
                     connect_path: ConnectPath::Direct,
                 })
             })
-340
+        }
-341
         fn handle_http_through_proxy(
             &mut self,
             _dst: Uri,
             intercept: hyper_util::client::proxy::matcher::Intercept,
         ) -> Connecting {
             // For HTTP through proxy, connect to the proxy and let it handle the request
             let proxy_uri = intercept.uri().clone();
             let connect_path = ConnectPath::forward_proxy(intercept.basic_auth().cloned());
             let fut = self.https.call(proxy_uri);
             Box::pin(async move {
                 let conn = fut.await?;
                 Ok(Conn {
                     inner: Box::new(conn),
                     is_proxy: true,
                     connect_path,
                 })
             })
-358
+        }
-359
         fn handle_https_through_proxy(
             &mut self,
             dst: Uri,
             intercept: hyper_util::client::proxy::matcher::Intercept,
         ) -> Connecting {
             // For HTTPS through HTTP proxy, we need to:
             // 1. Establish CONNECT tunnel using the HTTPS connector
             // 2. Perform manual TLS handshake over the tunneled stream
-368
             let tunnel = hyper_util::client::legacy::connect::proxy::Tunnel::new(
                 intercept.uri().clone(),
                 self.https.clone(),
             );
-373
             // Configure tunnel with authentication if present
             let mut tunnel = if let Some(auth) = intercept.basic_auth() {
                 tunnel.with_auth(auth.clone())
             } else {
                 tunnel
             };
-380
             let tls_config = self.tls_config.clone();
             let dst_clone = dst.clone();
-383
             Box::pin(async move {
                 // Stage 1: Establish CONNECT tunnel
                 tracing::trace!("tunneling HTTPS over proxy using s2n-tls");
                 let tunneled = tunnel
                     .call(dst_clone.clone())
                     .await
                     .map_err(|e| BoxError::from(format!("CONNECT tunnel failed: {e}")))?;
-391
                 // Stage 2: Manual TLS handshake over tunneled stream
                 let host = dst_clone
                     .host()
                     .ok_or("missing host in URI for TLS handshake")?;
-396
                 // s2n-tls uses string server names (simpler than rustls ServerName)
                 let tls_connector = s2n_tls_tokio::TlsConnector::new(tls_config);
                 let tls_stream = tls_connector
                     .connect(host, TokioIo::new(tunneled))
                     .await
                     .map_err(|e| BoxError::from(format!("s2n-tls handshake failed: {e}")))?;
-403
                 Ok(Conn {
                     inner: Box::new(S2nTlsConn {
                         inner: TokioIo::new(tls_stream),
                     }),
                     is_proxy: true,
                     connect_path: ConnectPath::ProxyTunnel,
                 })
             })
-411
+        }
-412
+    }
-413
     // Simple wrapper that implements Connection for s2n-tls streams
     struct S2nTlsConn<T>
     where
         T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
-418
+    {

↧ Expand context

         inner: TokioIo<s2n_tls_tokio::TlsStream<T>>,
-420
+    }
-421
     impl<T> Connection for S2nTlsConn<T>
     where
         T: Connection + tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
-425
+    {
         fn connected(&self) -> Connected {
             // For tunneled connections, we can't easily access the underlying connection info
             // from s2n-tls, so we'll return a basic Connected instance
             Connected::new()
-430
+        }
-431
+    }
-432
     impl<T> hyper::rt::Read for S2nTlsConn<T>
     where
         T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
-436
+    {
         fn poll_read(
             self: Pin<&mut Self>,

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/tests/common/client.rs

@@ -1,1 +64,259 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Client configuration and request helpers shared by connection behavior tests.
-7
 use aws_smithy_async::rt::sleep::{SharedAsyncSleep, TokioSleep};
 use aws_smithy_async::time::SystemTimeSource;
 use aws_smithy_http_client::pool::{Client as PoolClient, ConnectionPool};
 use aws_smithy_http_client::proxy::ProxyConfig;
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 use aws_smithy_http_client::tls;
 use aws_smithy_http_client::{Builder, Connector};
 use aws_smithy_runtime_api::client::dns::SharedDnsResolver;
 use aws_smithy_runtime_api::client::http::{
     HttpClient, HttpConnector, HttpConnectorSettings, SharedHttpClient, SharedHttpConnector,
     http_client_fn, HttpClient, HttpConnector, HttpConnectorSettings, SharedHttpClient,
     SharedHttpConnector,
 };
 use aws_smithy_runtime_api::client::orchestrator::{HttpRequest, HttpResponse};
 use aws_smithy_runtime_api::client::result::ConnectorError;
 use aws_smithy_runtime_api::client::runtime_components::{
     RuntimeComponents, RuntimeComponentsBuilder,
 };
 use http_body_util::BodyExt;
 use std::time::Duration;
-27
 /// Default timeout for test waits and deadline assertions.
 pub(crate) const WAIT: Duration = Duration::from_secs(5);
-30
 #[derive(Clone, Copy, Debug, Default)]
 /// Settings applied uniformly by backend-neutral connection contracts.
 #[derive(Clone, Debug, Default)]
 pub(crate) struct BackendConfig {
     pub(crate) pool_idle_timeout: Option<Duration>,
     pub(crate) proxy_config: Option<ProxyConfig>,
     pub(crate) dns_resolver: Option<SharedDnsResolver>,
-37
+}
-38
 /// Hyper 1.x through `hyper_util::client::legacy::Client`.
 ///
 /// "Legacy" is Hyper Util's module name and does not refer to smithy-rs's `hyper-014` feature.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct HyperUtilLegacyPool;
-44
 /// The partition-aware Smithy connection pool.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct PartitionedConnectionPool;
-+
 /// Builds a cleartext client for one connection-pool implementation.
 #[allow(dead_code)]
 pub(crate) trait HttpClientBackend {
     fn build(&self, config: BackendConfig) -> SharedHttpClient;
-+
+}
-+
 impl HttpClientBackend for HyperUtilLegacyPool {
     fn build(&self, config: BackendConfig) -> SharedHttpClient {
         let BackendConfig {
             pool_idle_timeout,
             proxy_config,
             dns_resolver,
         } = config;
         if proxy_config.is_none() && dns_resolver.is_none() {
             let mut builder = Builder::new();
             if let Some(pool_idle_timeout) = pool_idle_timeout {
                 builder = builder.pool_idle_timeout(pool_idle_timeout);
-+
+            }
             return builder.build_http();
-+
+        }
-+
         http_client_fn(move |settings, _| {
             let mut builder = Connector::builder().connector_settings(settings.clone());
             if let Some(pool_idle_timeout) = pool_idle_timeout {
                 builder = builder.pool_idle_timeout(Some(pool_idle_timeout));
-+
+            }
             if let Some(proxy_config) = &proxy_config {
                 builder = builder.proxy_config(proxy_config.clone());
-+
+            }
             if let Some(resolver) = &dns_resolver {
                 #[cfg(any(
                     feature = "rustls-aws-lc",
                     feature = "rustls-aws-lc-fips",
                     feature = "rustls-ring",
                     feature = "s2n-tls"
                 ))]
                 return SharedHttpConnector::new(
                     builder
                         .tls_provider(custom_dns_test_provider())
                         .build_with_resolver(resolver.clone()),
                 );
                 #[cfg(not(any(
                     feature = "rustls-aws-lc",
                     feature = "rustls-aws-lc-fips",
                     feature = "rustls-ring",
                     feature = "s2n-tls"
                 )))]
-+
+                {
                     let _ = resolver;
                     panic!("the legacy custom-DNS test backend requires an enabled TLS provider");
-+
+                }
-+
+            }
             SharedHttpConnector::new(builder.build_http())
         })
-+
+    }
-+
+}
-+
 impl HttpClientBackend for PartitionedConnectionPool {
     fn build(&self, config: BackendConfig) -> SharedHttpClient {
         let mut builder = ConnectionPool::builder();
         if let Some(dns_resolver) = config.dns_resolver {
             builder = builder.dns_resolver(dns_resolver);
-+
+        }
         if let Some(pool_idle_timeout) = config.pool_idle_timeout {
             builder = builder.idle_timeout(pool_idle_timeout);
-+
+        }
         if let Some(proxy_config) = config.proxy_config {
             builder = builder.proxy_config(proxy_config);
-+
+        }
         let pool = builder.build_http().expect("valid connection-pool config");
         SharedHttpClient::new(PoolClient::new(&pool).expect("anonymous partition exists"))
-+
+    }
-+
+}
-+
 #[cfg(any(
     feature = "rustls-aws-lc",
     feature = "rustls-aws-lc-fips",
     feature = "rustls-ring",
     feature = "s2n-tls"
 ))]
 fn custom_dns_test_provider() -> tls::Provider {
     #[cfg(feature = "rustls-aws-lc")]
-+
+    {
         tls::Provider::Rustls(tls::rustls_provider::CryptoMode::AwsLc)
-+
+    }
     #[cfg(all(not(feature = "rustls-aws-lc"), feature = "rustls-aws-lc-fips"))]
-+
+    {
         tls::Provider::Rustls(tls::rustls_provider::CryptoMode::AwsLcFips)
-+
+    }
     #[cfg(all(
         not(feature = "rustls-aws-lc"),
         not(feature = "rustls-aws-lc-fips"),
         feature = "rustls-ring"
     ))]
-+
+    {
         tls::Provider::Rustls(tls::rustls_provider::CryptoMode::Ring)
-+
+    }
     #[cfg(all(
         not(feature = "rustls-aws-lc"),
         not(feature = "rustls-aws-lc-fips"),
         not(feature = "rustls-ring"),
         feature = "s2n-tls"
     ))]
-+
+    {
         tls::Provider::S2nTls
-+
+    }
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 /// Builds a TLS client for one connection-pool implementation.
 #[allow(dead_code)]
 pub(crate) trait HttpsClientBackend {
     fn build_https(
         &self,
         config: BackendConfig,
         provider: tls::Provider,
         tls_context: tls::TlsContext,
     ) -> SharedHttpClient;
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 impl HttpsClientBackend for HyperUtilLegacyPool {
     fn build_https(
         &self,
         config: BackendConfig,
         provider: tls::Provider,
         tls_context: tls::TlsContext,
     ) -> SharedHttpClient {
         let Some(proxy_config) = config.proxy_config else {
             let mut builder = Builder::new();
             if let Some(pool_idle_timeout) = config.pool_idle_timeout {
                 builder = builder.pool_idle_timeout(pool_idle_timeout);
-+
+            }
             return builder
                 .tls_provider(provider)
                 .tls_context(tls_context)
                 .build_https();
         };
-+
         let pool_idle_timeout = config.pool_idle_timeout;
         http_client_fn(move |settings, _| {
             let mut builder = Connector::builder()
                 .connector_settings(settings.clone())
                 .proxy_config(proxy_config.clone());
             if let Some(pool_idle_timeout) = pool_idle_timeout {
                 builder = builder.pool_idle_timeout(Some(pool_idle_timeout));
-+
+            }
             SharedHttpConnector::new(
                 builder
                     .tls_provider(provider.clone())
                     .tls_context(tls_context.clone())
                     .build(),
-+
+            )
         })
-+
+    }
-+
+}
-+
 #[cfg(any(feature = "__rustls", feature = "s2n-tls"))]
 impl HttpsClientBackend for PartitionedConnectionPool {
     fn build_https(
         &self,
         config: BackendConfig,
         provider: tls::Provider,
         tls_context: tls::TlsContext,
     ) -> SharedHttpClient {
         let mut builder = ConnectionPool::builder();
         if let Some(pool_idle_timeout) = config.pool_idle_timeout {
             builder = builder.idle_timeout(pool_idle_timeout);
-+
+        }
         if let Some(proxy_config) = config.proxy_config {
             builder = builder.proxy_config(proxy_config);
-+
+        }
         let pool = builder
             .tls_provider(provider)
             .tls_context(tls_context)
             .build_https()
             .expect("valid connection-pool config");
         SharedHttpClient::new(PoolClient::new(&pool).expect("anonymous partition exists"))
-+
+    }
-+
+}
-+
 pub(crate) fn runtime_components() -> RuntimeComponents {
     RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .with_sleep_impl(Some(SharedAsyncSleep::new(TokioSleep::new())))
         .build()
         .expect("valid runtime components")
-236
+}
-237
 pub(crate) fn connector_with_settings(
     client: &SharedHttpClient,

↧ Expand context

     settings: HttpConnectorSettings,
 ) -> SharedHttpConnector {
     client.http_connector(&settings, &runtime_components())
-243
+}
-244
 pub(crate) fn connector(client: &SharedHttpClient) -> SharedHttpConnector {
     connector_with_settings(client, HttpConnectorSettings::builder().build())
-247
+}
-248
 pub(crate) async fn send_request(
     connector: &SharedHttpConnector,
     request: HttpRequest,
 ) -> Result<HttpResponse, ConnectorError> {
     tokio::time::timeout(WAIT, connector.call(request))
         .await
         .expect("request should finish within the outer deadline")
-256
+}
-257
 pub(crate) async fn send_and_collect(
     connector: &SharedHttpConnector,

Pages: 1 2 3