Moving request checksum mutator to a closure

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

@@ -1,6 +1,6 @@
 [package]
 name = "aws-config"
-version = "1.5.7"
+version = "1.5.8"
 authors = [
  "AWS Rust SDK Team <aws-sdk-rust@amazon.com>",
  "Russell Cohen <rcoh@amazon.com>",

aws/rust-runtime/aws-inlineable/src/http_request_checksum.rs

@@ -14,7 +14,7 @@ use aws_smithy_checksums::ChecksumAlgorithm;
 use aws_smithy_checksums::{body::calculate, http::HttpChecksum};
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::{
- BeforeSerializationInterceptorContextRef, BeforeTransmitInterceptorContextMut, Input,
+ BeforeSerializationInterceptorContextMut, BeforeTransmitInterceptorContextMut, Input,
 };
 use aws_smithy_runtime_api::client::interceptors::Intercept;
 use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
@@ -102,36 +102,42 @@ impl DefaultRequestChecksumOverride {
  }
 }
 
-pub(crate) struct RequestChecksumInterceptor<AP> {
+pub(crate) struct RequestChecksumInterceptor<AP, CM> {
  algorithm_provider: AP,
+ checksum_mutator: CM,
 }
 
-impl<AP> fmt::Debug for RequestChecksumInterceptor<AP> {
+impl<AP, CM> fmt::Debug for RequestChecksumInterceptor<AP, CM> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  f.debug_struct("RequestChecksumInterceptor").finish()
  }
 }
 
-impl<AP> RequestChecksumInterceptor<AP> {
- pub(crate) fn new(algorithm_provider: AP) -> Self {
- Self { algorithm_provider }
+impl<AP, CM> RequestChecksumInterceptor<AP, CM> {
+ pub(crate) fn new(algorithm_provider: AP, checksum_mutator: CM) -> Self {
+ Self {
+ algorithm_provider,
+ checksum_mutator,
+ }
  }
 }
 
-impl<AP> Intercept for RequestChecksumInterceptor<AP>
+impl<AP, CM> Intercept for RequestChecksumInterceptor<AP, CM>
 where
  AP: Fn(&Input) -> Result<(Option<ChecksumAlgorithm>, bool), BoxError> + Send + Sync,
+ CM: Fn(&mut Input, &ConfigBag) -> Result<(), BoxError> + Send + Sync,
 {
  fn name(&self) -> &'static str {
  "RequestChecksumInterceptor"
  }
 
- fn read_before_serialization(
+ fn modify_before_serialization(
  &self,
- context: &BeforeSerializationInterceptorContextRef<'_>,
+ context: &mut BeforeSerializationInterceptorContextMut<'_>,
  _runtime_components: &RuntimeComponents,
  cfg: &mut ConfigBag,
  ) -> Result<(), BoxError> {
+ let _ = (self.checksum_mutator)(context.input_mut(), cfg);
  let checksum_algorithm = (self.algorithm_provider)(context.input())?;
  let mut layer = Layer::new("RequestChecksumInterceptor");
  layer.store_put(RequestChecksumInterceptorState {

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

@@ -43,7 +43,6 @@ val DECORATORS: List<ClientCodegenDecorator> =
  UserAgentDecorator(),
  SigV4AuthDecorator(),
  HttpRequestChecksumDecorator(),
- HttpRequestChecksumMutationInterceptorDecorator(),
  HttpResponseChecksumDecorator(),
  HttpResponseChecksumMutationInterceptorDecorator(),
  IntegrationTestDecorator(),

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

@@ -160,29 +160,71 @@ class HttpRequestChecksumCustomization(
  writable {
  // Get the `HttpChecksumTrait`, returning early if this `OperationShape` doesn't have one
  val checksumTrait = operationShape.getTrait<HttpChecksumTrait>() ?: return@writable
- val requestAlgorithmMember = checksumTrait.requestAlgorithmMember(codegenContext, operationShape)
+ val requestAlgorithmMember =
+ checksumTrait.requestAlgorithmMemberShape(codegenContext, operationShape) ?: return@writable
+ val requestAlgorithmMemberName = checksumTrait.requestAlgorithmMember(codegenContext, operationShape)
  val inputShape = codegenContext.model.expectShape(operationShape.inputShape)
  val requestChecksumRequired = checksumTrait.isRequestChecksumRequired
  val operationName = codegenContext.symbolProvider.toSymbol(operationShape).name
+ val requestAlgorithmMemberInner =
+ if (requestAlgorithmMember.isOptional) {
+ codegenContext.model.expectShape(requestAlgorithmMember.target)
+ } else {
+ requestAlgorithmMember
+ }
 
  when (section) {
  is OperationSection.AdditionalInterceptors -> {
- if (requestAlgorithmMember != null) {
+ if (requestAlgorithmMemberName != null) {
  section.registerInterceptor(runtimeConfig, this) {
  val runtimeApi = RuntimeType.smithyRuntimeApiClient(runtimeConfig)
  rustTemplate(
  """
- #{RequestChecksumInterceptor}::new(|input: &#{Input}| {
+ #{RequestChecksumInterceptor}::new(
+ |input: &#{Input}| {
  let input: &#{OperationInput} = input.downcast_ref().expect("correct type");
- let checksum_algorithm = input.$requestAlgorithmMember();
+ let checksum_algorithm = input.$requestAlgorithmMemberName();
  #{checksum_algorithm_to_str}
  #{Result}::<_, #{BoxError}>::Ok((checksum_algorithm, $requestChecksumRequired))
- })
+ },
+ |input: &mut #{Input}, cfg: &#{ConfigBag}| {
+ let input = input
+ .downcast_mut::<#{OperationInputType}>()
+ .ok_or("failed to downcast to #{OperationInputType}")?;
+
+ // This value is set by the user on the SdkConfig to indicate their preference
+ let request_checksum_calculation = cfg
+ .load::<#{RequestChecksumCalculation}>()
+ .unwrap_or(&#{RequestChecksumCalculation}::WhenSupported);
+
+ // From the httpChecksum trait
+ let http_checksum_required = $requestChecksumRequired;
+
+ // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum we
+ // default to Crc32. If it is WhenRequired and a checksum is required by the trait we also set the
+ // default. In all other cases we do nothing.
+ match (
+ request_checksum_calculation,
+ http_checksum_required,
+ input.checksum_algorithm(),
+ ) {
+ (#{RequestChecksumCalculation}::WhenSupported, _, None)
+ | (#{RequestChecksumCalculation}::WhenRequired, true, None) => {
+ input.checksum_algorithm = Some(#{ChecksumAlgoShape}::Crc32);
+ }
+ _ => {},
+ }
+
+ Ok(())
+ }
+
+ )
  """,
  *preludeScope,
  "BoxError" to RuntimeType.boxError(runtimeConfig),
  "Input" to runtimeApi.resolve("client::interceptors::context::Input"),
  "OperationInput" to codegenContext.symbolProvider.toSymbol(inputShape),
+ "ConfigBag" to RuntimeType.configBag(runtimeConfig),
  "RequestChecksumInterceptor" to
  runtimeConfig.awsInlineableHttpRequestChecksum()
  .resolve("RequestChecksumInterceptor"),
@@ -191,14 +233,19 @@ class HttpRequestChecksumCustomization(
  codegenContext,
  operationShape,
  ),
- )
- }
- section.registerInterceptor(codegenContext.runtimeConfig, this) {
- val interceptorName = "${operationName}HttpRequestChecksumMutationInterceptor"
- rustTemplate(
- """
- $interceptorName
- """,
+ "RequestChecksumCalculation" to
+ CargoDependency.smithyTypes(runtimeConfig).toType()
+ .resolve("checksum_config::RequestChecksumCalculation"),
+ "ChecksumAlgoShape" to
+ codegenContext.symbolProvider.toSymbol(
+ requestAlgorithmMemberInner,
+ ),
+ "OperationInputType" to
+ codegenContext.symbolProvider.toSymbol(
+ operationShape.inputShape(
+ codegenContext.model,
+ ),
+ ),
  )
  }
  }

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

@@ -1,6 +1,6 @@
 [package]
 name = "aws-smithy-types"
-version = "1.2.7"
+version = "1.2.8"
 authors = [
  "AWS Rust SDK Team <aws-sdk-rust@amazon.com>",
  "Russell Cohen <rcoh@amazon.com>",