Unverified Commit 4029afd4 authored by John DiSanti's avatar John DiSanti Committed by GitHub
Browse files

Eliminate SDK client generics (#1132)

parent 384c492d

CHANGELOG.next.toml

+58 −1
Original line number Diff line number Diff line
@@ -84,3 +84,60 @@ message = "MSRV increased from `1.54` to `1.56.1` per our 2-behind MSRV policy." 
references = ["smithy-rs#1130"]

meta = { "breaking" = true, "tada" = false, "bug" = false }

author = "jdisanti"



[[aws-sdk-rust]]

message = """

Fluent clients for all services no longer have generics, and now use `DynConnector` and `DynMiddleware` to allow

for connector/middleware customization. This should only break references to the client that specified generic types for it.



If you customized the AWS client's connector or middleware with something like the following:

```rust

let client = aws_sdk_s3::Client::with_config(

    aws_sdk_s3::client::Builder::new()

        .connector(my_custom_connector) // Connector customization

        .middleware(my_custom_middleware) // Middleware customization

        .default_async_sleep()

        .build(),

    config

);

```

Then you will need to wrap the custom connector or middleware in

[`DynConnector`](https://docs.rs/aws-smithy-client/0.36.0/aws_smithy_client/erase/struct.DynConnector.html)

and

[`DynMiddleware`](https://docs.rs/aws-smithy-client/0.36.0/aws_smithy_client/erase/struct.DynMiddleware.html)

respectively:

```rust

let client = aws_sdk_s3::Client::with_config(

    aws_sdk_s3::client::Builder::new()

        .connector(DynConnector::new(my_custom_connector)) // Now with `DynConnector`

        .middleware(DynMiddleware::new(my_custom_middleware)) // Now with `DynMiddleware`

        .default_async_sleep()

        .build(),

    config

);

```



If you had functions that took a generic connector, such as the following:

```rust

fn some_function<C, E>(conn: C) -> Result<()>

where

    C: aws_smithy_client::bounds::SmithyConnector<Error = E> + Send + 'static,

    E: Into<aws_smithy_http::result::ConnectorError>

{

    // ...

}

```



Then the generics and trait bounds will no longer be necessary:

```rust

fn some_function(conn: DynConnector) -> Result<()> {

    // ...

}

```



Similarly, functions that took a generic middleware can replace the generic with `DynMiddleware` and

remove their trait bounds.

"""

references = ["smithy-rs#1132"]

meta = { "breaking" = true, "tada" = false, "bug" = false }

author = "jdisanti"

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt

+51 −34
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 


package software.amazon.smithy.rustsdk



import software.amazon.smithy.codegen.core.Symbol

import software.amazon.smithy.model.shapes.ShapeId

import software.amazon.smithy.model.traits.TitleTrait

import software.amazon.smithy.rust.codegen.rustlang.Attribute
@@ -23,17 +24,18 @@ import software.amazon.smithy.rust.codegen.smithy.RuntimeConfig 
import software.amazon.smithy.rust.codegen.smithy.RuntimeType

import software.amazon.smithy.rust.codegen.smithy.RustCrate

import software.amazon.smithy.rust.codegen.smithy.customize.RustCodegenDecorator

import software.amazon.smithy.rust.codegen.smithy.generators.ClientGenerics

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientGenerator

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientSection

import software.amazon.smithy.rust.codegen.smithy.generators.LibRsCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.LibRsSection

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientGenerator

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientGenerics

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientSection

import software.amazon.smithy.rust.codegen.util.expectTrait

import software.amazon.smithy.rustsdk.AwsRuntimeType.defaultMiddleware



private class Types(runtimeConfig: RuntimeConfig) {

    private val smithyClientDep = CargoDependency.SmithyClient(runtimeConfig)

    private val smithyHttpDep = CargoDependency.SmithyHttp(runtimeConfig)



    val awsTypes = awsTypes(runtimeConfig).asType()

    val smithyClientRetry = RuntimeType("retry", smithyClientDep, "aws_smithy_client")
@@ -41,6 +43,33 @@ private class Types(runtimeConfig: RuntimeConfig) { 


    val defaultMiddleware = runtimeConfig.defaultMiddleware()

    val dynConnector = RuntimeType("DynConnector", smithyClientDep, "aws_smithy_client::erase")

    val dynMiddleware = RuntimeType("DynMiddleware", smithyClientDep, "aws_smithy_client::erase")

    val smithyConnector = RuntimeType("SmithyConnector", smithyClientDep, "aws_smithy_client::bounds")



    val connectorError = RuntimeType("ConnectorError", smithyHttpDep, "aws_smithy_http::result")

}



private class AwsClientGenerics(private val types: Types) : FluentClientGenerics {

    /** Declaration with defaults set */

    override val decl = writable { }



    /** Instantiation of the Smithy client generics */

    override val smithyInst = writable {

        rustTemplate(

            "<#{DynConnector}, #{DynMiddleware}<#{DynConnector}>>",

            "DynConnector" to types.dynConnector,

            "DynMiddleware" to types.dynMiddleware

        )

    }



    /** Instantiation */

    override val inst = ""



    /** Trait bounds */

    override val bounds = writable { }



    /** Bounds for generated `send()` functions */

    override fun sendBounds(input: Symbol, output: Symbol, error: RuntimeType): Writable = writable { }

}



class AwsFluentClientDecorator : RustCodegenDecorator {
@@ -53,12 +82,7 @@ class AwsFluentClientDecorator : RustCodegenDecorator { 
        val types = Types(codegenContext.runtimeConfig)

        FluentClientGenerator(

            codegenContext,

            generics = ClientGenerics(

                connectorDefault = types.dynConnector,

                middlewareDefault = types.defaultMiddleware,

                retryDefault = types.smithyClientRetry.member("Standard"),

                client = types.awsSmithyClient

            ),

            generics = AwsClientGenerics(types),

            customizations = listOf(

                AwsPresignedFluentBuilderMethod(codegenContext.runtimeConfig),

                AwsFluentClientDocs(codegenContext)
@@ -88,33 +112,34 @@ class AwsFluentClientDecorator : RustCodegenDecorator { 
    }

}



private class AwsFluentClientExtensions(private val types: Types) {

    val clientGenerics = ClientGenerics(

        connectorDefault = types.dynConnector,

        middlewareDefault = types.defaultMiddleware,

        retryDefault = types.smithyClientRetry.member("Standard"),

        client = types.awsSmithyClient

    )



private class AwsFluentClientExtensions(types: Types) {

    private val codegenScope = arrayOf(

        "Middleware" to types.defaultMiddleware,

        "retry" to types.smithyClientRetry,

        "DynConnector" to types.dynConnector,

        "aws_smithy_client" to types.awsSmithyClient

        "DynMiddleware" to types.dynMiddleware,

        "SmithyConnector" to types.smithyConnector,

        "ConnectorError" to types.connectorError,

        "aws_smithy_client" to types.awsSmithyClient,

        "aws_types" to types.awsTypes,

    )



    fun render(writer: RustWriter) {

        writer.rustBlockTemplate("impl<C> Client<C, #{Middleware}, #{retry}::Standard>", *codegenScope) {

        writer.rustBlockTemplate("impl Client", *codegenScope) {

            rustTemplate(

                """

                /// Creates a client with the given service config and connector override.

                pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {

                pub fn from_conf_conn<C, E>(conf: crate::Config, conn: C) -> Self

                where

                    C: #{SmithyConnector}<Error = E> + Send + 'static,

                    E: Into<#{ConnectorError}>,

                {

                    let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();

                    let timeout_config = conf.timeout_config.as_ref().cloned().unwrap_or_default();

                    let sleep_impl = conf.sleep_impl.clone();

                    let mut builder = #{aws_smithy_client}::Builder::new()

                        .connector(conn)

                        .middleware(#{Middleware}::new());

                        .connector(#{DynConnector}::new(conn))

                        .middleware(#{DynMiddleware}::new(#{Middleware}::new()));

                    builder.set_retry_config(retry_config.into());

                    builder.set_timeout_config(timeout_config);

                    if let Some(sleep_impl) = sleep_impl {
@@ -123,13 +148,7 @@ private class AwsFluentClientExtensions(private val types: Types) { 
                    let client = builder.build();

                    Self { handle: std::sync::Arc::new(Handle { client, conf }) }

                }

                """,

                *codegenScope

            )

        }

        writer.rustBlockTemplate("impl Client<#{DynConnector}, #{Middleware}, #{retry}::Standard>", *codegenScope) {

            rustTemplate(

                """



                /// Creates a new client from a shared config.

                ##[cfg(any(feature = "rustls", feature = "native-tls"))]

                pub fn new(config: &#{aws_types}::config::Config) -> Self {
@@ -143,7 +162,7 @@ private class AwsFluentClientExtensions(private val types: Types) { 
                    let timeout_config = conf.timeout_config.as_ref().cloned().unwrap_or_default();

                    let sleep_impl = conf.sleep_impl.clone();

                    let mut builder = #{aws_smithy_client}::Builder::dyn_https()

                        .middleware(#{Middleware}::new());

                        .middleware(#{DynMiddleware}::new(#{Middleware}::new()));

                    builder.set_retry_config(retry_config.into());

                    builder.set_timeout_config(timeout_config);

                    // the builder maintains a try-state. To avoid suppressing the warning when sleep is unset,
@@ -156,9 +175,7 @@ private class AwsFluentClientExtensions(private val types: Types) { 
                    Self { handle: std::sync::Arc::new(Handle { client, conf }) }

                }

                """,

                "aws_smithy_client" to types.awsSmithyClient,

                "aws_types" to types.awsTypes,

                "Middleware" to types.defaultMiddleware

                *codegenScope,

            )

        }

    }

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsPresigningDecorator.kt

+2 −2
Original line number Diff line number Diff line
@@ -32,8 +32,8 @@ import software.amazon.smithy.rust.codegen.smithy.RuntimeConfig 
import software.amazon.smithy.rust.codegen.smithy.customize.OperationCustomization

import software.amazon.smithy.rust.codegen.smithy.customize.OperationSection

import software.amazon.smithy.rust.codegen.smithy.customize.RustCodegenDecorator

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientSection

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientSection

import software.amazon.smithy.rust.codegen.smithy.generators.error.errorSymbol

import software.amazon.smithy.rust.codegen.smithy.generators.protocol.MakeOperationGenerator

import software.amazon.smithy.rust.codegen.smithy.protocols.HttpBoundProtocolBodyGenerator

codegen/src/main/kotlin/software/amazon/smithy/rust/codegen/smithy/customize/RustCodegenDecorator.kt

+1 −1
Original line number Diff line number Diff line
@@ -13,9 +13,9 @@ import software.amazon.smithy.model.shapes.ShapeId 
import software.amazon.smithy.rust.codegen.smithy.CodegenContext

import software.amazon.smithy.rust.codegen.smithy.RustCrate

import software.amazon.smithy.rust.codegen.smithy.RustSymbolProvider

import software.amazon.smithy.rust.codegen.smithy.generators.FluentClientDecorator

import software.amazon.smithy.rust.codegen.smithy.generators.LibRsCustomization

import software.amazon.smithy.rust.codegen.smithy.generators.ManifestCustomizations

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientDecorator

import software.amazon.smithy.rust.codegen.smithy.generators.config.ConfigCustomization

import software.amazon.smithy.rust.codegen.smithy.protocols.ProtocolMap

import software.amazon.smithy.rust.codegen.util.deepMergeWith

codegen/src/main/kotlin/software/amazon/smithy/rust/codegen/smithy/generators/PaginatorGenerator.kt

+13 −21
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ import software.amazon.smithy.rust.codegen.rustlang.writable 
import software.amazon.smithy.rust.codegen.smithy.CodegenContext

import software.amazon.smithy.rust.codegen.smithy.RuntimeType

import software.amazon.smithy.rust.codegen.smithy.RustSymbolProvider

import software.amazon.smithy.rust.codegen.smithy.generators.client.FluentClientGenerics

import software.amazon.smithy.rust.codegen.smithy.generators.error.errorSymbol

import software.amazon.smithy.rust.codegen.smithy.rustType

import software.amazon.smithy.rust.codegen.util.PANIC
@@ -45,13 +46,13 @@ class PaginatorGenerator private constructor( 
    private val symbolProvider: RustSymbolProvider,

    service: ServiceShape,

    operation: OperationShape,

    private val generics: ClientGenerics

    private val generics: FluentClientGenerics

) {



    companion object {

        fun paginatorType(

            codegenContext: CodegenContext,

            generics: ClientGenerics,

            generics: FluentClientGenerics,

            operationShape: OperationShape

        ): RuntimeType? {

            return if (operationShape.isPaginated(codegenContext.model)) {
@@ -79,7 +80,9 @@ class PaginatorGenerator private constructor( 
        documentation = "Paginators for the service"

    )



    private val inputType = symbolProvider.toSymbol(operation.inputShape(model))

    private val outputType = operation.outputShape(model)

    private val errorType = operation.errorSymbol(symbolProvider)



    private fun paginatorType(): RuntimeType = RuntimeType.forInlineFun(

        paginatorName,
@@ -91,12 +94,13 @@ class PaginatorGenerator private constructor( 
        "generics" to generics.decl,

        "bounds" to generics.bounds,

        "page_size_setter" to pageSizeSetter(),

        "send_bounds" to generics.sendBounds(inputType, symbolProvider.toSymbol(outputType), errorType),



        // Operation Types

        "operation" to symbolProvider.toSymbol(operation),

        "Input" to symbolProvider.toSymbol(operation.inputShape(model)),

        "Output" to symbolProvider.toSymbol(operation.outputShape(model)),

        "Error" to operation.errorSymbol(symbolProvider),

        "Input" to inputType,

        "Output" to symbolProvider.toSymbol(outputType),

        "Error" to errorType,

        "Builder" to operation.inputShape(model).builderSymbol(symbolProvider),



        // SDK Types
@@ -125,7 +129,7 @@ class PaginatorGenerator private constructor( 
                builder: #{Builder}

            }



            impl${generics.inst} ${paginatorName}${generics.inst} where #{bounds:W} {

            impl${generics.inst} ${paginatorName}${generics.inst} #{bounds:W} {

                /// Create a new paginator-wrapper

                pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle${generics.inst}>, builder: #{Builder}) -> Self {

                    Self {
@@ -143,13 +147,7 @@ class PaginatorGenerator private constructor( 
                ///

                /// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).

                pub fn send(self) -> impl #{Stream}<Item = std::result::Result<#{Output}, #{SdkError}<#{Error}>>> + Unpin

                where

                    R::Policy: #{client}::bounds::SmithyRetryPolicy<

                        #{Input}OperationOutputAlias,

                        #{Output},

                        #{Error},

                        #{Input}OperationRetryAlias

                    >, {

                #{send_bounds:W} {

                    // Move individual fields out of self for the borrow checker

                    let builder = self.builder;

                    let handle = self.handle;
@@ -246,20 +244,14 @@ class PaginatorGenerator private constructor( 
                /// This is created with [`.items()`]($paginatorName::items)

                pub struct ${paginatorName}Items#{generics:W}($paginatorName${generics.inst});



                impl ${generics.inst} ${paginatorName}Items${generics.inst} where #{bounds:W} {

                impl ${generics.inst} ${paginatorName}Items${generics.inst} #{bounds:W} {

                    /// Create the pagination stream

                    ///

                    /// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._

                    ///

                    /// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).

                    pub fn send(self) -> impl #{Stream}<Item = std::result::Result<${itemType()}, #{SdkError}<#{Error}>>> + Unpin

                    where

                        R::Policy: #{client}::bounds::SmithyRetryPolicy<

                            #{Input}OperationOutputAlias,

                            #{Output},

                            #{Error},

                            #{Input}OperationRetryAlias

                        >, {

                    #{send_bounds:W} {

                        #{fn_stream}::TryFlatMap::new(self.0.send()).flat_map(|page| #{extract_items}(page).unwrap_or_default().into_iter())

                    }

                }