fix: aws client config redesign (#274)

Author: kneekey23

AWSClientRuntime/Sources/AWSClientConfiguration.swift

@@ -5,9 +5,11 @@
 
 import ClientRuntime
 
-public protocol AWSClientConfiguration {
+public protocol AWSRuntimeConfiguration {
     var credentialsProvider: AWSCredentialsProvider { get set }
     var region: String { get set }
     var signingRegion: String {get set}
     var endpointResolver: EndpointResolver {get set}
 }
+
+public typealias AWSClientConfiguration = SDKRuntimeConfiguration & AWSRuntimeConfiguration

AWSClientRuntime/Sources/Auth/AWSCredentialsProvider.swift

@@ -46,7 +46,8 @@ public class AWSCredentialsProvider {
         return AWSCredentialsProvider(awsCredentialsProvider: credsProvider)
     }
 
-    public static func fromChain(_ config: AWSCredentialsProviderChainDefaultConfig) throws -> AWSCredentialsProvider {
+    public static func fromChain(shutDownCallback: ShutDownCallback? = nil) throws -> AWSCredentialsProvider {
+        let config = AWSCredentialsProviderChainDefaultConfig(shutDownCallback: shutDownCallback)
         let credsProvider = try CRTAWSCredentialsProvider(fromChainDefault: config.toCRTType())
         return AWSCredentialsProvider(awsCredentialsProvider: credsProvider)
     }

AWSClientRuntime/Sources/Auth/AWSCredentialsProviderChainDefaultConfig.swift

@@ -9,12 +9,15 @@ import ClientRuntime
 
 public struct AWSCredentialsProviderChainDefaultConfig {
     let shutDownCallback: ShutDownCallback?
-    let client: CRTClientEngine
+    
+    public init(shutDownCallback: ShutDownCallback? = nil) {
+        self.shutDownCallback = shutDownCallback
+    }
 }
 
 extension AWSCredentialsProviderChainDefaultConfig {
     func toCRTType() -> CRTCredentialsProviderChainDefaultConfig {
-        return CredentialsProviderChainDefaultConfig(bootstrap: client.bootstrap, shutDownOptions: shutDownCallback)
+        return CredentialsProviderChainDefaultConfig(bootstrap: SDKDefaultIO.shared.clientBootstrap, shutDownOptions: shutDownCallback)
     }
 }
 

README.md

@@ -95,25 +95,13 @@ let package = Package(
 )
 ```
 
-Update the scheme in Xcode to put your AWS credentials in env variables (we don’t have auto credential resolution quite finished yet, only 3/4 done sry)
-
-Variable names are:*
-```
-AWS_ACCESS_KEY_ID
-AWS_SECRET_ACCESS_KEY
-```
-(if you need help with getting these values, talk to wooj@ or nickik@
-
 Then you can open up main.swift, and instantiate CognitoIdentity as follows:
 
 ```swift
 import CognitoIdentity
 import Foundation
 
-//this config file will be moved out of the client,
-// I realize this is a pain right now and we have an open ticket for it.
-let config = try! CognitoIdentityClient.CognitoIdentityClientConfiguration.default()
-let cognitoIdentityClient = CognitoIdentityClient(config: config)
+let cognitoIdentityClient = CognitoIdentityClient()
 let cognitoInputCall = CreateIdentityPoolInput(allowClassicFlow: nil,
                                                 allowUnauthenticatedIdentities: true,
                                                 cognitoIdentityProviders: nil,
@@ -136,7 +124,7 @@ cognitoIdentityClient.createIdentityPool(input: cognitoInputCall) { (result) in
 
 As a result, you should be able to:
 
-    1. Log into your AWS console, go to us-east-1 (we default region to us-east-1, no region resolver yet)
+    1. Log into your AWS console, go to us-east-1 (we default region to us-east-1 but you can pass in a region, no region resolver yet)
     2. Click on cognito
     3. click on cognito identity pools
     4. Verify that you see the newly created identity pool name: identityPoolMadeWithSwiftSDK

TestLambdaSdk/Sources/TestSdk/main.swift

@@ -4,8 +4,7 @@ import ClientRuntime
 
 do {
 
-    let config = try S3Client.S3ClientConfiguration.default()
-    let s3Client = S3Client(config: config)
+    let s3Client = try S3Client(region: "us-east-1")
     guard let data = "hello".data(using: .utf8) else {
         print("why is data empty")
         fatalError()

codegen/smithy-aws-swift-codegen/src/main/kotlin/software/amazon/smithy/aws/swift/codegen/AWSClientRuntimeTypes.kt

@@ -0,0 +1,16 @@
+package software.amazon.smithy.aws.swift.codegen
+
+import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.swift.codegen.model.buildSymbol
+
+object AWSClientRuntimeTypes {
+    object Core {
+        val EndpointResolver = runtimeSymbol("EndpointResolver", AWSSwiftDependency.AWS_CLIENT_RUNTIME)
+        val CredentialsProvider = runtimeSymbol("AWSCredentialsProvider", AWSSwiftDependency.AWS_CLIENT_RUNTIME)
+    }
+}
+
+private fun runtimeSymbol(name: String, dependency: AWSSwiftDependency): Symbol = buildSymbol {
+    this.name = name
+    dependency(dependency)
+}

codegen/smithy-aws-swift-codegen/src/main/kotlin/software/amazon/smithy/aws/swift/codegen/AWSHttpProtocolClientGeneratorFactory.kt

@@ -18,7 +18,6 @@ class AWSHttpProtocolClientGeneratorFactory : HttpProtocolClientGeneratorFactory
     ): HttpProtocolClientGenerator {
         val serviceName = ctx.symbolProvider.toSymbol(ctx.service).name
         val config = AWSServiceConfig(writer, serviceName)
-        val clientProperties = httpProtocolCustomizable.getClientProperties()
-        return HttpProtocolClientGenerator(ctx, writer, clientProperties, config, httpBindingResolver, defaultContentType, httpProtocolCustomizable)
+        return HttpProtocolClientGenerator(ctx, writer, config, httpBindingResolver, defaultContentType, httpProtocolCustomizable)
     }
 }

codegen/smithy-aws-swift-codegen/src/main/kotlin/software/amazon/smithy/aws/swift/codegen/AWSHttpProtocolCustomizations.kt

@@ -10,8 +10,10 @@ import software.amazon.smithy.model.shapes.ServiceShape
 import software.amazon.smithy.swift.codegen.SwiftWriter
 import software.amazon.smithy.swift.codegen.integration.ClientProperty
 import software.amazon.smithy.swift.codegen.integration.DefaultHttpProtocolCustomizations
+import software.amazon.smithy.swift.codegen.integration.HttpProtocolServiceClient
 import software.amazon.smithy.swift.codegen.integration.OperationMiddlewareRenderable
 import software.amazon.smithy.swift.codegen.integration.ProtocolGenerator
+import software.amazon.smithy.swift.codegen.integration.ServiceConfig
 
 abstract class AWSHttpProtocolCustomizations : DefaultHttpProtocolCustomizations() {
     override fun baseMiddlewares(ctx: ProtocolGenerator.GenerationContext, op: OperationShape): List<OperationMiddlewareRenderable> {
@@ -57,4 +59,14 @@ abstract class AWSHttpProtocolCustomizations : DefaultHttpProtocolCustomizations
         properties.add(AWSHttpResponseJsonDecoder(responseDecoderOptions))
         return properties
     }
+
+    override fun serviceClient(
+        ctx: ProtocolGenerator.GenerationContext,
+        writer: SwiftWriter,
+        serviceConfig: ServiceConfig
+    ): HttpProtocolServiceClient {
+        writer.addImport(AWSSwiftDependency.AWS_CLIENT_RUNTIME.target)
+        val clientProperties = getClientProperties()
+        return AWSHttpProtocolServiceClient(ctx, writer, clientProperties, serviceConfig)
+    }
 }

codegen/smithy-aws-swift-codegen/src/main/kotlin/software/amazon/smithy/aws/swift/codegen/AWSHttpProtocolServiceClient.kt

@@ -0,0 +1,23 @@
+package software.amazon.smithy.aws.swift.codegen
+
+import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.swift.codegen.SwiftWriter
+import software.amazon.smithy.swift.codegen.integration.ClientProperty
+import software.amazon.smithy.swift.codegen.integration.HttpProtocolServiceClient
+import software.amazon.smithy.swift.codegen.integration.ProtocolGenerator
+import software.amazon.smithy.swift.codegen.integration.ServiceConfig
+
+class AWSHttpProtocolServiceClient(
+    ctx: ProtocolGenerator.GenerationContext,
+    private val writer: SwiftWriter,
+    properties: List<ClientProperty>,
+    private val serviceConfig: ServiceConfig
+) : HttpProtocolServiceClient(ctx, writer, properties, serviceConfig) {
+    override fun renderConvenienceInit(serviceSymbol: Symbol) {
+        writer.openBlock("public convenience init(region: String? = nil) throws {", "}") {
+            writer.write("let unwrappedRegion = region ?? \"us-east-1\"") // TODO: replace with call to region resolver
+            writer.write("let config = try ${serviceConfig.typeName}(region: unwrappedRegion)")
+            writer.write("self.init(config: config)")
+        }
+    }
+}

codegen/smithy-aws-swift-codegen/src/main/kotlin/software/amazon/smithy/aws/swift/codegen/AWSServiceConfig.kt

@@ -4,54 +4,78 @@ import software.amazon.smithy.codegen.core.Symbol
 import software.amazon.smithy.swift.codegen.SwiftWriter
 import software.amazon.smithy.swift.codegen.integration.ConfigField
 import software.amazon.smithy.swift.codegen.integration.ServiceConfig
+import software.amazon.smithy.swift.codegen.model.buildSymbol
 
 const val REGION_CONFIG_NAME = "region"
 const val CREDENTIALS_PROVIDER_CONFIG_NAME = "credentialsProvider"
 const val SIGNING_REGION_CONFIG_NAME = "signingRegion"
 const val ENDPOINT_RESOLVER = "endpointResolver"
 
-val AWS_CONFIG_FIELDS = listOf(
-    ConfigField(REGION_CONFIG_NAME, "String", "The region to send requests to. (Required)"),
-    ConfigField(
-        CREDENTIALS_PROVIDER_CONFIG_NAME, "AWSCredentialsProvider",
-        "The credentials provider to use to authenticate requests."
-    ),
-    ConfigField(SIGNING_REGION_CONFIG_NAME, "String", "The region to sign requests in. (Required)"),
-    ConfigField(
-        ENDPOINT_RESOLVER, "EndpointResolver",
-        "The endpoint resolver used to resolve endpoints."
-    )
-)
-
 class AWSServiceConfig(writer: SwiftWriter, serviceName: String) : ServiceConfig(writer, serviceName) {
     override val typesToConformConfigTo: List<String>
-        get() = super.typesToConformConfigTo + listOf("AWSClientConfiguration")
+        get() = listOf("AWSClientConfiguration")
 
-    override fun renderStaticDefaultImplementation(serviceSymbol: Symbol) {
-        writer.openBlock("public static func `default`() throws -> ${serviceSymbol.name}Configuration {", "}") {
-            writer.write("let awsCredsProvider = try AWSCredentialsProvider.fromEnv()") // TODO: should be this be the default creds provider?
-            writer.write("return try ${serviceSymbol.name}Configuration(credentialsProvider: awsCredsProvider)")
+    override fun renderInitializers(serviceSymbol: Symbol) {
+        val awsConfigFields = otherRuntimeConfigProperties()
+        writer.openBlock("public init(", ") throws {") {
+            awsConfigFields.forEach {
+                writer.write("${it.memberName}: \$D, ", it.type)
+            }
+            writer.write("runtimeConfig: SDKRuntimeConfiguration")
         }
-    }
+        writer.indent()
+        writer.write("self.region = region")
+        writer.write("self.signingRegion = signingRegion ?? region")
+        writer.write("self.endpointResolver = endpointResolver ?? DefaultEndpointResolver()")
+        writer.openBlock("if let credProvider = credentialsProvider {", "} else {") {
+            writer.write("self.credentialsProvider = credProvider")
+        }
+        writer.indent().write("self.credentialsProvider = try AWSCredentialsProvider.fromChain()")
+        writer.dedent().write("}")
+        val runtimeTimeConfigFields = sdkRuntimeConfigProperties()
+        runtimeTimeConfigFields.forEach {
+            writer.write("self.${it.memberName} = runtimeConfig.${it.memberName}")
+        }
+        writer.dedent().write("}")
+        writer.write("")
 
-    override fun getConfigFields(): List<ConfigField> {
-        return AWS_CONFIG_FIELDS
-    }
+        writer.openBlock("public convenience init(", ") throws {") {
 
-    override fun renderConvenienceInits(serviceSymbol: Symbol) {
-        writer.addImport("AWSClientRuntime")
-        writer.openBlock("public convenience init(credentialsProvider: AWSCredentialsProvider) throws {", "}") {
-            writer.write("let region = \"us-east-1\"") // FIXME: get region from a region resolver
-            writer.write("let signingRegion = \"us-east-1\"") // FIXME: get region from a region resolver
-            writer.write("let endpointResolver = DefaultEndpointResolver()")
-            writer.openBlock("try self.init(", ")") {
-                val configFieldsSortedByName = getConfigFields().sortedBy { it.name }
-                for ((index, member) in configFieldsSortedByName.withIndex()) {
-                    val memberName = member.name
-                    val terminator = if (index == configFieldsSortedByName.size - 1) "" else ","
-                    writer.write("\$L: \$L$terminator", memberName, memberName)
-                }
+            awsConfigFields.forEachIndexed { index, configField ->
+                val terminator = if (index != awsConfigFields.lastIndex) ", " else ""
+                writer.write("${configField.memberName}: \$D$terminator", configField.type)
             }
         }
+
+        var configParamValues = ""
+        awsConfigFields.forEach {
+            configParamValues += "${it.memberName}: ${it.memberName}, "
+        }
+        writer.indent()
+        writer.write("let defaultRuntimeConfig = try DefaultSDKRuntimeConfiguration(\"${serviceName}\")")
+        writer.write("try self.init(${configParamValues}runtimeConfig: defaultRuntimeConfig)")
+        writer.dedent().write("}")
+    }
+
+    override fun otherRuntimeConfigProperties(): List<ConfigField> {
+        return listOf(
+            ConfigField(
+                REGION_CONFIG_NAME,
+                buildSymbol {
+                    this.name = "String"
+                    this.nullable = false
+                },
+                "The region to send requests to. (Required)"
+            ),
+            ConfigField(
+                CREDENTIALS_PROVIDER_CONFIG_NAME, AWSClientRuntimeTypes.Core.CredentialsProvider,
+                "The credentials provider to use to authenticate requests."
+            ),
+            ConfigField(SIGNING_REGION_CONFIG_NAME, buildSymbol { this.name = "String" }, "The region to sign requests in. (Required)"),
+            ConfigField(
+                ENDPOINT_RESOLVER, AWSClientRuntimeTypes.Core.EndpointResolver,
+                "The endpoint resolver used to resolve endpoints."
+            )
+        ).sortedBy { it.memberName }
     }
 }