diff --git a/.changelog/7c8973c1e65d45e59ef349859b24026a.json b/.changelog/7c8973c1e65d45e59ef349859b24026a.json new file mode 100644 index 00000000000..9f551532c6a --- /dev/null +++ b/.changelog/7c8973c1e65d45e59ef349859b24026a.json @@ -0,0 +1,8 @@ +{ + "id": "7c8973c1-e65d-45e5-9ef3-49859b24026a", + "type": "announcement", + "description": "BREAKFIX: corrected function spelling in environment config from GetS3DisableMultRegionAccessPoints to GetS3DisableMultiRegionAccessPoints", + "modules": [ + "service/s3control" + ] +} \ No newline at end of file diff --git a/.changelog/8e145919b32d4a33816ceb4aa78031ac.json b/.changelog/8e145919b32d4a33816ceb4aa78031ac.json new file mode 100644 index 00000000000..107fe21fb61 --- /dev/null +++ b/.changelog/8e145919b32d4a33816ceb4aa78031ac.json @@ -0,0 +1,8 @@ +{ + "id": "8e145919-b32d-4a33-816c-eb4aa78031ac", + "type": "bugfix", + "description": "Adds DisableMRAP option to config loader, and DisableMRAP client resolver to achieve parity with other S3 options in the config loader. Additionally, added breakfix to correct spelling.", + "modules": [ + "service/s3control" + ] +} \ No newline at end of file diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ResolveClientConfigFromSources.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ResolveClientConfigFromSources.java index c771daf34be..5af199db31c 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ResolveClientConfigFromSources.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ResolveClientConfigFromSources.java @@ -24,11 +24,15 @@ public class ResolveClientConfigFromSources implements GoIntegration { private static final Logger LOGGER = Logger.getLogger(AddAwsConfigFields.class.getName()); private static final String CONFIG_SOURCE_CONFIG_NAME = "ConfigSources"; - // UseARNRegion + private static final String USE_ARN_REGION_OPTION = "UseARNRegion"; private static final String USE_ARN_REGION_CONFIG_RESOLVER = "resolveUseARNRegion"; private static final String RESOLVE_USE_ARN_REGION = "ResolveUseARNRegion"; + private static final String DISABLE_MRAP_OPTION = "DisableMultiRegionAccessPoints"; + private static final String DISABLE_MRAP_CONFIG_RESOLVER = "resolveDisableMultiRegionAccessPoints"; + private static final String RESOLVE_DISABLE_MRAP = "ResolveDisableMultiRegionAccessPoints"; + // EndpointDiscovery options private static final String ENDPOINT_DISCOVERY_OPTION = "EndpointDiscovery"; private static final Symbol ENDPOINT_DISCOVERY_OPTION_TYPE = SymbolUtils.createValueSymbolBuilder( @@ -54,6 +58,14 @@ public class ResolveClientConfigFromSources implements GoIntegration { .awsResolveFunction(SymbolUtils.createValueSymbolBuilder(USE_ARN_REGION_CONFIG_RESOLVER) .build()) .build(), + AddAwsConfigFields.AwsConfigField.builder() + .name(DISABLE_MRAP_OPTION) + .type(getUniversalSymbol("bool")) + .generatedOnClient(false) + .servicePredicate(ResolveClientConfigFromSources::isS3Service) + .awsResolveFunction(SymbolUtils.createValueSymbolBuilder(DISABLE_MRAP_CONFIG_RESOLVER) + .build()) + .build(), AddAwsConfigFields.AwsConfigField.builder() .name(ENDPOINT_DISCOVERY_OPTION) .type(ENDPOINT_DISCOVERY_OPTION_TYPE) @@ -89,6 +101,7 @@ public void writeAdditionalFiles( ServiceShape serviceShape = settings.getService(model); goDelegator.useShapeWriter(serviceShape, writer -> { generateUseARNRegionResolver(model, serviceShape, writer); + generateDisableMrapResolver(model, serviceShape, writer); generateEnableEndpointDiscoveryResolver(model, serviceShape, writer); generateUseUseDualStackResolver(model, serviceShape, writer); generateUseUseFIPSEndpointResolver(model, serviceShape, writer); @@ -128,6 +141,22 @@ private static void generateUseARNRegionResolver(Model model, ServiceShape servi writer.write(""); } + private static void generateDisableMrapResolver(Model model, ServiceShape serviceShape, GoWriter writer) { + if (!isS3Service(model, serviceShape)) { + return; + } + generatedResolverFunction(writer, DISABLE_MRAP_CONFIG_RESOLVER, "resolves DisableMultiRegionAccessPoints S3 configuration", () -> { + writer.addUseImports(SmithyGoDependency.CONTEXT); + Symbol resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_DISABLE_MRAP, + AwsGoDependency.S3_SHARED_CONFIG).build(); + writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc, + CONFIG_SOURCE_CONFIG_NAME); + writer.write("if err != nil { return err }"); + writer.write("if found { o.$L = value }", DISABLE_MRAP_OPTION); + }); + writer.write(""); + } + private static void generateEnableEndpointDiscoveryResolver( Model model, ServiceShape serviceShape, diff --git a/config/env_config.go b/config/env_config.go index 18c8e0121b9..63ecd02b384 100644 --- a/config/env_config.go +++ b/config/env_config.go @@ -482,9 +482,9 @@ func (c EnvConfig) GetS3UseARNRegion(ctx context.Context) (value, ok bool, err e return *c.S3UseARNRegion, true, nil } -// GetS3DisableMultRegionAccessPoints returns whether to disable multi-region access point +// GetS3DisableMultiRegionAccessPoints returns whether to disable multi-region access point // support for the S3 client. -func (c EnvConfig) GetS3DisableMultRegionAccessPoints(ctx context.Context) (value, ok bool, err error) { +func (c EnvConfig) GetS3DisableMultiRegionAccessPoints(ctx context.Context) (value, ok bool, err error) { if c.S3DisableMultiRegionAccessPoints == nil { return false, false, nil } diff --git a/config/load_options.go b/config/load_options.go index d2280dae612..7480bb45ed1 100644 --- a/config/load_options.go +++ b/config/load_options.go @@ -172,6 +172,10 @@ type LoadOptions struct { // the region, the client's requests are sent to. S3UseARNRegion *bool + // S3DisableMultiRegionAccessPoints specifies if the S3 service should disable + // the S3 Multi-Region access points feature. + S3DisableMultiRegionAccessPoints *bool + // EnableEndpointDiscovery specifies if endpoint discovery is enable for // the client. EnableEndpointDiscovery aws.EndpointDiscoveryEnableState @@ -876,6 +880,26 @@ func WithS3UseARNRegion(v bool) LoadOptionsFunc { } } +// GetS3DisableMultiRegionAccessPoints returns whether to disable +// the S3 multi-region access points feature. +func (o LoadOptions) GetS3DisableMultiRegionAccessPoints(ctx context.Context) (v bool, found bool, err error) { + if o.S3DisableMultiRegionAccessPoints == nil { + return false, false, nil + } + return *o.S3DisableMultiRegionAccessPoints, true, nil +} + +// WithS3DisableMultiRegionAccessPoints is a helper function to construct functional options +// that can be used to set S3DisableMultiRegionAccessPoints on LoadOptions. +// If multiple WithS3DisableMultiRegionAccessPoints calls are made, the last call overrides +// the previous call values. +func WithS3DisableMultiRegionAccessPoints(v bool) LoadOptionsFunc { + return func(o *LoadOptions) error { + o.S3DisableMultiRegionAccessPoints = &v + return nil + } +} + // GetEnableEndpointDiscovery returns if the EnableEndpointDiscovery flag is set. func (o LoadOptions) GetEnableEndpointDiscovery(ctx context.Context) (value aws.EndpointDiscoveryEnableState, ok bool, err error) { if o.EnableEndpointDiscovery == aws.EndpointDiscoveryUnset { diff --git a/service/internal/s3shared/config/config.go b/service/internal/s3shared/config/config.go index 8926e5970e4..b5d31f5c574 100644 --- a/service/internal/s3shared/config/config.go +++ b/service/internal/s3shared/config/config.go @@ -7,6 +7,11 @@ type UseARNRegionProvider interface { GetS3UseARNRegion(ctx context.Context) (value bool, found bool, err error) } +// DisableMultiRegionAccessPointsProvider is an interface for retrieving external configuration value for DisableMultiRegionAccessPoints +type DisableMultiRegionAccessPointsProvider interface { + GetS3DisableMultiRegionAccessPoints(ctx context.Context) (value bool, found bool, err error) +} + // ResolveUseARNRegion extracts the first instance of a UseARNRegion from the config slice. // Additionally returns a boolean to indicate if the value was found in provided configs, and error if one is encountered. func ResolveUseARNRegion(ctx context.Context, configs []interface{}) (value bool, found bool, err error) { @@ -20,3 +25,17 @@ func ResolveUseARNRegion(ctx context.Context, configs []interface{}) (value bool } return } + +// ResolveDisableMultiRegionAccessPoints extracts the first instance of a DisableMultiRegionAccessPoints from the config slice. +// Additionally returns a boolean to indicate if the value was found in provided configs, and error if one is encountered. +func ResolveDisableMultiRegionAccessPoints(ctx context.Context, configs []interface{}) (value bool, found bool, err error) { + for _, cfg := range configs { + if p, ok := cfg.(DisableMultiRegionAccessPointsProvider); ok { + value, found, err = p.GetS3DisableMultiRegionAccessPoints(ctx) + if err != nil || found { + break + } + } + } + return +} diff --git a/service/s3/api_client.go b/service/s3/api_client.go index f3f258bf4d0..1ddcba2b256 100644 --- a/service/s3/api_client.go +++ b/service/s3/api_client.go @@ -344,6 +344,7 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { resolveAWSRetryMode(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) resolveUseARNRegion(cfg, &opts) + resolveDisableMultiRegionAccessPoints(cfg, &opts) resolveUseDualStackEndpoint(cfg, &opts) resolveUseFIPSEndpoint(cfg, &opts) return New(opts, optFns...) @@ -515,6 +516,21 @@ func resolveUseARNRegion(cfg aws.Config, o *Options) error { return nil } +// resolves DisableMultiRegionAccessPoints S3 configuration +func resolveDisableMultiRegionAccessPoints(cfg aws.Config, o *Options) error { + if len(cfg.ConfigSources) == 0 { + return nil + } + value, found, err := s3sharedconfig.ResolveDisableMultiRegionAccessPoints(context.Background(), cfg.ConfigSources) + if err != nil { + return err + } + if found { + o.DisableMultiRegionAccessPoints = value + } + return nil +} + // resolves dual-stack endpoint configuration func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error { if len(cfg.ConfigSources) == 0 {