Port middleware connectors to the orchestrator

CHANGELOG.next.toml

@@ -102,3 +102,27 @@ message = "Required members with @contextParam are now treated as client-side re
 references = ["smithy-rs#2964"]
 meta = { "breaking" = false, "tada" = false, "bug" = false, target = "client" }
 author = "rcoh"
+
+[[smithy-rs]]
+message = "`aws_smithy_client::hyper_ext::Adapter` was moved/renamed to `aws_smithy_runtime::client::connectors::hyper_connector::HyperConnector`."
+references = ["smithy-rs#2970"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
+author = "jdisanti"
+
+[[smithy-rs]]
+message = "Test connectors moved into `aws_smithy_runtime::client::connectors::test_util` behind the `test-util` feature."
+references = ["smithy-rs#2970"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
+author = "jdisanti"
+
+[[smithy-rs]]
+message = "DVR's RecordingConnection and ReplayingConnection were renamed to RecordingConnector and ReplayingConnector respectively."
+references = ["smithy-rs#2970"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
+author = "jdisanti"
+
+[[smithy-rs]]
+message = "TestConnection was renamed to EventConnector."
+references = ["smithy-rs#2970"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
+author = "jdisanti"

rust-runtime/aws-smithy-client/src/erase.rs

@@ -169,10 +169,8 @@ impl DynConnector {
     pub fn call_lite(
         &mut self,
         req: http::Request<SdkBody>,
-    ) -> BoxFuture<http::Response<SdkBody>, Box<dyn std::error::Error + Send + Sync + 'static>>
-    {
-        let future = Service::call(self, req);
-        Box::pin(async move { future.await.map_err(|err| Box::new(err) as _) })
+    ) -> BoxFuture<http::Response<SdkBody>, ConnectorError> {
+        Service::call(self, req)
     }
 }
 

rust-runtime/aws-smithy-runtime-api/src/client/connectors.rs

@@ -3,10 +3,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use crate::client::orchestrator::{BoxFuture, HttpRequest, HttpResponse};
+use crate::client::orchestrator::{HttpRequest, HttpResponse};
+use aws_smithy_async::future::now_or_later::NowOrLater;
+use aws_smithy_http::result::ConnectorError;
 use std::fmt;
+use std::future::Future as StdFuture;
+use std::pin::Pin;
 use std::sync::Arc;
 
+/// Boxed future used by [`HttpConnectorFuture`].
+pub type BoxFuture = Pin<Box<dyn StdFuture<Output = Result<HttpResponse, ConnectorError>> + Send>>;
+/// Future for [`HttpConnector::call`].
+pub type HttpConnectorFuture = NowOrLater<Result<HttpResponse, ConnectorError>, BoxFuture>;
+
 /// Trait with a `call` function that asynchronously converts a request into a response.
 ///
 /// Ordinarily, a connector would use an underlying HTTP library such as [hyper](https://crates.io/crates/hyper),
@@ -16,7 +25,7 @@ use std::sync::Arc;
 /// for testing.
 pub trait HttpConnector: Send + Sync + fmt::Debug {
     /// Asynchronously converts a request into a response.
-    fn call(&self, request: HttpRequest) -> BoxFuture<HttpResponse>;
+    fn call(&self, request: HttpRequest) -> HttpConnectorFuture;
 }
 
 /// A shared [`HttpConnector`] implementation.
@@ -31,7 +40,7 @@ impl SharedHttpConnector {
 }
 
 impl HttpConnector for SharedHttpConnector {
-    fn call(&self, request: HttpRequest) -> BoxFuture<HttpResponse> {
+    fn call(&self, request: HttpRequest) -> HttpConnectorFuture {
         (*self.0).call(request)
     }
 }

rust-runtime/aws-smithy-runtime-api/src/client/runtime_components.rs

@@ -511,11 +511,11 @@ impl RuntimeComponentsBuilder {
     #[cfg(feature = "test-util")]
     pub fn for_tests() -> Self {
         use crate::client::auth::AuthSchemeOptionResolver;
-        use crate::client::connectors::HttpConnector;
+        use crate::client::connectors::{HttpConnector, HttpConnectorFuture};
         use crate::client::endpoint::{EndpointResolver, EndpointResolverParams};
         use crate::client::identity::Identity;
         use crate::client::identity::IdentityResolver;
-        use crate::client::orchestrator::Future;
+        use crate::client::orchestrator::{Future, HttpRequest};
         use crate::client::retries::RetryStrategy;
         use aws_smithy_async::rt::sleep::AsyncSleep;
         use aws_smithy_async::time::TimeSource;
@@ -537,11 +537,7 @@ impl RuntimeComponentsBuilder {
         #[derive(Debug)]
         struct FakeConnector;
         impl HttpConnector for FakeConnector {
-            fn call(
-                &self,
-                _: crate::client::orchestrator::HttpRequest,
-            ) -> crate::client::orchestrator::BoxFuture<crate::client::orchestrator::HttpResponse>
-            {
+            fn call(&self, _: HttpRequest) -> HttpConnectorFuture {
                 unreachable!("fake connector must be overridden for this test")
             }
         }

rust-runtime/aws-smithy-runtime-api/src/client/runtime_plugin.rs

@@ -258,8 +258,8 @@ impl RuntimePlugins {
 #[cfg(test)]
 mod tests {
     use super::{RuntimePlugin, RuntimePlugins};
-    use crate::client::connectors::{HttpConnector, SharedHttpConnector};
-    use crate::client::orchestrator::{BoxFuture, HttpRequest, HttpResponse};
+    use crate::client::connectors::{HttpConnector, HttpConnectorFuture, SharedHttpConnector};
+    use crate::client::orchestrator::HttpRequest;
     use crate::client::runtime_components::RuntimeComponentsBuilder;
     use crate::client::runtime_plugin::Order;
     use aws_smithy_http::body::SdkBody;
@@ -342,29 +342,29 @@ mod tests {
         #[derive(Debug)]
         struct CN1;
         impl HttpConnector for CN1 {
-            fn call(&self, _: HttpRequest) -> BoxFuture<HttpResponse> {
-                Box::pin(async {
+            fn call(&self, _: HttpRequest) -> HttpConnectorFuture {
+                HttpConnectorFuture::new(Box::pin(async {
                     Ok(http::Response::builder()
                         .status(200)
                         .header("rp1", "1")
                         .body(SdkBody::empty())
                         .unwrap())
-                })
+                }))
             }
         }
 
         // CN2, the outer connector, calls the inner connector and adds the `rp2` header to the response
         #[derive(Debug)]
         struct CN2(SharedHttpConnector);
         impl HttpConnector for CN2 {
-            fn call(&self, request: HttpRequest) -> BoxFuture<HttpResponse> {
+            fn call(&self, request: HttpRequest) -> HttpConnectorFuture {
                 let inner = self.0.clone();
-                Box::pin(async move {
+                HttpConnectorFuture::new(Box::pin(async move {
                     let mut resp = inner.call(request).await.unwrap();
                     resp.headers_mut()
                         .append("rp2", HeaderValue::from_static("1"));
                     Ok(resp)
-                })
+                }))
             }
         }
 

rust-runtime/aws-smithy-runtime/Cargo.toml

@@ -12,7 +12,9 @@ repository = "https://github.com/awslabs/smithy-rs"
 [features]
 client = ["aws-smithy-runtime-api/client"]
 http-auth = ["aws-smithy-runtime-api/http-auth"]
-test-util = ["aws-smithy-runtime-api/test-util", "dep:aws-smithy-protocol-test", "dep:tracing-subscriber"]
+test-util = ["aws-smithy-runtime-api/test-util", "dep:aws-smithy-protocol-test", "dep:tracing-subscriber", "dep:serde", "dep:serde_json"]
+connector-hyper = ["dep:hyper", "hyper?/client", "hyper?/http2", "hyper?/http1", "hyper?/tcp"]
+tls-rustls = ["dep:hyper-rustls", "dep:rustls", "connector-hyper"]
 
 [dependencies]
 aws-smithy-async = { path = "../aws-smithy-async" }
@@ -25,9 +27,14 @@ bytes = "1"
 fastrand = "2.0.0"
 http = "0.2.8"
 http-body = "0.4.5"
+hyper = { version = "0.14.26", default-features = false, optional = true }
+hyper-rustls = { version = "0.24", features = ["rustls-native-certs", "http2"], optional = true }
 once_cell = "1.18.0"
 pin-project-lite = "0.2.7"
 pin-utils = "0.1.0"
+rustls = { version = "0.21.1", optional = true }
+serde = { version = "1", features = ["derive"], optional = true }
+serde_json = { version = "1", optional = true }
 tokio = { version = "1.25", features = [] }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.16", optional = true, features = ["fmt", "json"] }
@@ -37,6 +44,7 @@ approx = "0.5.1"
 aws-smithy-async = { path = "../aws-smithy-async", features = ["rt-tokio", "test-util"] }
 aws-smithy-runtime-api = { path = "../aws-smithy-runtime-api", features = ["test-util"] }
 aws-smithy-types = { path = "../aws-smithy-types", features = ["test-util"] }
+hyper-tls = { version = "0.5.0" }
 tokio = { version = "1.25", features = ["macros", "rt", "test-util"] }
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
 tracing-test = "0.2.1"

rust-runtime/aws-smithy-runtime/src/client/connectors.rs

@@ -9,14 +9,18 @@ pub mod connection_poisoning;
 #[cfg(feature = "test-util")]
 pub mod test_util;
 
+/// Default HTTP and TLS connectors that use hyper and rustls.
+#[cfg(feature = "connector-hyper")]
+pub mod hyper_connector;
+
 // TODO(enableNewSmithyRuntimeCleanup): Delete this module
 /// Unstable API for interfacing the old middleware connectors with the newer orchestrator connectors.
 ///
 /// Important: This module and its contents will be removed in the next release.
 pub mod adapter {
     use aws_smithy_client::erase::DynConnector;
-    use aws_smithy_runtime_api::client::connectors::HttpConnector;
-    use aws_smithy_runtime_api::client::orchestrator::{BoxFuture, HttpRequest, HttpResponse};
+    use aws_smithy_runtime_api::client::connectors::{HttpConnector, HttpConnectorFuture};
+    use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
     use std::sync::{Arc, Mutex};
 
     /// Adapts a [`DynConnector`] to the [`HttpConnector`] trait.
@@ -40,9 +44,9 @@ pub mod adapter {
     }
 
     impl HttpConnector for DynConnectorAdapter {
-        fn call(&self, request: HttpRequest) -> BoxFuture<HttpResponse> {
+        fn call(&self, request: HttpRequest) -> HttpConnectorFuture {
             let future = self.dyn_connector.lock().unwrap().call_lite(request);
-            future
+            HttpConnectorFuture::new(future)
         }
     }
 }