diff --git a/aws/config.go b/aws/config.go index 2b346baee77..9e117364000 100644 --- a/aws/config.go +++ b/aws/config.go @@ -85,6 +85,16 @@ type Config struct { // See the ClientLogMode type documentation for the complete set of logging modes and available // configuration. ClientLogMode ClientLogMode + + // The configured DefaultsMode. If not specified, service clients will default to legacy. + // + // Supported modes are: auto, cross-region, in-region, legacy, mobile, standard + DefaultsMode DefaultsMode + + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set to + // AutoDefaultsMode and is initialized by `config.LoadDefaultConfig`. You should not + // populate this structure programmatically, or rely on the values here within your applications. + RuntimeEnvironment RuntimeEnvironment } // NewConfig returns a new Config pointer that can be chained with builder diff --git a/aws/defaults/auto.go b/aws/defaults/auto.go new file mode 100644 index 00000000000..9f23a2d8e3d --- /dev/null +++ b/aws/defaults/auto.go @@ -0,0 +1,38 @@ +package defaults + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + "runtime" + "strings" +) + +var getGOOS = func() string { + return runtime.GOOS +} + +// ResolveDefaultsModeAuto is used to determine the effective aws.DefaultsMode when the mode +// is set to aws.AutoDefaultsMode. +func ResolveDefaultsModeAuto(region string, environment aws.RuntimeEnvironment) aws.DefaultsMode { + goos := getGOOS() + if goos == "android" || goos == "ios" { + return aws.DefaultsModeMobile + } + + var currentRegion string + if len(environment.EnvironmentIdentifier) > 0 { + currentRegion = environment.Region + } + + if len(currentRegion) == 0 && len(environment.EC2InstanceMetadataRegion) > 0 { + currentRegion = environment.EC2InstanceMetadataRegion + } + + if len(region) > 0 && len(currentRegion) > 0 { + if strings.EqualFold(region, currentRegion) { + return aws.DefaultsModeInRegion + } + return aws.DefaultsModeCrossRegion + } + + return aws.DefaultsModeStandard +} diff --git a/aws/defaults/auto_test.go b/aws/defaults/auto_test.go new file mode 100644 index 00000000000..c514c21676c --- /dev/null +++ b/aws/defaults/auto_test.go @@ -0,0 +1,89 @@ +package defaults + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + "strconv" + "testing" +) + +func TestDetermineDefaultsMode(t *testing.T) { + cases := []struct { + Region string + GOOS string + Environment aws.RuntimeEnvironment + Expected aws.DefaultsMode + }{ + { + Region: "us-east-1", + GOOS: "ios", + Environment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: aws.ExecutionEnvironmentID("AWS_Lambda_java8"), + Region: "us-east-1", + }, + Expected: aws.DefaultsModeMobile, + }, + { + Region: "us-east-1", + GOOS: "android", + Environment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: aws.ExecutionEnvironmentID("AWS_Lambda_java8"), + Region: "us-east-1", + }, + Expected: aws.DefaultsModeMobile, + }, + { + Region: "us-east-1", + Environment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: aws.ExecutionEnvironmentID("AWS_Lambda_java8"), + Region: "us-east-1", + }, + Expected: aws.DefaultsModeInRegion, + }, + { + Region: "us-east-1", + Environment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: aws.ExecutionEnvironmentID("AWS_Lambda_java8"), + Region: "us-west-2", + }, + Expected: aws.DefaultsModeCrossRegion, + }, + { + Region: "us-east-1", + Environment: aws.RuntimeEnvironment{ + Region: "us-east-1", + EC2InstanceMetadataRegion: "us-east-1", + }, + Expected: aws.DefaultsModeInRegion, + }, + { + Region: "us-east-1", + Environment: aws.RuntimeEnvironment{ + EC2InstanceMetadataRegion: "us-west-2", + }, + Expected: aws.DefaultsModeCrossRegion, + }, + { + Region: "us-west-2", + Environment: aws.RuntimeEnvironment{}, + Expected: aws.DefaultsModeStandard, + }, + } + + for i, tt := range cases { + t.Run(strconv.Itoa(i), func(t *testing.T) { + if len(tt.GOOS) > 0 { + orig := getGOOS + getGOOS = func() string { + return tt.GOOS + } + defer func() { + getGOOS = orig + }() + } + got := ResolveDefaultsModeAuto(tt.Region, tt.Environment) + if got != tt.Expected { + t.Errorf("expect %v, got %v", tt.Expected, got) + } + }) + } +} diff --git a/aws/defaults/configuration.go b/aws/defaults/configuration.go new file mode 100644 index 00000000000..3e18d284ab0 --- /dev/null +++ b/aws/defaults/configuration.go @@ -0,0 +1,35 @@ +package defaults + +import "time" + +// Configuration is the set of SDK configuration options that are determined based +// on the configured DefaultsMode. +type Configuration struct { + // ConnectTimeout is the maximum amount of time a dial will wait for + // a connect to complete. + // + // See https://pkg.go.dev/net#Dialer.Timeout + ConnectTimeout *time.Duration + + // TLSNegotiationTimeout specifies the maximum amount of time waiting to + // wait for a TLS handshake. + // + // See https://pkg.go.dev/net/http#Transport.TLSHandshakeTimeout + TLSNegotiationTimeout *time.Duration +} + +// GetConnectTimeout returns the ConnectTimeout value, returns false if the value is not set. +func (c *Configuration) GetConnectTimeout() (time.Duration, bool) { + if c.ConnectTimeout == nil { + return 0, false + } + return *c.ConnectTimeout, true +} + +// GetTLSNegotiationTimeout returns the TLSNegotiationTimeout value, returns false if the value is not set. +func (c *Configuration) GetTLSNegotiationTimeout() (time.Duration, bool) { + if c.TLSNegotiationTimeout == nil { + return 0, false + } + return *c.TLSNegotiationTimeout, true +} diff --git a/aws/defaults/defaults.go b/aws/defaults/defaults.go new file mode 100644 index 00000000000..51a5e0fb394 --- /dev/null +++ b/aws/defaults/defaults.go @@ -0,0 +1,46 @@ +// Code generated by github.com/aws/aws-sdk-go-v2/internal/codegen/cmd/defaultsconfig. DO NOT EDIT. + +package defaults + +import ( + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + "time" +) + +// GetModeConfiguration returns the default Configuration descriptor for the given mode. +// +// Supports the following modes: cross-region, in-region, mobile, standard +func GetModeConfiguration(mode aws.DefaultsMode) (Configuration, error) { + var mv aws.DefaultsMode + mv.SetFromString(string(mode)) + + switch mv { + case aws.DefaultsModeCrossRegion: + settings := Configuration{ + ConnectTimeout: aws.Duration(3100 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(3100 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeInRegion: + settings := Configuration{ + ConnectTimeout: aws.Duration(1100 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(1100 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeMobile: + settings := Configuration{ + ConnectTimeout: aws.Duration(30000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(30000 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeStandard: + settings := Configuration{ + ConnectTimeout: aws.Duration(3100 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(3100 * time.Millisecond), + } + return settings, nil + default: + return Configuration{}, fmt.Errorf("unsupported defaults mode: %v", mode) + } +} diff --git a/aws/defaults/defaults_codegen_test.go b/aws/defaults/defaults_codegen_test.go new file mode 100644 index 00000000000..cc451229970 --- /dev/null +++ b/aws/defaults/defaults_codegen_test.go @@ -0,0 +1,46 @@ +// Code generated by github.com/aws/aws-sdk-go-v2/internal/codegen/cmd/defaultsconfig. DO NOT EDIT. + +package defaults + +import ( + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + "time" +) + +// v1TestResolver returns the default Configuration descriptor for the given mode. +// +// Supports the following modes: cross-region, in-region, mobile, standard +func v1TestResolver(mode aws.DefaultsMode) (Configuration, error) { + var mv aws.DefaultsMode + mv.SetFromString(string(mode)) + + switch mv { + case aws.DefaultsModeCrossRegion: + settings := Configuration{ + ConnectTimeout: aws.Duration(2800 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(2800 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeInRegion: + settings := Configuration{ + ConnectTimeout: aws.Duration(1000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(1000 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeMobile: + settings := Configuration{ + ConnectTimeout: aws.Duration(10000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(11000 * time.Millisecond), + } + return settings, nil + case aws.DefaultsModeStandard: + settings := Configuration{ + ConnectTimeout: aws.Duration(2000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(2000 * time.Millisecond), + } + return settings, nil + default: + return Configuration{}, fmt.Errorf("unsupported defaults mode: %v", mode) + } +} diff --git a/aws/defaults/defaults_test.go b/aws/defaults/defaults_test.go new file mode 100644 index 00000000000..ca397ea3ff7 --- /dev/null +++ b/aws/defaults/defaults_test.go @@ -0,0 +1,58 @@ +package defaults + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + "strconv" + "testing" + "time" + + "github.com/google/go-cmp/cmp" +) + +func TestConfigV1(t *testing.T) { + cases := []struct { + Mode aws.DefaultsMode + Expected Configuration + }{ + { + Mode: aws.DefaultsModeStandard, + Expected: Configuration{ + ConnectTimeout: aws.Duration(2000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(2000 * time.Millisecond), + }, + }, + { + Mode: aws.DefaultsModeInRegion, + Expected: Configuration{ + ConnectTimeout: aws.Duration(1000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(1000 * time.Millisecond), + }, + }, + { + Mode: aws.DefaultsModeCrossRegion, + Expected: Configuration{ + ConnectTimeout: aws.Duration(2800 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(2800 * time.Millisecond), + }, + }, + { + Mode: aws.DefaultsModeMobile, + Expected: Configuration{ + ConnectTimeout: aws.Duration(10000 * time.Millisecond), + TLSNegotiationTimeout: aws.Duration(11000 * time.Millisecond), + }, + }, + } + + for i, tt := range cases { + t.Run(strconv.Itoa(i), func(t *testing.T) { + got, err := v1TestResolver(tt.Mode) + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + if diff := cmp.Diff(tt.Expected, got); len(diff) > 0 { + t.Error(diff) + } + }) + } +} diff --git a/aws/defaults/doc.go b/aws/defaults/doc.go new file mode 100644 index 00000000000..2d90011b426 --- /dev/null +++ b/aws/defaults/doc.go @@ -0,0 +1,2 @@ +// Package defaults provides recommended configuration values for AWS SDKs and CLIs. +package defaults diff --git a/aws/defaultsmode.go b/aws/defaultsmode.go new file mode 100644 index 00000000000..fcf9387c281 --- /dev/null +++ b/aws/defaultsmode.go @@ -0,0 +1,95 @@ +// Code generated by github.com/aws/aws-sdk-go-v2/internal/codegen/cmd/defaultsmode. DO NOT EDIT. + +package aws + +import ( + "strings" +) + +// DefaultsMode is the SDK defaults mode setting. +type DefaultsMode string + +// The DefaultsMode constants. +const ( + // DefaultsModeAuto is an experimental mode that builds on the standard mode. + // The SDK will attempt to discover the execution environment to determine the + // appropriate settings automatically. + // + // Note that the auto detection is heuristics-based and does not guarantee 100% + // accuracy. STANDARD mode will be used if the execution environment cannot + // be determined. The auto detection might query EC2 Instance Metadata service + // (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html), + // which might introduce latency. Therefore we recommend choosing an explicit + // defaults_mode instead if startup latency is critical to your application + DefaultsModeAuto DefaultsMode = "auto" + + // DefaultsModeCrossRegion builds on the standard mode and includes optimization + // tailored for applications which call AWS services in a different region + // + // Note that the default values vended from this mode might change as best practices + // may evolve. As a result, it is encouraged to perform tests when upgrading + // the SDK + DefaultsModeCrossRegion DefaultsMode = "cross-region" + + // DefaultsModeInRegion builds on the standard mode and includes optimization + // tailored for applications which call AWS services from within the same AWS + // region + // + // Note that the default values vended from this mode might change as best practices + // may evolve. As a result, it is encouraged to perform tests when upgrading + // the SDK + DefaultsModeInRegion DefaultsMode = "in-region" + + // DefaultsModeLegacy provides default settings that vary per SDK and were used + // prior to establishment of defaults_mode + DefaultsModeLegacy DefaultsMode = "legacy" + + // DefaultsModeMobile builds on the standard mode and includes optimization + // tailored for mobile applications + // + // Note that the default values vended from this mode might change as best practices + // may evolve. As a result, it is encouraged to perform tests when upgrading + // the SDK + DefaultsModeMobile DefaultsMode = "mobile" + + // DefaultsModeStandard provides the latest recommended default values that + // should be safe to run in most scenarios + // + // Note that the default values vended from this mode might change as best practices + // may evolve. As a result, it is encouraged to perform tests when upgrading + // the SDK + DefaultsModeStandard DefaultsMode = "standard" +) + +// SetFromString sets the DefaultsMode value to one of the pre-defined constants that matches +// the provided string when compared using EqualFold. If the value does not match a known +// constant it will be set to as-is and the function will return false. As a special case, if the +// provided value is a zero-length string, the mode will be set to LegacyDefaultsMode. +func (d *DefaultsMode) SetFromString(v string) (ok bool) { + switch { + case strings.EqualFold(v, string(DefaultsModeAuto)): + *d = DefaultsModeAuto + ok = true + case strings.EqualFold(v, string(DefaultsModeCrossRegion)): + *d = DefaultsModeCrossRegion + ok = true + case strings.EqualFold(v, string(DefaultsModeInRegion)): + *d = DefaultsModeInRegion + ok = true + case strings.EqualFold(v, string(DefaultsModeLegacy)): + *d = DefaultsModeLegacy + ok = true + case strings.EqualFold(v, string(DefaultsModeMobile)): + *d = DefaultsModeMobile + ok = true + case strings.EqualFold(v, string(DefaultsModeStandard)): + *d = DefaultsModeStandard + ok = true + case len(v) == 0: + *d = DefaultsModeLegacy + ok = true + default: + *d = DefaultsMode(v) + } + return ok +} diff --git a/aws/from_ptr.go b/aws/from_ptr.go index 72e29c354d3..2394418e9bd 100644 --- a/aws/from_ptr.go +++ b/aws/from_ptr.go @@ -342,3 +342,24 @@ func ToTimeSlice(vs []*time.Time) []time.Time { func ToTimeMap(vs map[string]*time.Time) map[string]time.Time { return ptr.ToTimeMap(vs) } + +// ToDuration returns time.Duration value dereferenced if the passed +// in pointer was not nil. Returns a time.Duration zero value if the +// pointer was nil. +func ToDuration(p *time.Duration) (v time.Duration) { + return ptr.ToDuration(p) +} + +// ToDurationSlice returns a slice of time.Duration values, that are +// dereferenced if the passed in pointer was not nil. Returns a time.Duration +// zero value if the pointer was nil. +func ToDurationSlice(vs []*time.Duration) []time.Duration { + return ptr.ToDurationSlice(vs) +} + +// ToDurationMap returns a map of time.Duration values, that are +// dereferenced if the passed in pointer was not nil. The time.Duration +// zero value is used if the pointer was nil. +func ToDurationMap(vs map[string]*time.Duration) map[string]time.Duration { + return ptr.ToDurationMap(vs) +} diff --git a/aws/protocol/eventstream/go.mod b/aws/protocol/eventstream/go.mod index 2c87389fd00..c7ef240b56b 100644 --- a/aws/protocol/eventstream/go.mod +++ b/aws/protocol/eventstream/go.mod @@ -3,7 +3,7 @@ module github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream go 1.15 require ( - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 // indirect ) diff --git a/aws/protocol/eventstream/go.sum b/aws/protocol/eventstream/go.sum index ff032855447..23991236cde 100644 --- a/aws/protocol/eventstream/go.sum +++ b/aws/protocol/eventstream/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/aws/runtime.go b/aws/runtime.go new file mode 100644 index 00000000000..3af9b2b3361 --- /dev/null +++ b/aws/runtime.go @@ -0,0 +1,14 @@ +package aws + +// ExecutionEnvironmentID is the AWS execution environment runtime identifier. +type ExecutionEnvironmentID string + +// RuntimeEnvironment is a collection of values that are determined at runtime +// based on the environment that the SDK is executing in. Some of these values +// may or may not be present based on the executing environment and certain SDK +// configuration properties that drive whether these values are populated.. +type RuntimeEnvironment struct { + EnvironmentIdentifier ExecutionEnvironmentID + Region string + EC2InstanceMetadataRegion string +} diff --git a/aws/to_ptr.go b/aws/to_ptr.go index 28a193b8a22..f3fc4d610dc 100644 --- a/aws/to_ptr.go +++ b/aws/to_ptr.go @@ -278,3 +278,20 @@ func TimeSlice(vs []time.Time) []*time.Time { func TimeMap(vs map[string]time.Time) map[string]*time.Time { return ptr.TimeMap(vs) } + +// Duration returns a pointer value for the time.Duration value passed in. +func Duration(v time.Duration) *time.Duration { + return ptr.Duration(v) +} + +// DurationSlice returns a slice of time.Duration pointers from the values +// passed in. +func DurationSlice(vs []time.Duration) []*time.Duration { + return ptr.DurationSlice(vs) +} + +// DurationMap returns a map of time.Duration pointers from the values +// passed in. +func DurationMap(vs map[string]time.Duration) map[string]*time.Duration { + return ptr.DurationMap(vs) +} diff --git a/aws/transport/http/client.go b/aws/transport/http/client.go index b207a5655d6..26d90719b2d 100644 --- a/aws/transport/http/client.go +++ b/aws/transport/http/client.go @@ -2,6 +2,7 @@ package http import ( "crypto/tls" + "github.com/aws/aws-sdk-go-v2/aws" "net" "net/http" "reflect" @@ -68,6 +69,14 @@ func (b *BuildableClient) Do(req *http.Request) (*http.Response, error) { return b.client.Do(req) } +// Freeze returns a frozen aws.HTTPClient implementation that is no longer a BuildableClient. +// Use this to prevent the SDK from applying DefaultMode configuration values to a buildable client. +func (b *BuildableClient) Freeze() aws.HTTPClient { + cpy := b.clone() + cpy.build() + return cpy.client +} + func (b *BuildableClient) build() { b.client = wrapWithLimitedRedirect(&http.Client{ Timeout: b.clientTimeout, diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddAwsConfigFields.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddAwsConfigFields.java index bffa70bcdfd..90e072e404c 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddAwsConfigFields.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddAwsConfigFields.java @@ -54,6 +54,8 @@ public class AddAwsConfigFields implements GoIntegration { public static final String API_OPTIONS_CONFIG_NAME = "APIOptions"; public static final String LOGGER_CONFIG_NAME = "Logger"; public static final String LOG_MODE_CONFIG_NAME = "ClientLogMode"; + public static final String DEFAULTS_MODE_CONFIG_NAME = "DefaultsMode"; + public static final String RUNTIME_ENVIRONMENT_CONFIG_NAME = "RuntimeEnvironment"; private static final String RESOLVE_HTTP_CLIENT = "resolveHTTPClient"; private static final String RESOLVE_RETRYER = "resolveRetryer"; @@ -66,6 +68,24 @@ public class AddAwsConfigFields implements GoIntegration { .type(getUniversalSymbol("string")) .documentation("The region to send requests to. (Required)") .build(), + AwsConfigField.builder() + .name(DEFAULTS_MODE_CONFIG_NAME) + .type(getAwsCoreSymbol("DefaultsMode")) + .documentation(""" + The configuration DefaultsMode that the SDK should use when constructing + the clients initial default settings. + """) + .build(), + AwsConfigField.builder() + .name(RUNTIME_ENVIRONMENT_CONFIG_NAME) + .type(getAwsCoreSymbol("RuntimeEnvironment")) + .documentation(""" + The RuntimeEnvironment configuration, only populated if the DefaultsMode is set to + AutoDefaultsMode and is initialized using `config.LoadDefaultConfig`. You should not + populate this structure programmatically, or rely on the values here within your + applications. + """) + .build(), AwsConfigField.builder() .name(RETRYER_CONFIG_NAME) .type(getAwsCoreSymbol("Retryer")) @@ -193,13 +213,78 @@ private void writeRetryerResolvers(GoWriter writer) { } private void writeHttpClientResolver(GoWriter writer) { - writer.openBlock("func $L(o *Options) {", "}", RESOLVE_HTTP_CLIENT, () -> { - writer.openBlock("if o.$L != nil {", "}", HTTP_CLIENT_CONFIG_NAME, () -> writer.write("return")); - writer.write("o.$L = $T()", HTTP_CLIENT_CONFIG_NAME, - SymbolUtils.createValueSymbolBuilder("NewBuildableClient", - AwsGoDependency.AWS_HTTP_TRANSPORT).build()); - }); - writer.write(""); + writer.pushState(); + + writer.putContext("resolverName", RESOLVE_HTTP_CLIENT); + writer.putContext("optionName", HTTP_CLIENT_CONFIG_NAME); + writer.putContext("newClient", SymbolUtils.createValueSymbolBuilder("NewBuildableClient", + AwsGoDependency.AWS_HTTP_TRANSPORT).build()); + writer.putContext("buildableType", SymbolUtils.createPointableSymbolBuilder("BuildableClient", + AwsGoDependency.AWS_HTTP_TRANSPORT).build()); + writer.putContext("modeType", SymbolUtils.createValueSymbolBuilder("DefaultsMode", + AwsGoDependency.AWS_CORE).build()); + writer.putContext("modeOption", DEFAULTS_MODE_CONFIG_NAME); + writer.putContext("runtimeOption", RUNTIME_ENVIRONMENT_CONFIG_NAME); + writer.putContext("autoModeType", SymbolUtils.createValueSymbolBuilder("DefaultsModeAuto", + AwsGoDependency.AWS_CORE).build()); + writer.putContext("legacyModeType", SymbolUtils.createValueSymbolBuilder("DefaultsModeLegacy", + AwsGoDependency.AWS_CORE).build()); + writer.putContext("regionOption", REGION_CONFIG_NAME); + writer.putContext("resolveAuto", SymbolUtils.createValueSymbolBuilder("ResolveDefaultsModeAuto", + AwsGoDependency.AWS_DEFAULTS).build()); + writer.putContext("getConfig", SymbolUtils.createValueSymbolBuilder("GetModeConfiguration", + AwsGoDependency.AWS_DEFAULTS).build()); + writer.putContext("dialer", SymbolUtils.createPointableSymbolBuilder("Dialer", + SmithyGoDependency.NET).build()); + writer.putContext("transport", SymbolUtils.createPointableSymbolBuilder("Transport", + SmithyGoDependency.NET_HTTP).build()); + writer.putContext("errorf", SymbolUtils.createPointableSymbolBuilder("Errorf", + SmithyGoDependency.FMT).build()); + + writer.write(""" + func $resolverName:L(o *Options) { + var buildable $buildableType:P + + if o.$optionName:L != nil { + var ok bool + buildable, ok = o.$optionName:L.($buildableType:P) + if !ok { + return + } + } else { + buildable = $newClient:T() + } + + var mode $modeType:T + if ok := mode.SetFromString(string(o.$modeOption:L)); !ok { + panic($errorf:T("unsupported defaults mode constant %v", mode)) + } + + if mode == $autoModeType:T { + mode = $resolveAuto:T(o.$regionOption:L, o.$runtimeOption:L) + } + + if mode != $legacyModeType:T { + modeConfig, _ := $getConfig:T(mode) + + buildable = buildable.WithDialerOptions(func(dialer $dialer:P) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport $transport:P) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.$optionName:L = buildable + } + """); + + writer.popState(); } private void writeAwsConfigEndpointResolver(GoWriter writer) { diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsGoDependency.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsGoDependency.java index 8ce0bae34ca..66ace99bfd9 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsGoDependency.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsGoDependency.java @@ -46,6 +46,7 @@ public class AwsGoDependency { null, Versions.SERVICE_INTERNAL_CONFIG, "internalConfig"); public static final GoDependency SERVICE_INTERNAL_ENDPOINT_DISCOVERY = awsModuleDep("service/internal/endpoint-discovery", null, Versions.SERVICE_INTERNAL_ENDPOINT_DISCOVERY, "internalEndpointDiscovery"); + public static final GoDependency AWS_DEFAULTS = aws("aws/defaults"); public static final GoDependency REGEXP = SmithyGoDependency.stdlib("regexp"); diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ClientResolvedDefaultsMode.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ClientResolvedDefaultsMode.java new file mode 100644 index 00000000000..614deaa7011 --- /dev/null +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ClientResolvedDefaultsMode.java @@ -0,0 +1,114 @@ +/* + * Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"). + * You may not use this file except in compliance with the License. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0 + * + * or in the "license" file accompanying this file. This file is distributed + * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing + * permissions and limitations under the License. + */ + +package software.amazon.smithy.aws.go.codegen; + +import java.util.List; +import software.amazon.smithy.codegen.core.SymbolProvider; +import software.amazon.smithy.go.codegen.GoDelegator; +import software.amazon.smithy.go.codegen.GoSettings; +import software.amazon.smithy.go.codegen.GoWriter; +import software.amazon.smithy.go.codegen.SymbolUtils; +import software.amazon.smithy.go.codegen.integration.ConfigField; +import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver; +import software.amazon.smithy.go.codegen.integration.GoIntegration; +import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.utils.ListUtils; + +/** + * Records the initial resolve DefaultsMode when the client is constructed. + */ +public class ClientResolvedDefaultsMode implements GoIntegration { + private static final String RESOLVED_DEFAULTS_MODE_CONFIG_NAME = "resolvedDefaultsMode"; + private static final String RESOLVE_RESOLVED_DEFAULTS_MODE = "setResolvedDefaultsMode"; + + private static final ConfigField CONFIG_FIELD = ConfigField.builder() + .name(RESOLVED_DEFAULTS_MODE_CONFIG_NAME) + .type(SymbolUtils.createValueSymbolBuilder("DefaultsMode", AwsGoDependency.AWS_CORE) + .build()) + .documentation(""" + The initial DefaultsMode used when the client options were constructed. If the + DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved value + was at that point in time. + """) + .build(); + + private void writeSetResolvedDefaultsMode(GoWriter writer) { + writer.pushState(); + + writer.putContext("resolverName", RESOLVE_RESOLVED_DEFAULTS_MODE); + writer.putContext("resolvedOption", RESOLVED_DEFAULTS_MODE_CONFIG_NAME); + writer.putContext("modeType", SymbolUtils.createValueSymbolBuilder("DefaultsMode", + AwsGoDependency.AWS_CORE) + .build()); + writer.putContext("modeOption", AddAwsConfigFields.DEFAULTS_MODE_CONFIG_NAME); + writer.putContext("autoResolve", SymbolUtils.createValueSymbolBuilder("ResolveDefaultsModeAuto", + AwsGoDependency.AWS_DEFAULTS) + .build()); + writer.putContext("autoMode", SymbolUtils.createValueSymbolBuilder("DefaultsModeAuto", + AwsGoDependency.AWS_CORE) + .build()); + writer.putContext("region", "Region"); + writer.putContext("envOption", AddAwsConfigFields.RUNTIME_ENVIRONMENT_CONFIG_NAME); + + writer.write(""" + func $resolverName:L(o *Options) { + if len(o.$resolvedOption:L) > 0 { + return + } + + var mode $modeType:T + mode.SetFromString(string(o.$modeOption:L)) + + if mode == $autoMode:T { + mode = $autoResolve:T(o.$region:L, o.$envOption:L) + } + + o.$resolvedOption:L = mode + } + """); + + writer.popState(); + } + + @Override + public void writeAdditionalFiles( + GoSettings settings, + Model model, + SymbolProvider symbolProvider, + GoDelegator goDelegator + ) { + ServiceShape serviceShape = settings.getService(model); + goDelegator.useShapeWriter(serviceShape, w -> { + writeSetResolvedDefaultsMode(w); + }); + } + + @Override + public List getClientPlugins() { + return ListUtils.of( + RuntimeClientPlugin.builder() + .addConfigField(CONFIG_FIELD) + .addConfigFieldResolver(ConfigFieldResolver.builder() + .location(ConfigFieldResolver.Location.CLIENT) + .target(ConfigFieldResolver.Target.INITIALIZATION) + .resolver(SymbolUtils.createValueSymbolBuilder(RESOLVE_RESOLVED_DEFAULTS_MODE).build()) + .build()) + .build() + ); + } +} diff --git a/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration b/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration index fe9286408a6..b1acf0cc6ec 100644 --- a/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration +++ b/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration @@ -1,5 +1,6 @@ software.amazon.smithy.aws.go.codegen.AddProtocols software.amazon.smithy.aws.go.codegen.AddAwsConfigFields +software.amazon.smithy.aws.go.codegen.ClientResolvedDefaultsMode software.amazon.smithy.aws.go.codegen.RegisterServiceMetadataMiddleware software.amazon.smithy.aws.go.codegen.AwsEventStreamIntegration software.amazon.smithy.aws.go.codegen.AssembleMiddlewareStack diff --git a/config/codegen/main.go b/config/codegen/main.go index 80257ff0f39..03ee7328a17 100644 --- a/config/codegen/main.go +++ b/config/codegen/main.go @@ -40,6 +40,8 @@ var implAsserts = map[string][]string{ "clientLogModeProvider": {loadOptionsType}, "logConfigurationWarningsProvider": {loadOptionsType}, "ec2IMDSRegionProvider": {loadOptionsType}, + "defaultsModeProvider": {envConfigType, sharedConfigType, loadOptionsType}, + "defaultsModeIMDSClientProvider": {loadOptionsType}, } var tplProviderTests = template.Must(template.New("tplProviderTests").Funcs(map[string]interface{}{ diff --git a/config/config.go b/config/config.go index 83fd1c952f5..80d6e83a4d3 100644 --- a/config/config.go +++ b/config/config.go @@ -2,6 +2,7 @@ package config import ( "context" + "github.com/aws/aws-sdk-go-v2/aws" ) @@ -53,6 +54,14 @@ var defaultAWSConfigResolvers = []awsConfigResolver{ // API client request pipeline middleware. resolveAPIOptions, + // Resolves the DefaultsMode that should be used by SDK clients. + // If this mode is set to AutoDefaultsMode. + // + // Comes after HTTPClient and CustomCABundle to ensure the HTTP client is configured if provided before invoking + // IMDS if mode is auto. Comes before resolving credentials so that those subsequent clients use the configured + // auto mode. + resolveDefaultsModeOptions, + // Sets the resolved credentials the API clients will use for // authentication. Provides the SDK's default credential chain. // diff --git a/config/defaultsmode.go b/config/defaultsmode.go new file mode 100644 index 00000000000..dc94acd30a1 --- /dev/null +++ b/config/defaultsmode.go @@ -0,0 +1,47 @@ +package config + +import ( + "context" + "os" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" +) + +const execEnvVar = "AWS_EXECUTION_ENV" + +// DefaultsModeOptions is the set of options that are used to configure +type DefaultsModeOptions struct { + // The SDK configuration defaults mode. Defaults to legacy if not specified. + // + // Supported modes are: auto, cross-region, in-region, legacy, mobile, standard + Mode aws.DefaultsMode + + // The EC2 Instance Metadata Client that should be used when performing environment + // discovery when aws.AutoDefaultsMode is set. + // + // If not specified the SDK will construct a client if the instance metadata service has not been disabled by + // the AWS_EC2_METADATA_DISABLED environment variable. + IMDSClient *imds.Client +} + +func resolveDefaultsModeRuntimeEnvironment(ctx context.Context, envConfig *EnvConfig, client *imds.Client) (aws.RuntimeEnvironment, error) { + getRegionOutput, err := client.GetRegion(ctx, &imds.GetRegionInput{}) + // honor context timeouts, but if we couldn't talk to IMDS don't fail runtime environment introspection. + select { + case <-ctx.Done(): + return aws.RuntimeEnvironment{}, err + default: + } + + var imdsRegion string + if err == nil { + imdsRegion = getRegionOutput.Region + } + + return aws.RuntimeEnvironment{ + EnvironmentIdentifier: aws.ExecutionEnvironmentID(os.Getenv(execEnvVar)), + Region: envConfig.Region, + EC2InstanceMetadataRegion: imdsRegion, + }, nil +} diff --git a/config/env_config.go b/config/env_config.go index c4ddb229700..6907804e870 100644 --- a/config/env_config.go +++ b/config/env_config.go @@ -4,13 +4,13 @@ import ( "bytes" "context" "fmt" - "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "io" "io/ioutil" "os" "strings" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" ) // CredentialsSourceName provides a name of the provider when config is @@ -63,6 +63,8 @@ const ( awsUseDualStackEndpoint = "AWS_USE_DUALSTACK_ENDPOINT" awsUseFIPSEndpoint = "AWS_USE_FIPS_ENDPOINT" + + awsDefaultMode = "AWS_DEFAULTS_MODE" ) var ( @@ -226,6 +228,11 @@ type EnvConfig struct { // // AWS_USE_FIPS_ENDPOINT=true UseFIPSEndpoint aws.FIPSEndpointState + + // Specifies the SDk Defaults Mode used by services. + // + // AWS_DEFAULTS_MODE=standard + DefaultsMode aws.DefaultsMode } // loadEnvConfig reads configuration values from the OS's environment variables. @@ -292,9 +299,20 @@ func NewEnvConfig() (EnvConfig, error) { return cfg, err } + if err := setDefaultsModeFromEnvVal(&cfg.DefaultsMode, []string{awsDefaultMode}); err != nil { + return cfg, err + } + return cfg, nil } +func (c EnvConfig) getDefaultsMode(ctx context.Context) (aws.DefaultsMode, bool, error) { + if len(c.DefaultsMode) == 0 { + return "", false, nil + } + return c.DefaultsMode, true, nil +} + func setEC2IMDSClientEnableState(state *imds.ClientEnableState, keys []string) { for _, k := range keys { value := os.Getenv(k) @@ -313,6 +331,18 @@ func setEC2IMDSClientEnableState(state *imds.ClientEnableState, keys []string) { } } +func setDefaultsModeFromEnvVal(mode *aws.DefaultsMode, keys []string) error { + for _, k := range keys { + if value := os.Getenv(k); len(value) > 0 { + if ok := mode.SetFromString(value); !ok { + return fmt.Errorf("invalid %s value: %s", k, value) + } + break + } + } + return nil +} + func setEC2IMDSEndpointMode(mode *imds.EndpointModeState, keys []string) error { for _, k := range keys { value := os.Getenv(k) diff --git a/config/env_config_test.go b/config/env_config_test.go index aaee33a016a..14470ff7114 100644 --- a/config/env_config_test.go +++ b/config/env_config_test.go @@ -1,16 +1,16 @@ package config import ( - "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" - "github.com/google/go-cmp/cmp" "os" "reflect" "strconv" "testing" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/aws-sdk-go-v2/internal/awstesting" "github.com/aws/smithy-go/ptr" + "github.com/google/go-cmp/cmp" ) var _ sharedConfigProfileProvider = (*EnvConfig)(nil) @@ -368,6 +368,31 @@ func TestNewEnvConfig(t *testing.T) { }, WantErr: true, }, + 31: { + Env: map[string]string{ + "AWS_DEFAULTS_MODE": "auto", + }, + Config: EnvConfig{ + DefaultsMode: aws.DefaultsModeAuto, + }, + }, + 32: { + Env: map[string]string{ + "AWS_DEFAULTS_MODE": "standard", + }, + Config: EnvConfig{ + DefaultsMode: aws.DefaultsModeStandard, + }, + }, + 33: { + Env: map[string]string{ + "AWS_DEFAULTS_MODE": "invalid", + }, + Config: EnvConfig{ + DefaultsMode: aws.DefaultsMode("invalid"), + }, + WantErr: true, + }, } for i, c := range cases { diff --git a/config/go.mod b/config/go.mod index e0edd953339..77d20366858 100644 --- a/config/go.mod +++ b/config/go.mod @@ -9,7 +9,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/ini v1.3.3 github.com/aws/aws-sdk-go-v2/service/sso v1.8.0 github.com/aws/aws-sdk-go-v2/service/sts v1.13.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/config/go.sum b/config/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/config/go.sum +++ b/config/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/config/load_options.go b/config/load_options.go index a2756aeb376..1a16e057972 100644 --- a/config/load_options.go +++ b/config/load_options.go @@ -159,6 +159,23 @@ type LoadOptions struct { // Specifies that SDK clients must resolve a FIPS endpoint for // services. UseFIPSEndpoint aws.FIPSEndpointState + + // Specifies the SDK configuration mode for defaults. + DefaultsModeOptions DefaultsModeOptions +} + +func (o LoadOptions) getDefaultsMode(ctx context.Context) (aws.DefaultsMode, bool, error) { + if len(o.DefaultsModeOptions.Mode) == 0 { + return "", false, nil + } + return o.DefaultsModeOptions.Mode, true, nil +} + +func (o LoadOptions) getDefaultsModeIMDSClient(ctx context.Context) (*imds.Client, bool, error) { + if o.DefaultsModeOptions.IMDSClient == nil { + return nil, false, nil + } + return o.DefaultsModeOptions.IMDSClient, true, nil } // getRegion returns Region from config's LoadOptions @@ -806,3 +823,20 @@ func (o LoadOptions) GetUseFIPSEndpoint(ctx context.Context) (value aws.FIPSEndp } return o.UseFIPSEndpoint, true, nil } + +// WithDefaultsMode sets the SDK defaults configuration mode to the value provided. +// +// Zero or more functional options can be provided to provide configuration options for performing +// environment discovery when using aws.AutoDefaultsMode. +func WithDefaultsMode(mode aws.DefaultsMode, optFns ...func(options *DefaultsModeOptions)) LoadOptionsFunc { + do := DefaultsModeOptions{ + Mode: mode, + } + for _, fn := range optFns { + fn(&do) + } + return func(options *LoadOptions) error { + options.DefaultsModeOptions = do + return nil + } +} diff --git a/config/provider.go b/config/provider.go index ac4c1403668..279aee7f4ca 100644 --- a/config/provider.go +++ b/config/provider.go @@ -11,6 +11,7 @@ import ( "github.com/aws/aws-sdk-go-v2/credentials/processcreds" "github.com/aws/aws-sdk-go-v2/credentials/ssocreds" "github.com/aws/aws-sdk-go-v2/credentials/stscreds" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" ) @@ -464,5 +465,37 @@ func getSSOProviderOptions(ctx context.Context, configs configs) (v func(options } } } - return + return v, found, err +} + +type defaultsModeIMDSClientProvider interface { + getDefaultsModeIMDSClient(context.Context) (*imds.Client, bool, error) +} + +func getDefaultsModeIMDSClient(ctx context.Context, configs configs) (v *imds.Client, found bool, err error) { + for _, c := range configs { + if p, ok := c.(defaultsModeIMDSClientProvider); ok { + v, found, err = p.getDefaultsModeIMDSClient(ctx) + if err != nil || found { + break + } + } + } + return v, found, err +} + +type defaultsModeProvider interface { + getDefaultsMode(context.Context) (aws.DefaultsMode, bool, error) +} + +func getDefaultsMode(ctx context.Context, configs configs) (v aws.DefaultsMode, found bool, err error) { + for _, c := range configs { + if p, ok := c.(defaultsModeProvider); ok { + v, found, err = p.getDefaultsMode(ctx) + if err != nil || found { + break + } + } + } + return v, found, err } diff --git a/config/provider_assert_test.go b/config/provider_assert_test.go index b0a8fa1cbb4..2ed28b3d0cf 100644 --- a/config/provider_assert_test.go +++ b/config/provider_assert_test.go @@ -38,6 +38,18 @@ var ( _ defaultRegionProvider = &LoadOptions{} ) +// defaultsModeIMDSClientProvider implementor assertions +var ( + _ defaultsModeIMDSClientProvider = &LoadOptions{} +) + +// defaultsModeProvider implementor assertions +var ( + _ defaultsModeProvider = &EnvConfig{} + _ defaultsModeProvider = &SharedConfig{} + _ defaultsModeProvider = &LoadOptions{} +) + // ec2IMDSRegionProvider implementor assertions var ( _ ec2IMDSRegionProvider = &LoadOptions{} diff --git a/config/resolve.go b/config/resolve.go index 305a2a16a3b..1cb59c15b41 100644 --- a/config/resolve.go +++ b/config/resolve.go @@ -11,6 +11,7 @@ import ( "github.com/aws/aws-sdk-go-v2/aws" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/smithy-go/logging" ) @@ -241,3 +242,36 @@ func resolveEC2IMDSRegion(ctx context.Context, cfg *aws.Config, configs configs) return nil } + +func resolveDefaultsModeOptions(ctx context.Context, cfg *aws.Config, configs configs) error { + defaultsMode, found, err := getDefaultsMode(ctx, configs) + if err != nil { + return err + } + if !found { + defaultsMode = aws.DefaultsModeLegacy + } + + var environment aws.RuntimeEnvironment + if defaultsMode == aws.DefaultsModeAuto { + envConfig, _, _ := getAWSConfigSources(configs) + + client, found, err := getDefaultsModeIMDSClient(ctx, configs) + if err != nil { + return err + } + if !found { + client = imds.NewFromConfig(*cfg) + } + + environment, err = resolveDefaultsModeRuntimeEnvironment(ctx, envConfig, client) + if err != nil { + return err + } + } + + cfg.DefaultsMode = defaultsMode + cfg.RuntimeEnvironment = environment + + return nil +} diff --git a/config/resolve_processcreds_test.go b/config/resolve_processcreds_test.go index d6056bc1e4d..222a62d05df 100644 --- a/config/resolve_processcreds_test.go +++ b/config/resolve_processcreds_test.go @@ -2,11 +2,12 @@ package config import ( "context" - "github.com/aws/aws-sdk-go-v2/internal/awstesting" "os" "path/filepath" "runtime" "testing" + + "github.com/aws/aws-sdk-go-v2/internal/awstesting" ) func setupEnvForProcesscredsConfigFile() { diff --git a/config/resolve_test.go b/config/resolve_test.go index 984f66655ae..49828574e3d 100644 --- a/config/resolve_test.go +++ b/config/resolve_test.go @@ -3,16 +3,22 @@ package config import ( "bytes" "context" + "encoding/json" "io/ioutil" "net/http" + "net/http/httptest" + "os" + "strconv" "testing" "github.com/aws/aws-sdk-go-v2/aws" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" "github.com/aws/aws-sdk-go-v2/credentials" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/aws-sdk-go-v2/internal/awstesting" "github.com/aws/aws-sdk-go-v2/internal/awstesting/unit" "github.com/aws/smithy-go/logging" + "github.com/google/go-cmp/cmp" ) func TestResolveCustomCABundle(t *testing.T) { @@ -211,3 +217,165 @@ func TestResolveLogger(t *testing.T) { t.Error("unexpected logger type") } } + +func TestResolveDefaultsMode(t *testing.T) { + cases := []struct { + Mode aws.DefaultsMode + ExpectedDefaultsMode aws.DefaultsMode + ExpectedRuntimeEnvironment aws.RuntimeEnvironment + WithIMDS func() *httptest.Server + Env map[string]string + }{ + { + ExpectedDefaultsMode: aws.DefaultsModeLegacy, + }, + { + Mode: aws.DefaultsModeStandard, + ExpectedDefaultsMode: aws.DefaultsModeStandard, + }, + { + Mode: aws.DefaultsModeInRegion, + ExpectedDefaultsMode: aws.DefaultsModeInRegion, + }, + { + Mode: aws.DefaultsModeCrossRegion, + ExpectedDefaultsMode: aws.DefaultsModeCrossRegion, + }, + { + Mode: aws.DefaultsModeMobile, + ExpectedDefaultsMode: aws.DefaultsModeMobile, + }, + { + Mode: aws.DefaultsModeAuto, + Env: map[string]string{ + "AWS_EXECUTION_ENV": "envName", + "AWS_REGION": "us-west-2", + }, + WithIMDS: func() *httptest.Server { + return httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/latest/dynamic/instance-identity/document" { + out, _ := json.Marshal(&imds.InstanceIdentityDocument{ + Region: "us-west-2", + }) + w.Write(out) + } else if r.URL.Path == "/latest/api/token" { + header := w.Header() + // bounce the TTL header + const ttlHeader = "X-Aws-Ec2-Metadata-Token-Ttl-Seconds" + header.Set(ttlHeader, r.Header.Get(ttlHeader)) + w.Write([]byte("validToken")) + } else { + w.Write([]byte("")) + } + })) + }, + ExpectedDefaultsMode: aws.DefaultsModeAuto, + ExpectedRuntimeEnvironment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: "envName", + Region: "us-west-2", + EC2InstanceMetadataRegion: "us-west-2", + }, + }, + { + Mode: aws.DefaultsModeAuto, + Env: map[string]string{ + "AWS_EXECUTION_ENV": "envName", + "AWS_REGION": "us-west-2", + }, + WithIMDS: func() *httptest.Server { + return httptest.NewServer(http.HandlerFunc( + func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(500) + })) + }, + ExpectedDefaultsMode: aws.DefaultsModeAuto, + ExpectedRuntimeEnvironment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: "envName", + Region: "us-west-2", + EC2InstanceMetadataRegion: "", + }, + }, + { + Mode: aws.DefaultsModeAuto, + Env: map[string]string{ + "AWS_EXECUTION_ENV": "envName", + "AWS_REGION": "us-west-2", + "AWS_EC2_METADATA_DISABLED": "true", + }, + ExpectedDefaultsMode: aws.DefaultsModeAuto, + ExpectedRuntimeEnvironment: aws.RuntimeEnvironment{ + EnvironmentIdentifier: "envName", + Region: "us-west-2", + EC2InstanceMetadataRegion: "", + }, + }, + { + Mode: aws.DefaultsModeAuto, + Env: map[string]string{ + "AWS_REGION": "us-west-2", + "AWS_DEFAULT_REGION": "other", + "AWS_EC2_METADATA_DISABLED": "true", + }, + ExpectedDefaultsMode: aws.DefaultsModeAuto, + ExpectedRuntimeEnvironment: aws.RuntimeEnvironment{ + Region: "us-west-2", + }, + }, + { + Mode: aws.DefaultsModeAuto, + Env: map[string]string{ + "AWS_DEFAULT_REGION": "us-west-2", + "AWS_EC2_METADATA_DISABLED": "true", + }, + ExpectedDefaultsMode: aws.DefaultsModeAuto, + ExpectedRuntimeEnvironment: aws.RuntimeEnvironment{ + Region: "us-west-2", + }, + }, + } + + for i, tt := range cases { + t.Run(strconv.Itoa(i), func(t *testing.T) { + var server *httptest.Server + if tt.WithIMDS != nil { + server = tt.WithIMDS() + defer server.Close() + } + loadOptionsFunc := func(*LoadOptions) error { + return nil + } + if len(tt.Mode) != 0 { + loadOptionsFunc = WithDefaultsMode(tt.Mode, func(options *DefaultsModeOptions) { + if server != nil { + options.IMDSClient = imds.New(imds.Options{ + Endpoint: server.URL, + }) + } + }) + } + + if len(tt.Env) > 0 { + restoreEnv := awstesting.StashEnv() + defer awstesting.PopEnv(restoreEnv) + + for key := range tt.Env { + _ = os.Setenv(key, tt.Env[key]) + } + } + + cfg, err := LoadDefaultConfig(context.Background(), loadOptionsFunc) + if err != nil { + t.Errorf("expect no error, got %v", err) + } + + if diff := cmp.Diff(tt.ExpectedDefaultsMode, cfg.DefaultsMode); len(diff) > 0 { + t.Errorf(diff) + } + + if diff := cmp.Diff(tt.ExpectedRuntimeEnvironment, cfg.RuntimeEnvironment); len(diff) > 0 { + t.Errorf(diff) + } + }) + } +} diff --git a/config/shared_config.go b/config/shared_config.go index b7222d0206b..b82926df976 100644 --- a/config/shared_config.go +++ b/config/shared_config.go @@ -4,7 +4,6 @@ import ( "context" "errors" "fmt" - "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "os" "path/filepath" "runtime" @@ -12,6 +11,7 @@ import ( "time" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/aws-sdk-go-v2/internal/ini" "github.com/aws/smithy-go/logging" ) @@ -76,6 +76,8 @@ const ( s3DisableMultiRegionAccessPointsKey = `s3_disable_multiregion_access_points` useFIPSEndpointKey = "use_fips_endpoint" + + defaultsModeKey = "defaults_mode" ) // defaultSharedConfigProfile allows for swapping the default profile for testing @@ -193,6 +195,19 @@ type SharedConfig struct { // // use_fips_endpoint=true UseFIPSEndpoint aws.FIPSEndpointState + + // Specifies which defaults mode should be used by services. + // + // defaults_mode=standard + DefaultsMode aws.DefaultsMode +} + +func (c SharedConfig) getDefaultsMode(ctx context.Context) (value aws.DefaultsMode, ok bool, err error) { + if len(c.DefaultsMode) == 0 { + return "", false, nil + } + + return c.DefaultsMode, true, nil } // GetS3UseARNRegion returns if the S3 service should allow ARNs to direct the region @@ -549,12 +564,8 @@ func mergeSections(dst, src ini.Sections) error { secretKey := srcSection.String(secretAccessKey) if dstSection.Has(accessKeyIDKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding credentials value for aws access key id, "+ - "and aws secret access key, defined in %v, with values found in a duplicate profile "+ - "defined at file %v. \n", - sectionName, dstSection.SourceFile[accessKeyIDKey], - srcSection.SourceFile[accessKeyIDKey])) + dstSection.Logs = append(dstSection.Logs, newMergeKeyLogMessage(sectionName, accessKeyIDKey, + dstSection.SourceFile[accessKeyIDKey], srcSection.SourceFile[accessKeyIDKey])) } // update access key @@ -572,24 +583,8 @@ func mergeSections(dst, src ini.Sections) error { dstSection.UpdateValue(secretAccessKey, v) // update session token - if srcSection.Has(sessionTokenKey) { - sessionKey := srcSection.String(sessionTokenKey) - - val, e := ini.NewStringValue(sessionKey) - if e != nil { - return fmt.Errorf("error merging session key, %w", e) - } - - if dstSection.Has(sessionTokenKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, sessionTokenKey, dstSection.SourceFile[sessionTokenKey], - sessionTokenKey, srcSection.SourceFile[sessionTokenKey])) - } - - dstSection.UpdateValue(sessionTokenKey, val) - dstSection.UpdateSourceFile(sessionTokenKey, srcSection.SourceFile[sessionTokenKey]) + if err = mergeStringKey(&srcSection, &dstSection, sectionName, sessionTokenKey); err != nil { + return err } // update source file to reflect where the static creds came from @@ -597,253 +592,90 @@ func mergeSections(dst, src ini.Sections) error { dstSection.UpdateSourceFile(secretAccessKey, srcSection.SourceFile[secretAccessKey]) } - if srcSection.Has(roleArnKey) { - key := srcSection.String(roleArnKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging roleArnKey, %w", err) - } - - if dstSection.Has(roleArnKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, roleArnKey, dstSection.SourceFile[roleArnKey], - roleArnKey, srcSection.SourceFile[roleArnKey])) - } - - dstSection.UpdateValue(roleArnKey, val) - dstSection.UpdateSourceFile(roleArnKey, srcSection.SourceFile[roleArnKey]) - } - - if srcSection.Has(sourceProfileKey) { - key := srcSection.String(sourceProfileKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging sourceProfileKey, %w", err) - } - - if dstSection.Has(sourceProfileKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, sourceProfileKey, dstSection.SourceFile[sourceProfileKey], - sourceProfileKey, srcSection.SourceFile[sourceProfileKey])) - } - - dstSection.UpdateValue(sourceProfileKey, val) - dstSection.UpdateSourceFile(sourceProfileKey, srcSection.SourceFile[sourceProfileKey]) - } - - if srcSection.Has(credentialSourceKey) { - key := srcSection.String(credentialSourceKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging credentialSourceKey, %w", err) - } - - if dstSection.Has(credentialSourceKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, credentialSourceKey, dstSection.SourceFile[credentialSourceKey], - credentialSourceKey, srcSection.SourceFile[credentialSourceKey])) - } - - dstSection.UpdateValue(credentialSourceKey, val) - dstSection.UpdateSourceFile(credentialSourceKey, srcSection.SourceFile[credentialSourceKey]) - } - - if srcSection.Has(externalIDKey) { - key := srcSection.String(externalIDKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging externalIDKey, %w", err) - } - - if dstSection.Has(externalIDKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, externalIDKey, dstSection.SourceFile[externalIDKey], - externalIDKey, srcSection.SourceFile[externalIDKey])) - } - - dstSection.UpdateValue(externalIDKey, val) - dstSection.UpdateSourceFile(externalIDKey, srcSection.SourceFile[externalIDKey]) - } - - if srcSection.Has(mfaSerialKey) { - key := srcSection.String(mfaSerialKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging mfaSerialKey, %w", err) - } - - if dstSection.Has(mfaSerialKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, mfaSerialKey, dstSection.SourceFile[mfaSerialKey], - mfaSerialKey, srcSection.SourceFile[mfaSerialKey])) - } - - dstSection.UpdateValue(mfaSerialKey, val) - dstSection.UpdateSourceFile(mfaSerialKey, srcSection.SourceFile[mfaSerialKey]) - } - - if srcSection.Has(roleSessionNameKey) { - key := srcSection.String(roleSessionNameKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging roleSessionNameKey, %w", err) - } - - if dstSection.Has(roleSessionNameKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, roleSessionNameKey, dstSection.SourceFile[roleSessionNameKey], - roleSessionNameKey, srcSection.SourceFile[roleSessionNameKey])) - } - - dstSection.UpdateValue(roleSessionNameKey, val) - dstSection.UpdateSourceFile(roleSessionNameKey, srcSection.SourceFile[roleSessionNameKey]) - } - - // role duration seconds key update - if srcSection.Has(roleDurationSecondsKey) { - roleDurationSeconds := srcSection.Int(roleDurationSecondsKey) - v, err := ini.NewIntValue(roleDurationSeconds) - if err != nil { - return fmt.Errorf("error merging role duration seconds key, %w", err) - } - dstSection.UpdateValue(roleDurationSecondsKey, v) - - dstSection.UpdateSourceFile(roleDurationSecondsKey, srcSection.SourceFile[roleDurationSecondsKey]) + stringKeys := []string{ + roleArnKey, + sourceProfileKey, + credentialSourceKey, + externalIDKey, + mfaSerialKey, + roleSessionNameKey, + regionKey, + enableEndpointDiscoveryKey, + credentialProcessKey, + webIdentityTokenFileKey, + s3UseARNRegionKey, + s3DisableMultiRegionAccessPointsKey, + ec2MetadataServiceEndpointModeKey, + ec2MetadataServiceEndpointKey, + useDualStackEndpoint, + useFIPSEndpointKey, + defaultsModeKey, } - - if srcSection.Has(regionKey) { - key := srcSection.String(regionKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging regionKey, %w", err) + for i := range stringKeys { + if err := mergeStringKey(&srcSection, &dstSection, sectionName, stringKeys[i]); err != nil { + return err } - - if dstSection.Has(regionKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, regionKey, dstSection.SourceFile[regionKey], - regionKey, srcSection.SourceFile[regionKey])) - } - - dstSection.UpdateValue(regionKey, val) - dstSection.UpdateSourceFile(regionKey, srcSection.SourceFile[regionKey]) } - if srcSection.Has(enableEndpointDiscoveryKey) { - key := srcSection.String(enableEndpointDiscoveryKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging enableEndpointDiscoveryKey, %w", err) + intKeys := []string{roleDurationSecondsKey} + for i := range intKeys { + if err := mergeIntKey(&srcSection, &dstSection, sectionName, intKeys[i]); err != nil { + return err } - - if dstSection.Has(enableEndpointDiscoveryKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, enableEndpointDiscoveryKey, dstSection.SourceFile[enableEndpointDiscoveryKey], - enableEndpointDiscoveryKey, srcSection.SourceFile[enableEndpointDiscoveryKey])) - } - - dstSection.UpdateValue(enableEndpointDiscoveryKey, val) - dstSection.UpdateSourceFile(enableEndpointDiscoveryKey, srcSection.SourceFile[enableEndpointDiscoveryKey]) } - if srcSection.Has(credentialProcessKey) { - key := srcSection.String(credentialProcessKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging credentialProcessKey, %w", err) - } + // set srcSection on dst srcSection + dst = dst.SetSection(sectionName, dstSection) + } - if dstSection.Has(credentialProcessKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, credentialProcessKey, dstSection.SourceFile[credentialProcessKey], - credentialProcessKey, srcSection.SourceFile[credentialProcessKey])) - } + return nil +} - dstSection.UpdateValue(credentialProcessKey, val) - dstSection.UpdateSourceFile(credentialProcessKey, srcSection.SourceFile[credentialProcessKey]) +func mergeStringKey(srcSection *ini.Section, dstSection *ini.Section, sectionName, key string) error { + if srcSection.Has(key) { + srcValue := srcSection.String(key) + val, err := ini.NewStringValue(srcValue) + if err != nil { + return fmt.Errorf("error merging %s, %w", key, err) } - if srcSection.Has(webIdentityTokenFileKey) { - key := srcSection.String(webIdentityTokenFileKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging webIdentityTokenFileKey, %w", err) - } - - if dstSection.Has(webIdentityTokenFileKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, webIdentityTokenFileKey, dstSection.SourceFile[webIdentityTokenFileKey], - webIdentityTokenFileKey, srcSection.SourceFile[webIdentityTokenFileKey])) - } - - dstSection.UpdateValue(webIdentityTokenFileKey, val) - dstSection.UpdateSourceFile(webIdentityTokenFileKey, srcSection.SourceFile[webIdentityTokenFileKey]) + if dstSection.Has(key) { + dstSection.Logs = append(dstSection.Logs, newMergeKeyLogMessage(sectionName, key, + dstSection.SourceFile[key], srcSection.SourceFile[key])) } - if srcSection.Has(s3UseARNRegionKey) { - key := srcSection.String(s3UseARNRegionKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging s3UseARNRegionKey, %w", err) - } - - if dstSection.Has(s3UseARNRegionKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, s3UseARNRegionKey, dstSection.SourceFile[s3UseARNRegionKey], - s3UseARNRegionKey, srcSection.SourceFile[s3UseARNRegionKey])) - } + dstSection.UpdateValue(key, val) + dstSection.UpdateSourceFile(key, srcSection.SourceFile[key]) + } + return nil +} - dstSection.UpdateValue(s3UseARNRegionKey, val) - dstSection.UpdateSourceFile(s3UseARNRegionKey, srcSection.SourceFile[s3UseARNRegionKey]) +func mergeIntKey(srcSection *ini.Section, dstSection *ini.Section, sectionName, key string) error { + if srcSection.Has(key) { + srcValue := srcSection.Int(key) + v, err := ini.NewIntValue(srcValue) + if err != nil { + return fmt.Errorf("error merging %s, %w", key, err) } - if srcSection.Has(s3DisableMultiRegionAccessPointsKey) { - key := srcSection.String(s3DisableMultiRegionAccessPointsKey) - val, err := ini.NewStringValue(key) - if err != nil { - return fmt.Errorf("error merging s3DisableMultiRegionAccessPointsKey, %w", err) - } + if dstSection.Has(key) { + dstSection.Logs = append(dstSection.Logs, newMergeKeyLogMessage(sectionName, key, + dstSection.SourceFile[key], srcSection.SourceFile[key])) - if dstSection.Has(s3DisableMultiRegionAccessPointsKey) { - dstSection.Logs = append(dstSection.Logs, - fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ - "with a %v value found in a duplicate profile defined at file %v. \n", - sectionName, s3DisableMultiRegionAccessPointsKey, dstSection.SourceFile[s3DisableMultiRegionAccessPointsKey], - s3DisableMultiRegionAccessPointsKey, srcSection.SourceFile[s3DisableMultiRegionAccessPointsKey])) - } - - dstSection.UpdateValue(s3DisableMultiRegionAccessPointsKey, val) - dstSection.UpdateSourceFile(s3DisableMultiRegionAccessPointsKey, srcSection.SourceFile[s3DisableMultiRegionAccessPointsKey]) } - // set srcSection on dst srcSection - dst = dst.SetSection(sectionName, dstSection) + dstSection.UpdateValue(key, v) + dstSection.UpdateSourceFile(key, srcSection.SourceFile[key]) } - return nil } +func newMergeKeyLogMessage(sectionName, key, dstSourceFile, srcSourceFile string) string { + return fmt.Sprintf("For profile: %v, overriding %v value, defined in %v "+ + "with a %v value found in a duplicate profile defined at file %v. \n", + sectionName, key, dstSourceFile, key, srcSourceFile) +} + // Returns an error if all of the files fail to load. If at least one file is // successfully loaded and contains the profile, no error will be returned. func (c *SharedConfig) setFromIniSections(profiles map[string]struct{}, profile string, @@ -991,6 +823,10 @@ func (c *SharedConfig) setFromIniSection(profile string, section ini.Section) er updateUseDualStackEndpoint(&c.UseDualStackEndpoint, section, useDualStackEndpoint) updateUseFIPSEndpoint(&c.UseFIPSEndpoint, section, useFIPSEndpointKey) + if err := updateDefaultsMode(&c.DefaultsMode, section, defaultsModeKey); err != nil { + return fmt.Errorf("failed to load %s from shared config, %w", defaultsModeKey, err) + } + // Shared Credentials creds := aws.Credentials{ AccessKeyID: section.String(accessKeyIDKey), @@ -1006,6 +842,17 @@ func (c *SharedConfig) setFromIniSection(profile string, section ini.Section) er return nil } +func updateDefaultsMode(mode *aws.DefaultsMode, section ini.Section, key string) error { + if !section.Has(key) { + return nil + } + value := section.String(key) + if ok := mode.SetFromString(value); !ok { + return fmt.Errorf("invalid value: %s", value) + } + return nil +} + func updateEC2MetadataServiceEndpointMode(endpointMode *imds.EndpointModeState, section ini.Section, key string) error { if !section.Has(key) { return nil diff --git a/config/shared_config_test.go b/config/shared_config_test.go index cc5fa432a94..f5195ecb4f5 100644 --- a/config/shared_config_test.go +++ b/config/shared_config_test.go @@ -4,7 +4,6 @@ import ( "bytes" "context" "fmt" - "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "path/filepath" "reflect" "strconv" @@ -13,6 +12,7 @@ import ( "time" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" "github.com/aws/aws-sdk-go-v2/internal/ini" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/ptr" @@ -510,6 +510,30 @@ func TestNewSharedConfig(t *testing.T) { UseFIPSEndpoint: aws.FIPSEndpointStateDisabled, }, }, + "defaults mode auto": { + ConfigFilenames: []string{testConfigFilename}, + CredentialsFilenames: []string{testCredentialsFilename}, + Profile: "autodefaultsmode", + Expected: SharedConfig{ + Profile: "autodefaultsmode", + DefaultsMode: aws.DefaultsModeAuto, + }, + }, + "defaults mode standard": { + ConfigFilenames: []string{testConfigFilename}, + CredentialsFilenames: []string{testCredentialsFilename}, + Profile: "standarddefaultsmode", + Expected: SharedConfig{ + Profile: "standarddefaultsmode", + DefaultsMode: aws.DefaultsModeStandard, + }, + }, + "defaults mode invalid": { + ConfigFilenames: []string{testConfigFilename}, + CredentialsFilenames: []string{testCredentialsFilename}, + Profile: "invaliddefaultsmode", + Err: fmt.Errorf("failed to load defaults_mode from shared config, invalid value: invalid"), + }, } for name, c := range cases { diff --git a/config/testdata/shared_config b/config/testdata/shared_config index a04f51767ed..ee2c7b9961c 100644 --- a/config/testdata/shared_config +++ b/config/testdata/shared_config @@ -225,3 +225,12 @@ use_fips_endpoint=False [profile UseFIPSEndpointInvalid] region = "us-west-2" use_fips_endpoint=invalid + +[profile autodefaultsmode] +defaults_mode = auto + +[profile standarddefaultsmode] +defaults_mode = standard + +[profile invaliddefaultsmode] +defaults_mode = invalid diff --git a/credentials/go.mod b/credentials/go.mod index 10e1629b0f3..4bc0b20f591 100644 --- a/credentials/go.mod +++ b/credentials/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.9.0 github.com/aws/aws-sdk-go-v2/service/sso v1.8.0 github.com/aws/aws-sdk-go-v2/service/sts v1.13.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/credentials/go.sum b/credentials/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/credentials/go.sum +++ b/credentials/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/example/service/s3/listObjects/go.sum b/example/service/s3/listObjects/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/example/service/s3/listObjects/go.sum +++ b/example/service/s3/listObjects/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/example/service/s3/usingPrivateLink/go.sum b/example/service/s3/usingPrivateLink/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/example/service/s3/usingPrivateLink/go.sum +++ b/example/service/s3/usingPrivateLink/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/feature/cloudfront/sign/go.sum b/feature/cloudfront/sign/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/feature/cloudfront/sign/go.sum +++ b/feature/cloudfront/sign/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/feature/dynamodb/attributevalue/go.mod b/feature/dynamodb/attributevalue/go.mod index 7fa7cbe6a1e..7bbb41d824f 100644 --- a/feature/dynamodb/attributevalue/go.mod +++ b/feature/dynamodb/attributevalue/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.12.0 github.com/aws/aws-sdk-go-v2/service/dynamodbstreams v1.10.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/feature/dynamodb/attributevalue/go.sum b/feature/dynamodb/attributevalue/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/feature/dynamodb/attributevalue/go.sum +++ b/feature/dynamodb/attributevalue/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/feature/dynamodb/expression/go.sum b/feature/dynamodb/expression/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/feature/dynamodb/expression/go.sum +++ b/feature/dynamodb/expression/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/feature/dynamodbstreams/attributevalue/go.mod b/feature/dynamodbstreams/attributevalue/go.mod index ea813a6b692..292478dc9dc 100644 --- a/feature/dynamodbstreams/attributevalue/go.mod +++ b/feature/dynamodbstreams/attributevalue/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.12.0 github.com/aws/aws-sdk-go-v2/service/dynamodbstreams v1.10.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/feature/dynamodbstreams/attributevalue/go.sum b/feature/dynamodbstreams/attributevalue/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/feature/dynamodbstreams/attributevalue/go.sum +++ b/feature/dynamodbstreams/attributevalue/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/feature/ec2/imds/go.mod b/feature/ec2/imds/go.mod index e21c587f3be..793415dea7f 100644 --- a/feature/ec2/imds/go.mod +++ b/feature/ec2/imds/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( github.com/aws/aws-sdk-go-v2 v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/feature/ec2/imds/go.sum b/feature/ec2/imds/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/feature/ec2/imds/go.sum +++ b/feature/ec2/imds/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/feature/ec2/imds/internal/configtesting/go.sum b/feature/ec2/imds/internal/configtesting/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/feature/ec2/imds/internal/configtesting/go.sum +++ b/feature/ec2/imds/internal/configtesting/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/feature/rds/auth/go.sum b/feature/rds/auth/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/feature/rds/auth/go.sum +++ b/feature/rds/auth/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/feature/s3/manager/go.mod b/feature/s3/manager/go.mod index 6ca6728fea2..17c34857c45 100644 --- a/feature/s3/manager/go.mod +++ b/feature/s3/manager/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/config v1.12.0 github.com/aws/aws-sdk-go-v2/service/s3 v1.23.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/feature/s3/manager/go.sum b/feature/s3/manager/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/feature/s3/manager/go.sum +++ b/feature/s3/manager/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/go.mod b/go.mod index 7aa19e456ab..4f573d5d1e5 100644 --- a/go.mod +++ b/go.mod @@ -1,7 +1,7 @@ module github.com/aws/aws-sdk-go-v2 require ( - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/go.sum b/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/internal/codegen/LICENSE.txt b/internal/codegen/LICENSE.txt new file mode 100644 index 00000000000..d6456956733 --- /dev/null +++ b/internal/codegen/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/internal/codegen/cmd/defaultsconfig/generator.go b/internal/codegen/cmd/defaultsconfig/generator.go new file mode 100644 index 00000000000..ae13b26ece0 --- /dev/null +++ b/internal/codegen/cmd/defaultsconfig/generator.go @@ -0,0 +1,113 @@ +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "os" + "path" +) + +// Import is a Go package import and associated alias +type Import struct { + Package string + Alias string +} + +type generationContext struct { + PackageName string + ResolverName string + Imports map[Import]struct{} + Config SDKDefaultConfig +} + +func (g *generationContext) AddImport(pkg, alias string) (s string) { + if g.Imports == nil { + g.Imports = make(map[Import]struct{}) + } + + g.Imports[Import{ + Package: pkg, + Alias: alias, + }] = struct{}{} + + return s +} + +func (g *generationContext) AddSDKImport(pkg, alias string) (s string) { + if g.Imports == nil { + g.Imports = make(map[Import]struct{}) + } + + g.Imports[Import{ + Package: path.Join("github.com/aws/aws-sdk-go-v2", pkg), + Alias: alias, + }] = struct{}{} + + return s +} + +func generateConfigPackage(jsonFile, outputFile, packageName, resolverName string) (err error) { + config, err := ioutil.ReadFile(jsonFile) + if err != nil { + return fmt.Errorf("failed to read configuration file: %w", err) + } + + decoder := newDecoder(config) + + var schemaVersion SchemaVersion + if err = decoder.Decode(&schemaVersion); err != nil { + return fmt.Errorf("failed to get schema version: %w", err) + } + + decoder = newDecoder(config) + + if schemaVersion.Version != 1 { + return fmt.Errorf("generator only supports version 1 schema, got %d", schemaVersion.Version) + } + + var defaultConfig SDKDefaultConfig + if err := decoder.Decode(&defaultConfig); err != nil { + return fmt.Errorf("failed to decode config: %w", err) + } + + oFile, err := os.OpenFile(outputFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) + if err != nil { + return fmt.Errorf("failed to open file: %w", err) + } + defer func() { + if cErr := oFile.Close(); cErr != nil && err == nil { + err = fmt.Errorf("failed to close file: %w", cErr) + } + }() + + configContent := bytes.NewBuffer(nil) + + data := &generationContext{ + PackageName: packageName, + ResolverName: resolverName, + Config: defaultConfig, + } + + if err := tmpl.ExecuteTemplate(configContent, "config", data); err != nil { + return fmt.Errorf("failed to execute template: %w", err) + } + + if err := tmpl.ExecuteTemplate(oFile, "header", data); err != nil { + return fmt.Errorf("failed to execute template: %w", err) + } + + if _, err := io.Copy(oFile, configContent); err != nil { + return fmt.Errorf("failed to copy to output file: %w", err) + } + + return nil +} + +func newDecoder(data []byte) *json.Decoder { + decoder := json.NewDecoder(bytes.NewReader(data)) + decoder.UseNumber() + return decoder +} diff --git a/internal/codegen/cmd/defaultsconfig/main.go b/internal/codegen/cmd/defaultsconfig/main.go new file mode 100644 index 00000000000..0299bda0489 --- /dev/null +++ b/internal/codegen/cmd/defaultsconfig/main.go @@ -0,0 +1,23 @@ +package main + +import ( + "flag" + "log" +) + +func main() { + jsonFile := flag.String("json", "", "The JSON defaults configuration file.") + outputFile := flag.String("output", "defaults.go", "The output filename.") + packageName := flag.String("p", "defaults", "The Go package name.") + resolverName := flag.String("r", "GetModeConfiguration", "The configuration resolver function name.") + flag.Parse() + + validateStringArgument(jsonFile, "-json file name is required") + validateStringArgument(outputFile, "-output file name is required") + validateStringArgument(packageName, "-p package name is required") + validateStringArgument(resolverName, "-r resolver name is required") + + if err := generateConfigPackage(*jsonFile, *outputFile, *packageName, *resolverName); err != nil { + log.Fatal(err) + } +} diff --git a/internal/codegen/cmd/defaultsconfig/v1.go b/internal/codegen/cmd/defaultsconfig/v1.go new file mode 100644 index 00000000000..d22d45880ac --- /dev/null +++ b/internal/codegen/cmd/defaultsconfig/v1.go @@ -0,0 +1,322 @@ +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "log" + "math/big" + "sort" + "strings" + "text/template" + + codegen "github.com/aws/aws-sdk-go-v2/internal/codegen/defaults" +) + +func renderPtrTimeMillisecond(context *generationContext, base interface{}, modifier Modifier) (string, error) { + context.AddImport("time", "") + + value, err := applyBaseModifier(base, modifier) + if err != nil { + return "", err + } + + i, ok := value.(int64) + if !ok { + return "", fmt.Errorf("expect int64, got %T", base) + } + + return fmt.Sprintf("aws.Duration(%d*time.Millisecond)", i), nil +} + +type ConfigurationValue struct { + FieldName string + Setter func(context *generationContext, base interface{}, modifier Modifier) (string, error) +} + +var supportedConfigKeys = map[string]ConfigurationValue{ + "connectTimeoutInMillis": { + FieldName: "ConnectTimeout", + Setter: renderPtrTimeMillisecond, + }, + "tlsNegotiationTimeoutInMillis": { + FieldName: "TLSNegotiationTimeout", + Setter: renderPtrTimeMillisecond, + }, +} + +// ModifierMap is a map of configuration keys to their respective modifier descriptor. +type ModifierMap map[string]Modifier + +// Modifier is a union type of either a multiply, add, or override modification descriptor. +type Modifier struct { + Multiply *json.Number + Add *int64 + Override interface{} +} + +// IsZero returns whether the type is the zero-value. +func (m *Modifier) IsZero() bool { + return m.Multiply == nil && + m.Add == nil && + m.Override == nil +} + +// UnmarshalJSON is a custom json.Unmarshaler that enforces a modifier unmarshas to a union and satisfies +// the appropriate type constraints. +func (m *Modifier) UnmarshalJSON(data []byte) error { + modifiers := make(map[string]interface{}) + + decoder := json.NewDecoder(bytes.NewReader(data)) + decoder.UseNumber() + + if err := decoder.Decode(&modifiers); err != nil { + return err + } + + if len(modifiers) != 1 { + return fmt.Errorf("expect one modifier key, got %d", len(modifiers)) + } + + var key string + for key = range modifiers { + } + + switch { + case strings.EqualFold(key, "multiply"): + var v json.Number + v, ok := modifiers[key].(json.Number) + if !ok { + return fmt.Errorf("expect %T, got %T", json.Number(""), v) + } + m.Multiply = &v + case strings.EqualFold(key, "add"): + v, ok := modifiers[key].(json.Number) + if !ok { + return fmt.Errorf("expect %T, got %T", json.Number(""), v) + } + i, err := numberToInt64(v) + if err != nil { + return fmt.Errorf("%s is not an int64", v.String()) + } + m.Add = &i + case strings.EqualFold(key, "override"): + switch v := modifiers[key].(type) { + case json.Number: + m.Override = v + case string: + m.Override = v + default: + return fmt.Errorf("expect JSON Number or String, got %T", v) + } + default: + return fmt.Errorf("unsupported modifier key: %s", key) + } + + return nil +} + +// BaseConfiguration is the set of configuration keys and their deserialized json value. +type BaseConfiguration map[string]interface{} + +// SchemaVersion is a versioned JSON document. +type SchemaVersion struct { + Version int `json:"version"` +} + +// SDKDefaultConfig is a default configuration descriptor. +type SDKDefaultConfig struct { + Base BaseConfiguration `json:"base"` + Modes map[string]ModifierMap `json:"modes"` + Documentation struct { + Modes map[string]string `json:"modes"` + Configuration map[string]string `json:"configuration"` + } `json:"documentation"` + + SchemaVersion +} + +func numberToBigFloat(value json.Number) (*big.Float, error) { + float, ok := (&big.Float{}).SetString(value.String()) + if !ok { + return nil, fmt.Errorf("failed to parse number") + } + return float, nil +} + +func numberToInt64(value json.Number) (int64, error) { + float, err := numberToBigFloat(value) + if err != nil { + return 0, err + } + if i, accuracy := float.Int64(); accuracy == big.Exact { + return i, nil + } + return 0, fmt.Errorf("failed to represent number as int64") +} + +func getModeConstant(v string) string { + return fmt.Sprintf("aws.%s", "DefaultsMode"+codegen.SymbolizeExport(v)) +} + +func isSupportedConfigKey(v string) (ok bool) { + _, ok = supportedConfigKeys[v] + return ok +} + +func getConfigKeyValue(v string) ConfigurationValue { + return supportedConfigKeys[v] +} + +func applyBaseModifier(base interface{}, modifier Modifier) (v interface{}, err error) { + switch bv := base.(type) { + case string: + bv, err = applyStringModifier(bv, modifier) + if err != nil { + return "", err + } + return bv, nil + case json.Number: + i, err := numberToInt64(bv) + if err != nil { + return "", err + } + i, err = applyInt64Modifier(i, modifier) + if err != nil { + return "", err + } + return i, nil + default: + return nil, fmt.Errorf("unexpected type %T", base) + } +} + +func isKeyInModifierMap(m ModifierMap, key string) bool { + _, ok := m[key] + return ok +} + +func renderImport(i Import) (string, error) { + if len(i.Package) == 0 { + return "", fmt.Errorf("invalid empty package import") + } + + if len(i.Alias) == 0 { + return fmt.Sprintf("%q", i.Package), nil + } + + return fmt.Sprintf("%s %q", i.Package, i.Alias), nil +} + +var tmpl = template.Must(template. + New("generate"). + Funcs(map[string]interface{}{ + "symbolizeExport": codegen.SymbolizeExport, + "isSupportedConfigKey": isSupportedConfigKey, + "getConfigKeyValue": getConfigKeyValue, + "isKeyInModifierMap": isKeyInModifierMap, + "getModeConstant": getModeConstant, + "renderImport": renderImport, + "listModes": func(v map[string]ModifierMap) string { + var modes []string + for mode := range v { + modes = append(modes, mode) + } + sort.Strings(modes) + return strings.Join(modes, ", ") + }, + }). + Parse(` +{{- define "header" -}} +// Code generated by github.com/aws/aws-sdk-go-v2/internal/codegen/cmd/defaultsconfig. DO NOT EDIT. + +package {{ $.PackageName }} + +import ( + {{- range $key, $_ := $.Imports }} + {{ renderImport $key }} + {{- end }} +) +{{ end -}} +{{- define "config" }} +{{- $.AddImport "fmt" "" -}} +{{- $.AddSDKImport "aws" "" -}} + +// {{ $.ResolverName }} returns the default Configuration descriptor for the given mode. +// +// Supports the following modes: {{ listModes $.Config.Modes }} +func {{ $.ResolverName }}(mode aws.DefaultsMode) (Configuration, error) { + var mv aws.DefaultsMode + mv.SetFromString(string(mode)) + + switch mv { + {{- range $mode, $modeModifiers := $.Config.Modes }} + case {{ getModeConstant $mode }}: + settings := Configuration{ + {{ range $key, $value := $.Config.Base }} + {{- if isSupportedConfigKey $key }} + {{- $configValue := (getConfigKeyValue $key) -}} + {{ $configValue.FieldName }}: {{ call $configValue.Setter $ $value (index $modeModifiers $key) }}, + {{ end -}} + {{- end }} + } + return settings, nil + {{- end }} + default: + return Configuration{}, fmt.Errorf("unsupported defaults mode: %v", mode) + } +} +{{ end }} +`)) + +func applyInt64Modifier(v int64, modifier Modifier) (int64, error) { + if modifier.IsZero() { + return v, nil + } + + if modifier.Override != nil { + jn, ok := modifier.Override.(json.Number) + if !ok { + return 0, fmt.Errorf("expect override to be JSON Number, got %T", modifier.Override) + } + i, err := numberToInt64(jn) + if err != nil { + return 0, err + } + return i, nil + } else if modifier.Add != nil { + return v + *modifier.Add, nil + } else if modifier.Multiply != nil { + fv, err := numberToBigFloat(*modifier.Multiply) + if err != nil { + return 0, err + } + fv = fv.Mul(fv, (&big.Float{}).SetInt64(v)) + if i, acc := fv.Int64(); acc == big.Exact { + return i, nil + } + return 0, fmt.Errorf("failed to compute an int64 using multiply modifier") + } + return 0, fmt.Errorf("unexpected modifier option") +} + +func applyStringModifier(s string, modifier Modifier) (string, error) { + if modifier.IsZero() { + return s, nil + } + + if modifier.Override == nil { + return "", fmt.Errorf("string only supports override modifier") + } + ov, ok := (modifier.Override).(string) + if !ok { + return "", fmt.Errorf("expect override value to be string") + } + return ov, nil +} + +func validateStringArgument(v *string, message string) { + if v == nil || len(*v) == 0 { + log.Fatal(message) + } +} diff --git a/internal/codegen/cmd/defaultsmode/main.go b/internal/codegen/cmd/defaultsmode/main.go new file mode 100644 index 00000000000..f0683d68c29 --- /dev/null +++ b/internal/codegen/cmd/defaultsmode/main.go @@ -0,0 +1,175 @@ +package main + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "io" + "io/ioutil" + "log" + "os" + "regexp" + "sort" + "text/template" + + codegen "github.com/aws/aws-sdk-go-v2/internal/codegen/defaults" +) + +var jsonFile string +var outputFile string +var outputPackage string + +func init() { + flag.StringVar(&jsonFile, "json", "", "The JSON defaults configuration file.") + flag.StringVar(&outputFile, "output", "defaults.go", "The output filename.") + flag.StringVar(&outputPackage, "package", "aws", "The output file package.") +} + +type Configuration struct { + Version int64 `json:"version"` + Modes map[string]struct{} `json:"modes"` + Documentation struct { + Modes map[string]string `json:"modes"` + } `json:"documentation"` +} + +var reFixDocLeadIn = regexp.MustCompile(`^

(?PThe \S+ mode)`) + +func main() { + flag.Parse() + + if len(jsonFile) == 0 || len(outputFile) == 0 { + log.Fatal("-json and -output arguments are required") + } + + jsonBytes, err := ioutil.ReadFile(jsonFile) + if err != nil { + log.Fatalf("failed to read json file: %v", err) + } + + var config Configuration + if err := json.Unmarshal(jsonBytes, &config); err != nil { + log.Fatalf("failed to unmarshal json: %v", err) + } + + for mode := range config.Documentation.Modes { + doc := config.Documentation.Modes[mode] + if reFixDocLeadIn.MatchString(doc) { + submatchIndex := reFixDocLeadIn.FindStringSubmatchIndex(doc) + doc = doc[:submatchIndex[2]] + modeConstant(mode) + doc[submatchIndex[3]:] + } + config.Documentation.Modes[mode] = doc + } + + var modes []string + for mode := range config.Modes { + modes = append(modes, mode) + } + + const legacyStr = "legacy" + if _, ok := config.Modes[legacyStr]; ok { + log.Fatalf("expect %s to not be defined", legacyStr) + } + modes = append(modes, legacyStr) + + const autoStr = "auto" + if _, ok := config.Modes[autoStr]; ok { + log.Fatalf("expect %s to not be defined", autoStr) + } + modes = append(modes, autoStr) + + sort.Strings(modes) + + buff := bytes.NewBuffer(nil) + + err = template.Must(template. + New("generate"). + Funcs(map[string]interface{}{ + "modeConstant": modeConstant, + "docify": func(v string) string { + return codegen.ToGoDoc(v) + }, + }). + Parse(` +{{- block "root" $ -}} +// Code generated by github.com/aws/aws-sdk-go-v2/internal/codegen/cmd/defaultsmode. DO NOT EDIT. + +package {{ $.PackageName }} + +import ( + "strings" +) + +// DefaultsMode is the SDK defaults mode setting. +type DefaultsMode string + +// The DefaultsMode constants. +const ( +{{- range $_, $mode := $.Modes }} + {{- $doc := (index $.Documentation $mode) }} + {{ docify $doc }} + {{ modeConstant $mode }} DefaultsMode = {{ printf "%q" $mode }} +{{ end }} +) + +// SetFromString sets the DefaultsMode value to one of the pre-defined constants that matches +// the provided string when compared using EqualFold. If the value does not match a known +// constant it will be set to as-is and the function will return false. As a special case, if the +// provided value is a zero-length string, the mode will be set to LegacyDefaultsMode. +func (d *DefaultsMode) SetFromString(v string) (ok bool) { + switch { + {{- range $_, $mode := $.Modes }} + case strings.EqualFold(v, string({{ modeConstant $mode }})): + *d = {{ modeConstant $mode }} + ok = true + {{- end }} + case len(v) == 0: + *d = {{ modeConstant "legacy" }} + ok = true + default: + *d = DefaultsMode(v) + } + return ok +} +{{- end }} +`)).Execute(buff, struct { + PackageName string + AliasTarget string + Modes []string + Documentation map[string]string + WithAutoMode bool + }{ + PackageName: outputPackage, + Modes: modes, + Documentation: config.Documentation.Modes, + }) + if err != nil { + log.Fatalf("failed to execute template: %v", err) + } + + if err := writeToFile(outputFile, buff); err != nil { + log.Fatalf("failed to write output file: %v", err) + } +} + +func modeConstant(v string) string { + return fmt.Sprintf("DefaultsMode%s", codegen.SymbolizeExport(v)) +} + +func writeToFile(fileName string, content io.Reader) (err error) { + var ow *os.File + ow, err = os.OpenFile(fileName, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) + if err != nil { + log.Fatalf("failed to open output file: %v", err) + } + defer func() { + if cErr := ow.Close(); err == nil && cErr != nil { + err = fmt.Errorf("failed to close output file: %v", err) + } + }() + + _, err = io.Copy(ow, content) + + return err +} diff --git a/internal/codegen/docstring.go b/internal/codegen/docstring.go new file mode 100644 index 00000000000..8a81794c81c --- /dev/null +++ b/internal/codegen/docstring.go @@ -0,0 +1,474 @@ +package codegen + +import ( + "bufio" + "fmt" + "html" + "io" + "regexp" + "strings" + + xhtml "golang.org/x/net/html" + "golang.org/x/net/html/atom" +) + +var reNewline = regexp.MustCompile(`\r?\n`) +var reMultiSpace = regexp.MustCompile(`\s+`) +var reComments = regexp.MustCompile(``) +var reFullnameBlock = regexp.MustCompile(`(.+?)<\/fullname>`) +var reFullname = regexp.MustCompile(`(.*?)`) +var reExamples = regexp.MustCompile(`.+?<\/examples?>`) +var reEndNL = regexp.MustCompile(`\n+$`) + +// ToGoDoc rewrites a string to insert godocs formatting. +func ToGoDoc(doc string) string { + doc = strings.TrimSpace(doc) + if doc == "" { + return "" + } + + doc = reNewline.ReplaceAllString(doc, "") + doc = reMultiSpace.ReplaceAllString(doc, " ") + doc = reComments.ReplaceAllString(doc, "") + + var fullname string + parts := reFullnameBlock.FindStringSubmatch(doc) + if len(parts) > 1 { + fullname = parts[1] + } + // Remove full name block from doc string + doc = reFullname.ReplaceAllString(doc, "") + + doc = reExamples.ReplaceAllString(doc, "") + doc = generateDoc(doc) + doc = reEndNL.ReplaceAllString(doc, "") + doc = html.UnescapeString(doc) + + // Replace doc with full name if doc is empty. + if len(doc) == 0 { + doc = fullname + } + + return commentify(doc) +} + +const ( + indent = " " +) + +// commentify converts a string to a Go comment +func commentify(doc string) string { + if len(doc) == 0 { + return "" + } + + lines := strings.Split(doc, "\n") + out := make([]string, 0, len(lines)) + for i := 0; i < len(lines); i++ { + line := lines[i] + + if i > 0 && line == "" && lines[i-1] == "" { + continue + } + out = append(out, line) + } + + if len(out) > 0 { + out[0] = "// " + out[0] + return strings.Join(out, "\n// ") + } + return "" +} + +func wrap(text string, length int) string { + var b strings.Builder + + s := bufio.NewScanner(strings.NewReader(text)) + for s.Scan() { + line := s.Text() + + // cleanup the line's spaces + var i int + for i = 0; i < len(line); i++ { + c := line[i] + // Ignore leading spaces, e.g indents. + if !(c == ' ' || c == '\t') { + break + } + } + line = line[:i] + strings.Join(strings.Fields(line[i:]), " ") + splitLine(&b, line, length) + } + + return strings.TrimRight(b.String(), "\n") +} + +func splitLine(w stringWriter, line string, length int) { + leading := getLeadingWhitespace(line) + + line = line[len(leading):] + length -= len(leading) + + const splitOn = " " + for len(line) > length { + // Find the next whitespace to the length + idx := strings.Index(line[length:], splitOn) + if idx == -1 { + break + } + offset := length + idx + + if v := line[offset+len(splitOn):]; len(v) == 1 && strings.ContainsAny(v, `,.!?'"`) { + // Workaround for long lines with space before the punctuation mark. + break + } + + w.WriteString(leading) + w.WriteString(line[:offset]) + w.WriteByte('\n') + line = strings.TrimLeft(line[offset+len(splitOn):], " \t") + } + + if len(line) > 0 { + w.WriteString(leading) + w.WriteString(line) + } + // Add the newline back in that was stripped out by scanner. + w.WriteByte('\n') +} + +func getLeadingWhitespace(v string) string { + var o strings.Builder + for _, c := range v { + if c == ' ' || c == '\t' { + o.WriteRune(c) + } else { + break + } + } + + return o.String() +} + +// generateDoc will generate the proper doc string for html encoded or plain text doc entries. +func generateDoc(htmlSrc string) string { + tokenizer := xhtml.NewTokenizer(strings.NewReader(htmlSrc)) + var builder strings.Builder + if err := encodeHTMLToText(&builder, tokenizer); err != nil { + panic(fmt.Sprintf("failed to generated docs, %v", err)) + } + + return wrap(strings.Trim(builder.String(), "\n"), 72) +} + +type stringWriter interface { + Write([]byte) (int, error) + WriteByte(byte) error + WriteRune(rune) (int, error) + WriteString(string) (int, error) +} + +func encodeHTMLToText(w stringWriter, z *xhtml.Tokenizer) error { + encoder := newHTMLTokenEncoder(w) + defer encoder.Flush() + + for { + tt := z.Next() + if tt == xhtml.ErrorToken { + if err := z.Err(); err == io.EOF { + return nil + } else if err != nil { + return err + } + } + + if err := encoder.Encode(z.Token()); err != nil { + return err + } + } +} + +type htmlTokenHandler interface { + OnStartTagToken(xhtml.Token) htmlTokenHandler + OnEndTagToken(xhtml.Token, bool) + OnSelfClosingTagToken(xhtml.Token) + OnTextTagToken(xhtml.Token) +} + +type htmlTokenEncoder struct { + w stringWriter + depth int + handlers []tokenHandlerItem + baseHandler tokenHandlerItem +} + +type tokenHandlerItem struct { + handler htmlTokenHandler + depth int +} + +func newHTMLTokenEncoder(w stringWriter) *htmlTokenEncoder { + baseHandler := newBlockTokenHandler(w) + baseHandler.rootBlock = true + + return &htmlTokenEncoder{ + w: w, + baseHandler: tokenHandlerItem{ + handler: baseHandler, + }, + } +} + +func (e *htmlTokenEncoder) Flush() error { + e.baseHandler.handler.OnEndTagToken(xhtml.Token{Type: xhtml.TextToken}, true) + return nil +} + +func (e *htmlTokenEncoder) Encode(token xhtml.Token) error { + h := e.baseHandler + if len(e.handlers) != 0 { + h = e.handlers[len(e.handlers)-1] + } + + switch token.Type { + case xhtml.StartTagToken: + e.depth++ + + next := h.handler.OnStartTagToken(token) + if next != nil { + e.handlers = append(e.handlers, tokenHandlerItem{ + handler: next, + depth: e.depth, + }) + } + + case xhtml.EndTagToken: + handlerBlockClosing := e.depth == h.depth + + h.handler.OnEndTagToken(token, handlerBlockClosing) + + // Remove all but the root handler as the handler is no longer needed. + if handlerBlockClosing { + e.handlers = e.handlers[:len(e.handlers)-1] + } + e.depth-- + + case xhtml.SelfClosingTagToken: + h.handler.OnSelfClosingTagToken(token) + + case xhtml.TextToken: + h.handler.OnTextTagToken(token) + } + + return nil +} + +type baseTokenHandler struct { + w stringWriter +} + +func (e *baseTokenHandler) OnStartTagToken(token xhtml.Token) htmlTokenHandler { return nil } +func (e *baseTokenHandler) OnEndTagToken(token xhtml.Token, blockClosing bool) {} +func (e *baseTokenHandler) OnSelfClosingTagToken(token xhtml.Token) {} +func (e *baseTokenHandler) OnTextTagToken(token xhtml.Token) { + e.w.WriteString(token.Data) +} + +type blockTokenHandler struct { + baseTokenHandler + + rootBlock bool + origWriter stringWriter + strBuilder *strings.Builder + + started bool + newlineBeforeNextBlock bool +} + +func newBlockTokenHandler(w stringWriter) *blockTokenHandler { + strBuilder := &strings.Builder{} + return &blockTokenHandler{ + origWriter: w, + strBuilder: strBuilder, + baseTokenHandler: baseTokenHandler{ + w: strBuilder, + }, + } +} +func (e *blockTokenHandler) OnStartTagToken(token xhtml.Token) htmlTokenHandler { + e.started = true + if e.newlineBeforeNextBlock { + e.w.WriteString("\n") + e.newlineBeforeNextBlock = false + } + + switch token.DataAtom { + case atom.A: + return newLinkTokenHandler(e.w, token) + case atom.Ul: + e.w.WriteString("\n") + e.newlineBeforeNextBlock = true + return newListTokenHandler(e.w) + + case atom.Div, atom.Dt, atom.P, atom.H1, atom.H2, atom.H3, atom.H4, atom.H5, atom.H6: + e.w.WriteString("\n") + e.newlineBeforeNextBlock = true + return newBlockTokenHandler(e.w) + + case atom.Pre, atom.Code: + if e.rootBlock { + e.w.WriteString("\n") + e.w.WriteString(indent) + e.newlineBeforeNextBlock = true + } + return newBlockTokenHandler(e.w) + } + + return nil +} +func (e *blockTokenHandler) OnEndTagToken(token xhtml.Token, blockClosing bool) { + if !blockClosing { + return + } + + e.origWriter.WriteString(e.strBuilder.String()) + if e.newlineBeforeNextBlock { + e.origWriter.WriteString("\n") + e.newlineBeforeNextBlock = false + } + + e.strBuilder.Reset() +} + +func (e *blockTokenHandler) OnTextTagToken(token xhtml.Token) { + if e.newlineBeforeNextBlock { + e.w.WriteString("\n") + e.newlineBeforeNextBlock = false + } + if !e.started { + token.Data = strings.TrimLeft(token.Data, " \t\n") + } + if len(token.Data) != 0 { + e.started = true + } + e.baseTokenHandler.OnTextTagToken(token) +} + +type linkTokenHandler struct { + baseTokenHandler + linkToken xhtml.Token +} + +func newLinkTokenHandler(w stringWriter, token xhtml.Token) *linkTokenHandler { + return &linkTokenHandler{ + baseTokenHandler: baseTokenHandler{ + w: w, + }, + linkToken: token, + } +} +func (e *linkTokenHandler) OnEndTagToken(token xhtml.Token, blockClosing bool) { + if !blockClosing { + return + } + + if href, ok := getHTMLTokenAttr(e.linkToken.Attr, "href"); ok && len(href) != 0 { + fmt.Fprintf(e.w, " (%s)", strings.TrimSpace(href)) + } +} + +type listTokenHandler struct { + baseTokenHandler + + items int +} + +func newListTokenHandler(w stringWriter) *listTokenHandler { + return &listTokenHandler{ + baseTokenHandler: baseTokenHandler{ + w: w, + }, + } +} +func (e *listTokenHandler) OnStartTagToken(token xhtml.Token) htmlTokenHandler { + switch token.DataAtom { + case atom.Li: + if e.items >= 1 { + e.w.WriteString("\n\n") + } + e.items++ + return newListItemTokenHandler(e.w) + } + return nil +} + +func (e *listTokenHandler) OnTextTagToken(token xhtml.Token) { + // Squash whitespace between list and items +} + +type listItemTokenHandler struct { + baseTokenHandler + + origWriter stringWriter + strBuilder *strings.Builder +} + +func newListItemTokenHandler(w stringWriter) *listItemTokenHandler { + strBuilder := &strings.Builder{} + return &listItemTokenHandler{ + origWriter: w, + strBuilder: strBuilder, + baseTokenHandler: baseTokenHandler{ + w: strBuilder, + }, + } +} +func (e *listItemTokenHandler) OnStartTagToken(token xhtml.Token) htmlTokenHandler { + switch token.DataAtom { + case atom.P: + return newBlockTokenHandler(e.w) + } + return nil +} +func (e *listItemTokenHandler) OnEndTagToken(token xhtml.Token, blockClosing bool) { + if !blockClosing { + return + } + + e.origWriter.WriteString(indent + "* ") + e.origWriter.WriteString(strings.TrimSpace(e.strBuilder.String())) +} + +type trimSpaceTokenHandler struct { + baseTokenHandler + + origWriter stringWriter + strBuilder *strings.Builder +} + +func newTrimSpaceTokenHandler(w stringWriter) *trimSpaceTokenHandler { + strBuilder := &strings.Builder{} + return &trimSpaceTokenHandler{ + origWriter: w, + strBuilder: strBuilder, + baseTokenHandler: baseTokenHandler{ + w: strBuilder, + }, + } +} +func (e *trimSpaceTokenHandler) OnEndTagToken(token xhtml.Token, blockClosing bool) { + if !blockClosing { + return + } + + e.origWriter.WriteString(strings.TrimSpace(e.strBuilder.String())) +} + +func getHTMLTokenAttr(attr []xhtml.Attribute, name string) (string, bool) { + for _, a := range attr { + if strings.EqualFold(a.Key, name) { + return a.Val, true + } + } + return "", false +} diff --git a/internal/codegen/generate_defaults.go b/internal/codegen/generate_defaults.go new file mode 100644 index 00000000000..922f412bc5f --- /dev/null +++ b/internal/codegen/generate_defaults.go @@ -0,0 +1,9 @@ +package codegen + +// defaults package +//go:generate go run ./cmd/defaultsconfig -json ./models/sdk-default-configuration.json -output=../../aws/defaults/defaults.go +//go:generate go run ./cmd/defaultsconfig -json ./models/testdata/sdk-default-configuration.json -output=../../aws/defaults/defaults_codegen_test.go -r v1TestResolver +//go:generate gofmt -s -w ../../aws/defaults/defaults.go ../../aws/defaults/defaults_codegen_test.go +// defaults mode constants +//go:generate go run ./cmd/defaultsmode -json ./models/sdk-default-configuration.json -output=../../aws/defaultsmode.go +//go:generate gofmt -s -w ../../aws/defaultsmode.go diff --git a/internal/codegen/go.mod b/internal/codegen/go.mod new file mode 100644 index 00000000000..8a2235c6e0c --- /dev/null +++ b/internal/codegen/go.mod @@ -0,0 +1,7 @@ +module github.com/aws/aws-sdk-go-v2/internal/codegen/defaults + +go 1.15 + +replace github.com/aws/aws-sdk-go-v2 => ../../ + +require golang.org/x/net v0.0.0-20220107192237-5cfca573fb4d diff --git a/internal/codegen/go.sum b/internal/codegen/go.sum new file mode 100644 index 00000000000..82091fc700c --- /dev/null +++ b/internal/codegen/go.sum @@ -0,0 +1,7 @@ +golang.org/x/net v0.0.0-20220107192237-5cfca573fb4d h1:62NvYBuaanGXR2ZOfwDFkhhl6X1DUgf8qg3GuQvxZsE= +golang.org/x/net v0.0.0-20220107192237-5cfca573fb4d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= diff --git a/internal/codegen/go_module_metadata.go b/internal/codegen/go_module_metadata.go new file mode 100644 index 00000000000..a6f21dd14e8 --- /dev/null +++ b/internal/codegen/go_module_metadata.go @@ -0,0 +1,6 @@ +// Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. + +package codegen + +// goModuleVersion is the tagged release for this module +const goModuleVersion = "tip" diff --git a/internal/codegen/models/sdk-default-configuration.json b/internal/codegen/models/sdk-default-configuration.json new file mode 100644 index 00000000000..3db13b26cc5 --- /dev/null +++ b/internal/codegen/models/sdk-default-configuration.json @@ -0,0 +1,55 @@ +{ + "version": 1, + "base": { + "retryMode": "standard", + "stsRegionalEndpoints": "regional", + "s3UsEast1RegionalEndpoints": "regional", + "connectTimeoutInMillis": 1100, + "tlsNegotiationTimeoutInMillis": 1100 + }, + "modes": { + "standard": { + "connectTimeoutInMillis": { + "override": 3100 + }, + "tlsNegotiationTimeoutInMillis": { + "override": 3100 + } + }, + "in-region": { + }, + "cross-region": { + "connectTimeoutInMillis": { + "override": 3100 + }, + "tlsNegotiationTimeoutInMillis": { + "override": 3100 + } + }, + "mobile": { + "connectTimeoutInMillis": { + "override": 30000 + }, + "tlsNegotiationTimeoutInMillis": { + "override": 30000 + } + } + }, + "documentation": { + "modes": { + "standard": "

The STANDARD mode provides the latest recommended default values that should be safe to run in most scenarios

Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK

", + "in-region": "

The IN_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services from within the same AWS region

Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK

", + "cross-region": "

The CROSS_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services in a different region

Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK

", + "mobile": "

The MOBILE mode builds on the standard mode and includes optimization tailored for mobile applications

Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK

", + "auto": "

The AUTO mode is an experimental mode that builds on the standard mode. The SDK will attempt to discover the execution environment to determine the appropriate settings automatically.

Note that the auto detection is heuristics-based and does not guarantee 100% accuracy. STANDARD mode will be used if the execution environment cannot be determined. The auto detection might query EC2 Instance Metadata service, which might introduce latency. Therefore we recommend choosing an explicit defaults_mode instead if startup latency is critical to your application

", + "legacy": "

The LEGACY mode provides default settings that vary per SDK and were used prior to establishment of defaults_mode

" + }, + "configuration": { + "retryMode": "

A retry mode specifies how the SDK attempts retries. See Retry Mode

", + "stsRegionalEndpoints": "

Specifies how the SDK determines the AWS service endpoint that it uses to talk to the AWS Security Token Service (AWS STS). See Setting STS Regional endpoints

", + "s3UsEast1RegionalEndpoints": "

Specifies how the SDK determines the AWS service endpoint that it uses to talk to the Amazon S3 for the us-east-1 region

", + "connectTimeoutInMillis": "

The amount of time after making an initial connection attempt on a socket, where if the client does not receive a completion of the connect handshake, the client gives up and fails the operation

", + "tlsNegotiationTimeoutInMillis": "

The maximum amount of time that a TLS handshake is allowed to take from the time the CLIENT HELLO message is sent to ethe time the client and server have fully negotiated ciphers and exchanged keys

" + } + } +} \ No newline at end of file diff --git a/internal/codegen/models/testdata/sdk-default-configuration.json b/internal/codegen/models/testdata/sdk-default-configuration.json new file mode 100644 index 00000000000..e658a823857 --- /dev/null +++ b/internal/codegen/models/testdata/sdk-default-configuration.json @@ -0,0 +1,64 @@ +{ + "version": 1, + "base": { + "retryMode": "standard", + "stsRegionalEndpoints": "regional", + "s3UsEast1RegionalEndpoints": "regional", + "connectTimeoutInMillis": 1000, + "tlsNegotiationTimeoutInMillis": 1000 + }, + "modes": { + "standard": { + "connectTimeoutInMillis": { + "multiply":2 + }, + "tlsNegotiationTimeoutInMillis": { + "multiply":2 + } + }, + "in-region": { + "connectTimeoutInMillis": { + "multiply": 1 + }, + "tlsNegotiationTimeoutInMillis": { + "multiply": 1 + } + }, + "cross-region": { + "connectTimeoutInMillis": { + "multiply": 2.8 + }, + "tlsNegotiationTimeoutInMillis": { + "multiply": 2.8 + } + }, + "mobile": { + "connectTimeoutInMillis": { + "override": 10000 + }, + "tlsNegotiationTimeoutInMillis": { + "add": 10000 + }, + "retryMode": { + "override": "adaptive" + } + } + }, + "documentation": { + "modes": { + "standard": "PLACEHOLDER", + "in-region": "PLACEHOLDER", + "cross-region": "PLACEHOLDER", + "mobile": "PLACEHOLDER", + "auto": "PLACEHOLDER", + "legacy": "PLACEHOLDER" + }, + "configuration": { + "retryMode": "PLACEHOLDER", + "stsRegionalEndpoints": "PLACEHOLDER", + "s3UsEast1RegionalEndpoints": "PLACEHOLDER", + "connectTimeoutInMillis": "PLACEHOLDER", + "tlsNegotiationTimeoutInMillis": "PLACEHOLDER" + } + } +} diff --git a/internal/codegen/symbols.go b/internal/codegen/symbols.go new file mode 100644 index 00000000000..5d0772aaf23 --- /dev/null +++ b/internal/codegen/symbols.go @@ -0,0 +1,9 @@ +package codegen + +import "strings" + +// SymbolizeExport takes an input value and symbolizes it for export. +func SymbolizeExport(v string) string { + v = strings.Replace(strings.Replace(v, "-", " ", -1), "_", " ", -1) + return strings.Replace(strings.Title(v), " ", "", -1) +} diff --git a/internal/configsources/configtesting/go.sum b/internal/configsources/configtesting/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/configsources/configtesting/go.sum +++ b/internal/configsources/configtesting/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/configsources/go.sum b/internal/configsources/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/configsources/go.sum +++ b/internal/configsources/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/endpoints/v2/go.mod b/internal/endpoints/v2/go.mod index 095abba3e7a..7d8f73179b3 100644 --- a/internal/endpoints/v2/go.mod +++ b/internal/endpoints/v2/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( github.com/aws/aws-sdk-go-v2 v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/endpoints/v2/go.sum b/internal/endpoints/v2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/endpoints/v2/go.sum +++ b/internal/endpoints/v2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/ini/go.sum b/internal/ini/go.sum index f7bd9b5b534..dc5136f5748 100644 --- a/internal/ini/go.sum +++ b/internal/ini/go.sum @@ -1,4 +1,4 @@ -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/internal/protocoltest/awsrestjson/api_client.go b/internal/protocoltest/awsrestjson/api_client.go index 9c9d18af79b..5275857b30c 100644 --- a/internal/protocoltest/awsrestjson/api_client.go +++ b/internal/protocoltest/awsrestjson/api_client.go @@ -5,7 +5,9 @@ package awsrestjson import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -39,6 +42,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -63,6 +68,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -83,9 +92,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -113,6 +135,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -165,11 +193,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -179,10 +209,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -210,6 +274,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "restjsonprotocol", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/internal/protocoltest/awsrestjson/go.mod b/internal/protocoltest/awsrestjson/go.mod index 7ca8f897011..8b5ec5ddf36 100644 --- a/internal/protocoltest/awsrestjson/go.mod +++ b/internal/protocoltest/awsrestjson/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/awsrestjson/go.sum b/internal/protocoltest/awsrestjson/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/awsrestjson/go.sum +++ b/internal/protocoltest/awsrestjson/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/ec2query/api_client.go b/internal/protocoltest/ec2query/api_client.go index d844b5d9eb6..268ca3de413 100644 --- a/internal/protocoltest/ec2query/api_client.go +++ b/internal/protocoltest/ec2query/api_client.go @@ -5,7 +5,9 @@ package ec2query import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -39,6 +42,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -63,6 +68,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -83,9 +92,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -113,6 +135,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -165,11 +193,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -179,10 +209,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -210,6 +274,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "ec2protocol", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/internal/protocoltest/ec2query/go.mod b/internal/protocoltest/ec2query/go.mod index 3622615459a..c56601084fd 100644 --- a/internal/protocoltest/ec2query/go.mod +++ b/internal/protocoltest/ec2query/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/ec2query/go.sum b/internal/protocoltest/ec2query/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/ec2query/go.sum +++ b/internal/protocoltest/ec2query/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/jsonrpc/api_client.go b/internal/protocoltest/jsonrpc/api_client.go index 106fb0677b1..61cee115041 100644 --- a/internal/protocoltest/jsonrpc/api_client.go +++ b/internal/protocoltest/jsonrpc/api_client.go @@ -4,7 +4,9 @@ package jsonrpc import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/internal/protocoltest/jsonrpc/go.mod b/internal/protocoltest/jsonrpc/go.mod index efbd4780cca..9de0e66da36 100644 --- a/internal/protocoltest/jsonrpc/go.mod +++ b/internal/protocoltest/jsonrpc/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/jsonrpc/go.sum b/internal/protocoltest/jsonrpc/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/jsonrpc/go.sum +++ b/internal/protocoltest/jsonrpc/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/jsonrpc10/api_client.go b/internal/protocoltest/jsonrpc10/api_client.go index 5179f18aa1c..19bf6a7bc02 100644 --- a/internal/protocoltest/jsonrpc10/api_client.go +++ b/internal/protocoltest/jsonrpc10/api_client.go @@ -4,7 +4,9 @@ package jsonrpc10 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -14,6 +16,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -37,6 +40,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -59,6 +64,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -75,9 +84,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -105,6 +127,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -157,11 +185,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -171,10 +201,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -202,6 +266,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "jsonrpc10", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/internal/protocoltest/jsonrpc10/go.mod b/internal/protocoltest/jsonrpc10/go.mod index 365e67ec44e..6de60ec471f 100644 --- a/internal/protocoltest/jsonrpc10/go.mod +++ b/internal/protocoltest/jsonrpc10/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/jsonrpc10/go.sum b/internal/protocoltest/jsonrpc10/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/jsonrpc10/go.sum +++ b/internal/protocoltest/jsonrpc10/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/query/api_client.go b/internal/protocoltest/query/api_client.go index c31a406a709..706780cfc38 100644 --- a/internal/protocoltest/query/api_client.go +++ b/internal/protocoltest/query/api_client.go @@ -5,7 +5,9 @@ package query import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -39,6 +42,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -63,6 +68,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -83,9 +92,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -113,6 +135,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -165,11 +193,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -179,10 +209,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -210,6 +274,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "queryprotocol", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/internal/protocoltest/query/go.mod b/internal/protocoltest/query/go.mod index 66a32a8e29f..21908f420e6 100644 --- a/internal/protocoltest/query/go.mod +++ b/internal/protocoltest/query/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/query/go.sum b/internal/protocoltest/query/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/query/go.sum +++ b/internal/protocoltest/query/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/restxml/api_client.go b/internal/protocoltest/restxml/api_client.go index f302d53aa9a..e69b9816a8e 100644 --- a/internal/protocoltest/restxml/api_client.go +++ b/internal/protocoltest/restxml/api_client.go @@ -5,7 +5,9 @@ package restxml import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -39,6 +42,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -63,6 +68,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -83,9 +92,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -113,6 +135,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -165,11 +193,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -179,10 +209,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -210,6 +274,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "restxmlprotocol", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/internal/protocoltest/restxml/go.mod b/internal/protocoltest/restxml/go.mod index 828fbf59c78..d32f2737ffc 100644 --- a/internal/protocoltest/restxml/go.mod +++ b/internal/protocoltest/restxml/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/restxml/go.sum b/internal/protocoltest/restxml/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/restxml/go.sum +++ b/internal/protocoltest/restxml/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/internal/protocoltest/restxmlwithnamespace/api_client.go b/internal/protocoltest/restxmlwithnamespace/api_client.go index 2e90b4d5219..b67d9b3149c 100644 --- a/internal/protocoltest/restxmlwithnamespace/api_client.go +++ b/internal/protocoltest/restxmlwithnamespace/api_client.go @@ -4,7 +4,9 @@ package restxmlwithnamespace import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" @@ -14,6 +16,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" ) @@ -37,6 +40,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPClient(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -59,6 +64,10 @@ type Options struct { // Configures the events that will be sent to the configured logger. ClientLogMode aws.ClientLogMode + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -75,9 +84,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -105,6 +127,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -157,11 +185,13 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -171,10 +201,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -202,6 +266,21 @@ func addClientUserAgent(stack *middleware.Stack) error { return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "restxmlprotocolnamespace", goModuleVersion)(stack) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/internal/protocoltest/restxmlwithnamespace/go.mod b/internal/protocoltest/restxmlwithnamespace/go.mod index 2063ca6b118..06760a057bb 100644 --- a/internal/protocoltest/restxmlwithnamespace/go.mod +++ b/internal/protocoltest/restxmlwithnamespace/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/internal/protocoltest/restxmlwithnamespace/go.sum b/internal/protocoltest/restxmlwithnamespace/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/internal/protocoltest/restxmlwithnamespace/go.sum +++ b/internal/protocoltest/restxmlwithnamespace/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/modman.toml b/modman.toml index 353085ff295..153f3ff4e68 100644 --- a/modman.toml +++ b/modman.toml @@ -1,6 +1,6 @@ [dependencies] - "github.com/aws/smithy-go" = "v1.9.1" + "github.com/aws/smithy-go" = "v1.9.2-0.20220113020543-dec09760da63" "github.com/google/go-cmp" = "v0.5.6" "github.com/jmespath/go-jmespath" = "v0.4.0" "golang.org/x/net" = "v0.0.0-20211209124913-491a49abca63" diff --git a/service/accessanalyzer/api_client.go b/service/accessanalyzer/api_client.go index 44a3ab0c94d..5a17398e440 100644 --- a/service/accessanalyzer/api_client.go +++ b/service/accessanalyzer/api_client.go @@ -5,7 +5,9 @@ package accessanalyzer import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/accessanalyzer/go.mod b/service/accessanalyzer/go.mod index f1d404a4493..325f6f423e7 100644 --- a/service/accessanalyzer/go.mod +++ b/service/accessanalyzer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/accessanalyzer/go.sum b/service/accessanalyzer/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/accessanalyzer/go.sum +++ b/service/accessanalyzer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/account/api_client.go b/service/account/api_client.go index a0897068f39..b7d343b4ccb 100644 --- a/service/account/api_client.go +++ b/service/account/api_client.go @@ -4,7 +4,9 @@ package account import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/account/go.mod b/service/account/go.mod index a29d528e6a6..7f2cc81002b 100644 --- a/service/account/go.mod +++ b/service/account/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/account/go.sum b/service/account/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/account/go.sum +++ b/service/account/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/acm/api_client.go b/service/acm/api_client.go index c0a80409b38..dcdaea161c5 100644 --- a/service/acm/api_client.go +++ b/service/acm/api_client.go @@ -4,7 +4,9 @@ package acm import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/acm/go.mod b/service/acm/go.mod index 9867b4e8335..2ac11f9b7cc 100644 --- a/service/acm/go.mod +++ b/service/acm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/acm/go.sum b/service/acm/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/acm/go.sum +++ b/service/acm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/acmpca/api_client.go b/service/acmpca/api_client.go index c913621ef75..ad15391ca96 100644 --- a/service/acmpca/api_client.go +++ b/service/acmpca/api_client.go @@ -4,7 +4,9 @@ package acmpca import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/acmpca/go.mod b/service/acmpca/go.mod index 0f16def5ebc..3594fbb907d 100644 --- a/service/acmpca/go.mod +++ b/service/acmpca/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/acmpca/go.sum b/service/acmpca/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/acmpca/go.sum +++ b/service/acmpca/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/alexaforbusiness/api_client.go b/service/alexaforbusiness/api_client.go index cb345b016b9..ad9bce2e2d3 100644 --- a/service/alexaforbusiness/api_client.go +++ b/service/alexaforbusiness/api_client.go @@ -5,7 +5,9 @@ package alexaforbusiness import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/alexaforbusiness/go.mod b/service/alexaforbusiness/go.mod index e6996068034..889b18ec29e 100644 --- a/service/alexaforbusiness/go.mod +++ b/service/alexaforbusiness/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/alexaforbusiness/go.sum b/service/alexaforbusiness/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/alexaforbusiness/go.sum +++ b/service/alexaforbusiness/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/amp/api_client.go b/service/amp/api_client.go index 570186959c0..eaf681092c1 100644 --- a/service/amp/api_client.go +++ b/service/amp/api_client.go @@ -5,7 +5,9 @@ package amp import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/amp/go.mod b/service/amp/go.mod index 5df20799aee..8060a36270c 100644 --- a/service/amp/go.mod +++ b/service/amp/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/amp/go.sum b/service/amp/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/amp/go.sum +++ b/service/amp/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/amplify/api_client.go b/service/amplify/api_client.go index b3b7820d6d0..549dc391eab 100644 --- a/service/amplify/api_client.go +++ b/service/amplify/api_client.go @@ -4,7 +4,9 @@ package amplify import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/amplify/go.mod b/service/amplify/go.mod index 114f60189fc..6553ca86dfe 100644 --- a/service/amplify/go.mod +++ b/service/amplify/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/amplify/go.sum b/service/amplify/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/amplify/go.sum +++ b/service/amplify/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/amplifybackend/api_client.go b/service/amplifybackend/api_client.go index 7f4e7c0d945..94763a425e4 100644 --- a/service/amplifybackend/api_client.go +++ b/service/amplifybackend/api_client.go @@ -4,7 +4,9 @@ package amplifybackend import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/amplifybackend/go.mod b/service/amplifybackend/go.mod index 52efe0c88c3..cac9e2ffb09 100644 --- a/service/amplifybackend/go.mod +++ b/service/amplifybackend/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/amplifybackend/go.sum b/service/amplifybackend/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/amplifybackend/go.sum +++ b/service/amplifybackend/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/amplifyuibuilder/api_client.go b/service/amplifyuibuilder/api_client.go index 9d09abc3ddf..5b3f2f40ee5 100644 --- a/service/amplifyuibuilder/api_client.go +++ b/service/amplifyuibuilder/api_client.go @@ -5,7 +5,9 @@ package amplifyuibuilder import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/amplifyuibuilder/go.mod b/service/amplifyuibuilder/go.mod index afccf5b6079..563d1f48607 100644 --- a/service/amplifyuibuilder/go.mod +++ b/service/amplifyuibuilder/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/amplifyuibuilder/go.sum b/service/amplifyuibuilder/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/amplifyuibuilder/go.sum +++ b/service/amplifyuibuilder/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/apigateway/api_client.go b/service/apigateway/api_client.go index ac94db1a410..76ac0c9de76 100644 --- a/service/apigateway/api_client.go +++ b/service/apigateway/api_client.go @@ -4,7 +4,9 @@ package apigateway import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/apigateway/go.mod b/service/apigateway/go.mod index 85afeebdde5..0c6e71e3c19 100644 --- a/service/apigateway/go.mod +++ b/service/apigateway/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/apigateway/go.sum b/service/apigateway/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/apigateway/go.sum +++ b/service/apigateway/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/apigatewaymanagementapi/api_client.go b/service/apigatewaymanagementapi/api_client.go index 1ef14f6451f..85a4a55326c 100644 --- a/service/apigatewaymanagementapi/api_client.go +++ b/service/apigatewaymanagementapi/api_client.go @@ -4,7 +4,9 @@ package apigatewaymanagementapi import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/apigatewaymanagementapi/go.mod b/service/apigatewaymanagementapi/go.mod index 1c88408c3b5..995eea0fd7f 100644 --- a/service/apigatewaymanagementapi/go.mod +++ b/service/apigatewaymanagementapi/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/apigatewaymanagementapi/go.sum b/service/apigatewaymanagementapi/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/apigatewaymanagementapi/go.sum +++ b/service/apigatewaymanagementapi/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/apigatewayv2/api_client.go b/service/apigatewayv2/api_client.go index 9256661e8e2..9da6ecc4fa2 100644 --- a/service/apigatewayv2/api_client.go +++ b/service/apigatewayv2/api_client.go @@ -4,7 +4,9 @@ package apigatewayv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/apigatewayv2/go.mod b/service/apigatewayv2/go.mod index 3c86ea58f85..beda50a44ed 100644 --- a/service/apigatewayv2/go.mod +++ b/service/apigatewayv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/apigatewayv2/go.sum b/service/apigatewayv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/apigatewayv2/go.sum +++ b/service/apigatewayv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appconfig/api_client.go b/service/appconfig/api_client.go index c4c2283e37a..21c43845637 100644 --- a/service/appconfig/api_client.go +++ b/service/appconfig/api_client.go @@ -4,7 +4,9 @@ package appconfig import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/appconfig/go.mod b/service/appconfig/go.mod index 423ac5a6536..25225a63342 100644 --- a/service/appconfig/go.mod +++ b/service/appconfig/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appconfig/go.sum b/service/appconfig/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appconfig/go.sum +++ b/service/appconfig/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appconfigdata/api_client.go b/service/appconfigdata/api_client.go index 9d913425dc6..50403fcad49 100644 --- a/service/appconfigdata/api_client.go +++ b/service/appconfigdata/api_client.go @@ -4,7 +4,9 @@ package appconfigdata import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/appconfigdata/go.mod b/service/appconfigdata/go.mod index bc0e71f80dc..463998d619d 100644 --- a/service/appconfigdata/go.mod +++ b/service/appconfigdata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appconfigdata/go.sum b/service/appconfigdata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appconfigdata/go.sum +++ b/service/appconfigdata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appflow/api_client.go b/service/appflow/api_client.go index 0ec64afa024..f00435e2268 100644 --- a/service/appflow/api_client.go +++ b/service/appflow/api_client.go @@ -4,7 +4,9 @@ package appflow import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/appflow/go.mod b/service/appflow/go.mod index 9a3164492ad..4d3735c2b1c 100644 --- a/service/appflow/go.mod +++ b/service/appflow/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appflow/go.sum b/service/appflow/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appflow/go.sum +++ b/service/appflow/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appintegrations/api_client.go b/service/appintegrations/api_client.go index f4ae9bb710d..9c55300e3f4 100644 --- a/service/appintegrations/api_client.go +++ b/service/appintegrations/api_client.go @@ -5,7 +5,9 @@ package appintegrations import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/appintegrations/go.mod b/service/appintegrations/go.mod index 53e9882ea8a..59c62e93300 100644 --- a/service/appintegrations/go.mod +++ b/service/appintegrations/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appintegrations/go.sum b/service/appintegrations/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appintegrations/go.sum +++ b/service/appintegrations/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/applicationautoscaling/api_client.go b/service/applicationautoscaling/api_client.go index e87573caadc..92cbbc0777d 100644 --- a/service/applicationautoscaling/api_client.go +++ b/service/applicationautoscaling/api_client.go @@ -4,7 +4,9 @@ package applicationautoscaling import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/applicationautoscaling/go.mod b/service/applicationautoscaling/go.mod index bc33160e8b5..52329c244e2 100644 --- a/service/applicationautoscaling/go.mod +++ b/service/applicationautoscaling/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/applicationautoscaling/go.sum b/service/applicationautoscaling/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/applicationautoscaling/go.sum +++ b/service/applicationautoscaling/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/applicationcostprofiler/api_client.go b/service/applicationcostprofiler/api_client.go index 5a5297b960b..21b49ef3247 100644 --- a/service/applicationcostprofiler/api_client.go +++ b/service/applicationcostprofiler/api_client.go @@ -4,7 +4,9 @@ package applicationcostprofiler import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/applicationcostprofiler/go.mod b/service/applicationcostprofiler/go.mod index 7161a783f73..2b6ac75d594 100644 --- a/service/applicationcostprofiler/go.mod +++ b/service/applicationcostprofiler/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/applicationcostprofiler/go.sum b/service/applicationcostprofiler/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/applicationcostprofiler/go.sum +++ b/service/applicationcostprofiler/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/applicationdiscoveryservice/api_client.go b/service/applicationdiscoveryservice/api_client.go index 0a8000caf0e..759448dde86 100644 --- a/service/applicationdiscoveryservice/api_client.go +++ b/service/applicationdiscoveryservice/api_client.go @@ -5,7 +5,9 @@ package applicationdiscoveryservice import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/applicationdiscoveryservice/go.mod b/service/applicationdiscoveryservice/go.mod index f713981ea79..b2e96a59e9e 100644 --- a/service/applicationdiscoveryservice/go.mod +++ b/service/applicationdiscoveryservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/applicationdiscoveryservice/go.sum b/service/applicationdiscoveryservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/applicationdiscoveryservice/go.sum +++ b/service/applicationdiscoveryservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/applicationinsights/api_client.go b/service/applicationinsights/api_client.go index 821f8d47227..559cf31e3fa 100644 --- a/service/applicationinsights/api_client.go +++ b/service/applicationinsights/api_client.go @@ -4,7 +4,9 @@ package applicationinsights import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/applicationinsights/go.mod b/service/applicationinsights/go.mod index 97ad9e14053..d9db4e6fe48 100644 --- a/service/applicationinsights/go.mod +++ b/service/applicationinsights/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/applicationinsights/go.sum b/service/applicationinsights/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/applicationinsights/go.sum +++ b/service/applicationinsights/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appmesh/api_client.go b/service/appmesh/api_client.go index 0a27789e847..6d66b15d316 100644 --- a/service/appmesh/api_client.go +++ b/service/appmesh/api_client.go @@ -5,7 +5,9 @@ package appmesh import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/appmesh/go.mod b/service/appmesh/go.mod index 37326255d58..fd948f089a3 100644 --- a/service/appmesh/go.mod +++ b/service/appmesh/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appmesh/go.sum b/service/appmesh/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appmesh/go.sum +++ b/service/appmesh/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/apprunner/api_client.go b/service/apprunner/api_client.go index aa9ede04fc8..9844a249c44 100644 --- a/service/apprunner/api_client.go +++ b/service/apprunner/api_client.go @@ -4,7 +4,9 @@ package apprunner import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/apprunner/go.mod b/service/apprunner/go.mod index 2badb5573a3..83eecc0d376 100644 --- a/service/apprunner/go.mod +++ b/service/apprunner/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/apprunner/go.sum b/service/apprunner/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/apprunner/go.sum +++ b/service/apprunner/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/appstream/api_client.go b/service/appstream/api_client.go index 5e7d2d8dcde..2dab922262b 100644 --- a/service/appstream/api_client.go +++ b/service/appstream/api_client.go @@ -4,7 +4,9 @@ package appstream import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/appstream/go.mod b/service/appstream/go.mod index b0f995336d8..d4a6f1696db 100644 --- a/service/appstream/go.mod +++ b/service/appstream/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/appstream/go.sum b/service/appstream/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/appstream/go.sum +++ b/service/appstream/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/appsync/api_client.go b/service/appsync/api_client.go index e176d389875..de65d1cdfd6 100644 --- a/service/appsync/api_client.go +++ b/service/appsync/api_client.go @@ -4,7 +4,9 @@ package appsync import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/appsync/go.mod b/service/appsync/go.mod index 82a96615ac2..109074c85b7 100644 --- a/service/appsync/go.mod +++ b/service/appsync/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/appsync/go.sum b/service/appsync/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/appsync/go.sum +++ b/service/appsync/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/athena/api_client.go b/service/athena/api_client.go index 91212217814..900c8ee47b6 100644 --- a/service/athena/api_client.go +++ b/service/athena/api_client.go @@ -5,7 +5,9 @@ package athena import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/athena/go.mod b/service/athena/go.mod index 24a65ffa951..c2198805e25 100644 --- a/service/athena/go.mod +++ b/service/athena/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/athena/go.sum b/service/athena/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/athena/go.sum +++ b/service/athena/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/auditmanager/api_client.go b/service/auditmanager/api_client.go index 29fcebe863a..a611703bb59 100644 --- a/service/auditmanager/api_client.go +++ b/service/auditmanager/api_client.go @@ -4,7 +4,9 @@ package auditmanager import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/auditmanager/go.mod b/service/auditmanager/go.mod index 967d4cb5488..bad81cd15c9 100644 --- a/service/auditmanager/go.mod +++ b/service/auditmanager/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/auditmanager/go.sum b/service/auditmanager/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/auditmanager/go.sum +++ b/service/auditmanager/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/autoscaling/api_client.go b/service/autoscaling/api_client.go index dcff6e8b9ec..1a11ea482b7 100644 --- a/service/autoscaling/api_client.go +++ b/service/autoscaling/api_client.go @@ -4,7 +4,9 @@ package autoscaling import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/autoscaling/go.mod b/service/autoscaling/go.mod index a6db5caec4d..4e2c36eb64b 100644 --- a/service/autoscaling/go.mod +++ b/service/autoscaling/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/autoscaling/go.sum b/service/autoscaling/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/autoscaling/go.sum +++ b/service/autoscaling/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/autoscalingplans/api_client.go b/service/autoscalingplans/api_client.go index eb7748a7370..b991b9ea9b7 100644 --- a/service/autoscalingplans/api_client.go +++ b/service/autoscalingplans/api_client.go @@ -4,7 +4,9 @@ package autoscalingplans import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/autoscalingplans/go.mod b/service/autoscalingplans/go.mod index 1894375b8be..d32913bcde7 100644 --- a/service/autoscalingplans/go.mod +++ b/service/autoscalingplans/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/autoscalingplans/go.sum b/service/autoscalingplans/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/autoscalingplans/go.sum +++ b/service/autoscalingplans/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/backup/api_client.go b/service/backup/api_client.go index e612eceabf7..dceb0ffb958 100644 --- a/service/backup/api_client.go +++ b/service/backup/api_client.go @@ -5,7 +5,9 @@ package backup import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/backup/go.mod b/service/backup/go.mod index 984c73c5073..ebe9a0e690a 100644 --- a/service/backup/go.mod +++ b/service/backup/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/backup/go.sum b/service/backup/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/backup/go.sum +++ b/service/backup/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/backupgateway/api_client.go b/service/backupgateway/api_client.go index 57e3484333e..6b32ffce04b 100644 --- a/service/backupgateway/api_client.go +++ b/service/backupgateway/api_client.go @@ -4,7 +4,9 @@ package backupgateway import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/backupgateway/go.mod b/service/backupgateway/go.mod index 2ba024f213b..e0c5263ccca 100644 --- a/service/backupgateway/go.mod +++ b/service/backupgateway/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/backupgateway/go.sum b/service/backupgateway/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/backupgateway/go.sum +++ b/service/backupgateway/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/batch/api_client.go b/service/batch/api_client.go index a72364711b4..22396756e48 100644 --- a/service/batch/api_client.go +++ b/service/batch/api_client.go @@ -4,7 +4,9 @@ package batch import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/batch/go.mod b/service/batch/go.mod index 68a397a20fe..3afb1a5e3ad 100644 --- a/service/batch/go.mod +++ b/service/batch/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/batch/go.sum b/service/batch/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/batch/go.sum +++ b/service/batch/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/braket/api_client.go b/service/braket/api_client.go index 8015f508356..2394ef04576 100644 --- a/service/braket/api_client.go +++ b/service/braket/api_client.go @@ -5,7 +5,9 @@ package braket import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/braket/go.mod b/service/braket/go.mod index 4b995bb7212..5b4d73fd367 100644 --- a/service/braket/go.mod +++ b/service/braket/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/braket/go.sum b/service/braket/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/braket/go.sum +++ b/service/braket/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/budgets/api_client.go b/service/budgets/api_client.go index 61d8114f547..dfe314eb31d 100644 --- a/service/budgets/api_client.go +++ b/service/budgets/api_client.go @@ -4,7 +4,9 @@ package budgets import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/budgets/go.mod b/service/budgets/go.mod index 8f47f5818e2..9c5039e42c7 100644 --- a/service/budgets/go.mod +++ b/service/budgets/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/budgets/go.sum b/service/budgets/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/budgets/go.sum +++ b/service/budgets/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/chime/api_client.go b/service/chime/api_client.go index 3c557703877..b62a3d36a13 100644 --- a/service/chime/api_client.go +++ b/service/chime/api_client.go @@ -5,7 +5,9 @@ package chime import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/chime/go.mod b/service/chime/go.mod index 03e61d0368e..49c5a969df4 100644 --- a/service/chime/go.mod +++ b/service/chime/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/chime/go.sum b/service/chime/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/chime/go.sum +++ b/service/chime/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/chimesdkidentity/api_client.go b/service/chimesdkidentity/api_client.go index 311800a5333..2434812e54b 100644 --- a/service/chimesdkidentity/api_client.go +++ b/service/chimesdkidentity/api_client.go @@ -5,7 +5,9 @@ package chimesdkidentity import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/chimesdkidentity/go.mod b/service/chimesdkidentity/go.mod index 3d58dc020ea..ad9a442a080 100644 --- a/service/chimesdkidentity/go.mod +++ b/service/chimesdkidentity/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/chimesdkidentity/go.sum b/service/chimesdkidentity/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/chimesdkidentity/go.sum +++ b/service/chimesdkidentity/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/chimesdkmeetings/api_client.go b/service/chimesdkmeetings/api_client.go index a389ca3de85..be296967f54 100644 --- a/service/chimesdkmeetings/api_client.go +++ b/service/chimesdkmeetings/api_client.go @@ -5,7 +5,9 @@ package chimesdkmeetings import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/chimesdkmeetings/go.mod b/service/chimesdkmeetings/go.mod index 5f35bdee92c..fd1639425e8 100644 --- a/service/chimesdkmeetings/go.mod +++ b/service/chimesdkmeetings/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/chimesdkmeetings/go.sum b/service/chimesdkmeetings/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/chimesdkmeetings/go.sum +++ b/service/chimesdkmeetings/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/chimesdkmessaging/api_client.go b/service/chimesdkmessaging/api_client.go index 076ee61fdcc..2bd8fe1eeb0 100644 --- a/service/chimesdkmessaging/api_client.go +++ b/service/chimesdkmessaging/api_client.go @@ -5,7 +5,9 @@ package chimesdkmessaging import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/chimesdkmessaging/go.mod b/service/chimesdkmessaging/go.mod index 9baa1eca726..962e379d330 100644 --- a/service/chimesdkmessaging/go.mod +++ b/service/chimesdkmessaging/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/chimesdkmessaging/go.sum b/service/chimesdkmessaging/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/chimesdkmessaging/go.sum +++ b/service/chimesdkmessaging/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloud9/api_client.go b/service/cloud9/api_client.go index d7d60ea97a6..1ad1b6b7bd1 100644 --- a/service/cloud9/api_client.go +++ b/service/cloud9/api_client.go @@ -4,7 +4,9 @@ package cloud9 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloud9/go.mod b/service/cloud9/go.mod index b5e2c1c0ce3..03638dbc4ff 100644 --- a/service/cloud9/go.mod +++ b/service/cloud9/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloud9/go.sum b/service/cloud9/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloud9/go.sum +++ b/service/cloud9/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudcontrol/api_client.go b/service/cloudcontrol/api_client.go index f8c3012adbd..631182e2a31 100644 --- a/service/cloudcontrol/api_client.go +++ b/service/cloudcontrol/api_client.go @@ -5,7 +5,9 @@ package cloudcontrol import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/cloudcontrol/go.mod b/service/cloudcontrol/go.mod index c54d320ba4a..e8800fd7f61 100644 --- a/service/cloudcontrol/go.mod +++ b/service/cloudcontrol/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/cloudcontrol/go.sum b/service/cloudcontrol/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/cloudcontrol/go.sum +++ b/service/cloudcontrol/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/clouddirectory/api_client.go b/service/clouddirectory/api_client.go index 7817f013f4c..526f55aef94 100644 --- a/service/clouddirectory/api_client.go +++ b/service/clouddirectory/api_client.go @@ -4,7 +4,9 @@ package clouddirectory import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/clouddirectory/go.mod b/service/clouddirectory/go.mod index 1c5aac4f4ff..e34013a395e 100644 --- a/service/clouddirectory/go.mod +++ b/service/clouddirectory/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/clouddirectory/go.sum b/service/clouddirectory/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/clouddirectory/go.sum +++ b/service/clouddirectory/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudformation/api_client.go b/service/cloudformation/api_client.go index ff3df5de72c..2e86fb0a387 100644 --- a/service/cloudformation/api_client.go +++ b/service/cloudformation/api_client.go @@ -5,7 +5,9 @@ package cloudformation import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/cloudformation/go.mod b/service/cloudformation/go.mod index 223ad039096..7ab579215aa 100644 --- a/service/cloudformation/go.mod +++ b/service/cloudformation/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/cloudformation/go.sum b/service/cloudformation/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/cloudformation/go.sum +++ b/service/cloudformation/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/cloudfront/api_client.go b/service/cloudfront/api_client.go index bdabcd0a6fc..9fcb205776a 100644 --- a/service/cloudfront/api_client.go +++ b/service/cloudfront/api_client.go @@ -4,7 +4,9 @@ package cloudfront import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudfront/go.mod b/service/cloudfront/go.mod index 84a15d84bc2..4f642df1fe7 100644 --- a/service/cloudfront/go.mod +++ b/service/cloudfront/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/cloudfront/go.sum b/service/cloudfront/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/cloudfront/go.sum +++ b/service/cloudfront/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/cloudhsm/api_client.go b/service/cloudhsm/api_client.go index ae1ade94c7f..b4cf606e4fc 100644 --- a/service/cloudhsm/api_client.go +++ b/service/cloudhsm/api_client.go @@ -4,7 +4,9 @@ package cloudhsm import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudhsm/go.mod b/service/cloudhsm/go.mod index 12e03b92536..c7ba51eb7f9 100644 --- a/service/cloudhsm/go.mod +++ b/service/cloudhsm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudhsm/go.sum b/service/cloudhsm/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudhsm/go.sum +++ b/service/cloudhsm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudhsmv2/api_client.go b/service/cloudhsmv2/api_client.go index 1b540d7e85e..08b32c2c6e7 100644 --- a/service/cloudhsmv2/api_client.go +++ b/service/cloudhsmv2/api_client.go @@ -4,7 +4,9 @@ package cloudhsmv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudhsmv2/go.mod b/service/cloudhsmv2/go.mod index 5c4197ef3a3..633d6c2e7c8 100644 --- a/service/cloudhsmv2/go.mod +++ b/service/cloudhsmv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudhsmv2/go.sum b/service/cloudhsmv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudhsmv2/go.sum +++ b/service/cloudhsmv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudsearch/api_client.go b/service/cloudsearch/api_client.go index 9138e32da6a..e08b5cbae87 100644 --- a/service/cloudsearch/api_client.go +++ b/service/cloudsearch/api_client.go @@ -4,7 +4,9 @@ package cloudsearch import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudsearch/go.mod b/service/cloudsearch/go.mod index e6c21e969c8..1206d0cf2b6 100644 --- a/service/cloudsearch/go.mod +++ b/service/cloudsearch/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudsearch/go.sum b/service/cloudsearch/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudsearch/go.sum +++ b/service/cloudsearch/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudsearchdomain/api_client.go b/service/cloudsearchdomain/api_client.go index fe20221e480..6f6c5b1729d 100644 --- a/service/cloudsearchdomain/api_client.go +++ b/service/cloudsearchdomain/api_client.go @@ -4,7 +4,9 @@ package cloudsearchdomain import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudsearchdomain/go.mod b/service/cloudsearchdomain/go.mod index 86e3968d496..88852e754c7 100644 --- a/service/cloudsearchdomain/go.mod +++ b/service/cloudsearchdomain/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudsearchdomain/go.sum b/service/cloudsearchdomain/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudsearchdomain/go.sum +++ b/service/cloudsearchdomain/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudtrail/api_client.go b/service/cloudtrail/api_client.go index 22dcd7fc398..5619367922d 100644 --- a/service/cloudtrail/api_client.go +++ b/service/cloudtrail/api_client.go @@ -4,7 +4,9 @@ package cloudtrail import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudtrail/go.mod b/service/cloudtrail/go.mod index 8c5f235f734..b66f2fd2a17 100644 --- a/service/cloudtrail/go.mod +++ b/service/cloudtrail/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudtrail/go.sum b/service/cloudtrail/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudtrail/go.sum +++ b/service/cloudtrail/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudwatch/api_client.go b/service/cloudwatch/api_client.go index 8e66303ae92..ccc1cace293 100644 --- a/service/cloudwatch/api_client.go +++ b/service/cloudwatch/api_client.go @@ -4,7 +4,9 @@ package cloudwatch import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudwatch/go.mod b/service/cloudwatch/go.mod index 608dcabcaca..024521b2fd5 100644 --- a/service/cloudwatch/go.mod +++ b/service/cloudwatch/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/cloudwatch/go.sum b/service/cloudwatch/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/cloudwatch/go.sum +++ b/service/cloudwatch/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/cloudwatchevents/api_client.go b/service/cloudwatchevents/api_client.go index be1d80022f4..5663a03e9b2 100644 --- a/service/cloudwatchevents/api_client.go +++ b/service/cloudwatchevents/api_client.go @@ -4,7 +4,9 @@ package cloudwatchevents import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudwatchevents/go.mod b/service/cloudwatchevents/go.mod index 12c94035749..a002c24b201 100644 --- a/service/cloudwatchevents/go.mod +++ b/service/cloudwatchevents/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudwatchevents/go.sum b/service/cloudwatchevents/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudwatchevents/go.sum +++ b/service/cloudwatchevents/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cloudwatchlogs/api_client.go b/service/cloudwatchlogs/api_client.go index 768ac315da9..5071eb03550 100644 --- a/service/cloudwatchlogs/api_client.go +++ b/service/cloudwatchlogs/api_client.go @@ -4,7 +4,9 @@ package cloudwatchlogs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cloudwatchlogs/go.mod b/service/cloudwatchlogs/go.mod index 8abb1b3a260..78939d4eb93 100644 --- a/service/cloudwatchlogs/go.mod +++ b/service/cloudwatchlogs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cloudwatchlogs/go.sum b/service/cloudwatchlogs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cloudwatchlogs/go.sum +++ b/service/cloudwatchlogs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codeartifact/api_client.go b/service/codeartifact/api_client.go index fe21458ee14..ade6ef5fc23 100644 --- a/service/codeartifact/api_client.go +++ b/service/codeartifact/api_client.go @@ -4,7 +4,9 @@ package codeartifact import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/codeartifact/go.mod b/service/codeartifact/go.mod index 58983c46f65..bc3d2279954 100644 --- a/service/codeartifact/go.mod +++ b/service/codeartifact/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codeartifact/go.sum b/service/codeartifact/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codeartifact/go.sum +++ b/service/codeartifact/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codebuild/api_client.go b/service/codebuild/api_client.go index 9b7e7072ccc..ed7e83b748e 100644 --- a/service/codebuild/api_client.go +++ b/service/codebuild/api_client.go @@ -4,7 +4,9 @@ package codebuild import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/codebuild/go.mod b/service/codebuild/go.mod index 65b5d694fb0..148a31da520 100644 --- a/service/codebuild/go.mod +++ b/service/codebuild/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codebuild/go.sum b/service/codebuild/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codebuild/go.sum +++ b/service/codebuild/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codecommit/api_client.go b/service/codecommit/api_client.go index 05b94644813..abb3612830d 100644 --- a/service/codecommit/api_client.go +++ b/service/codecommit/api_client.go @@ -5,7 +5,9 @@ package codecommit import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/codecommit/go.mod b/service/codecommit/go.mod index c89a8244a4c..37fa3a8ee39 100644 --- a/service/codecommit/go.mod +++ b/service/codecommit/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codecommit/go.sum b/service/codecommit/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codecommit/go.sum +++ b/service/codecommit/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codedeploy/api_client.go b/service/codedeploy/api_client.go index e06eb13a948..39f205fe43a 100644 --- a/service/codedeploy/api_client.go +++ b/service/codedeploy/api_client.go @@ -4,7 +4,9 @@ package codedeploy import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/codedeploy/go.mod b/service/codedeploy/go.mod index ba699549556..37e565b9663 100644 --- a/service/codedeploy/go.mod +++ b/service/codedeploy/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/codedeploy/go.sum b/service/codedeploy/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/codedeploy/go.sum +++ b/service/codedeploy/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/codeguruprofiler/api_client.go b/service/codeguruprofiler/api_client.go index da9b44f7d87..b4cc753fb8f 100644 --- a/service/codeguruprofiler/api_client.go +++ b/service/codeguruprofiler/api_client.go @@ -5,7 +5,9 @@ package codeguruprofiler import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/codeguruprofiler/go.mod b/service/codeguruprofiler/go.mod index 47a639af359..10eb204e618 100644 --- a/service/codeguruprofiler/go.mod +++ b/service/codeguruprofiler/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codeguruprofiler/go.sum b/service/codeguruprofiler/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codeguruprofiler/go.sum +++ b/service/codeguruprofiler/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codegurureviewer/api_client.go b/service/codegurureviewer/api_client.go index b54d180ad4c..f3fea147f90 100644 --- a/service/codegurureviewer/api_client.go +++ b/service/codegurureviewer/api_client.go @@ -5,7 +5,9 @@ package codegurureviewer import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/codegurureviewer/go.mod b/service/codegurureviewer/go.mod index 871a27b2ed7..6ce15716597 100644 --- a/service/codegurureviewer/go.mod +++ b/service/codegurureviewer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/codegurureviewer/go.sum b/service/codegurureviewer/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/codegurureviewer/go.sum +++ b/service/codegurureviewer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/codepipeline/api_client.go b/service/codepipeline/api_client.go index b8441bf4c95..c61d89afd3e 100644 --- a/service/codepipeline/api_client.go +++ b/service/codepipeline/api_client.go @@ -5,7 +5,9 @@ package codepipeline import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/codepipeline/go.mod b/service/codepipeline/go.mod index a0c9f4d2f92..4b7b0f241e8 100644 --- a/service/codepipeline/go.mod +++ b/service/codepipeline/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codepipeline/go.sum b/service/codepipeline/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codepipeline/go.sum +++ b/service/codepipeline/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codestar/api_client.go b/service/codestar/api_client.go index 50fb4294397..7667c4547fd 100644 --- a/service/codestar/api_client.go +++ b/service/codestar/api_client.go @@ -4,7 +4,9 @@ package codestar import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/codestar/go.mod b/service/codestar/go.mod index d1475f21e80..dafb4163113 100644 --- a/service/codestar/go.mod +++ b/service/codestar/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codestar/go.sum b/service/codestar/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codestar/go.sum +++ b/service/codestar/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codestarconnections/api_client.go b/service/codestarconnections/api_client.go index 491bfb02d25..e55c43fdb3b 100644 --- a/service/codestarconnections/api_client.go +++ b/service/codestarconnections/api_client.go @@ -4,7 +4,9 @@ package codestarconnections import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/codestarconnections/go.mod b/service/codestarconnections/go.mod index bddcfec7422..d8f7912e220 100644 --- a/service/codestarconnections/go.mod +++ b/service/codestarconnections/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codestarconnections/go.sum b/service/codestarconnections/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codestarconnections/go.sum +++ b/service/codestarconnections/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/codestarnotifications/api_client.go b/service/codestarnotifications/api_client.go index 9dec52c518a..db3b7fcce20 100644 --- a/service/codestarnotifications/api_client.go +++ b/service/codestarnotifications/api_client.go @@ -5,7 +5,9 @@ package codestarnotifications import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/codestarnotifications/go.mod b/service/codestarnotifications/go.mod index f2bce19f93c..260e9eef47b 100644 --- a/service/codestarnotifications/go.mod +++ b/service/codestarnotifications/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/codestarnotifications/go.sum b/service/codestarnotifications/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/codestarnotifications/go.sum +++ b/service/codestarnotifications/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cognitoidentity/api_client.go b/service/cognitoidentity/api_client.go index e6bda298e87..e6b673c0603 100644 --- a/service/cognitoidentity/api_client.go +++ b/service/cognitoidentity/api_client.go @@ -4,7 +4,9 @@ package cognitoidentity import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cognitoidentity/go.mod b/service/cognitoidentity/go.mod index 5931fb0f70c..36c54710369 100644 --- a/service/cognitoidentity/go.mod +++ b/service/cognitoidentity/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cognitoidentity/go.sum b/service/cognitoidentity/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cognitoidentity/go.sum +++ b/service/cognitoidentity/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cognitoidentityprovider/api_client.go b/service/cognitoidentityprovider/api_client.go index a45093bd0f3..d019e56d7db 100644 --- a/service/cognitoidentityprovider/api_client.go +++ b/service/cognitoidentityprovider/api_client.go @@ -4,7 +4,9 @@ package cognitoidentityprovider import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cognitoidentityprovider/go.mod b/service/cognitoidentityprovider/go.mod index b7c7a05933c..4ceb2f0c24d 100644 --- a/service/cognitoidentityprovider/go.mod +++ b/service/cognitoidentityprovider/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cognitoidentityprovider/go.sum b/service/cognitoidentityprovider/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cognitoidentityprovider/go.sum +++ b/service/cognitoidentityprovider/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/cognitosync/api_client.go b/service/cognitosync/api_client.go index aff1c509165..2a1b4907c16 100644 --- a/service/cognitosync/api_client.go +++ b/service/cognitosync/api_client.go @@ -4,7 +4,9 @@ package cognitosync import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/cognitosync/go.mod b/service/cognitosync/go.mod index c7b879037e4..73b8c157e6a 100644 --- a/service/cognitosync/go.mod +++ b/service/cognitosync/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/cognitosync/go.sum b/service/cognitosync/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/cognitosync/go.sum +++ b/service/cognitosync/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/comprehend/api_client.go b/service/comprehend/api_client.go index 449059f04ae..613529f4251 100644 --- a/service/comprehend/api_client.go +++ b/service/comprehend/api_client.go @@ -5,7 +5,9 @@ package comprehend import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/comprehend/go.mod b/service/comprehend/go.mod index bf5e97f257a..6b2da79a463 100644 --- a/service/comprehend/go.mod +++ b/service/comprehend/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/comprehend/go.sum b/service/comprehend/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/comprehend/go.sum +++ b/service/comprehend/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/comprehendmedical/api_client.go b/service/comprehendmedical/api_client.go index b69493fa786..b86a56b6431 100644 --- a/service/comprehendmedical/api_client.go +++ b/service/comprehendmedical/api_client.go @@ -5,7 +5,9 @@ package comprehendmedical import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/comprehendmedical/go.mod b/service/comprehendmedical/go.mod index 9e11c677242..edb633fcead 100644 --- a/service/comprehendmedical/go.mod +++ b/service/comprehendmedical/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/comprehendmedical/go.sum b/service/comprehendmedical/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/comprehendmedical/go.sum +++ b/service/comprehendmedical/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/computeoptimizer/api_client.go b/service/computeoptimizer/api_client.go index b2400605665..8d566735e1a 100644 --- a/service/computeoptimizer/api_client.go +++ b/service/computeoptimizer/api_client.go @@ -4,7 +4,9 @@ package computeoptimizer import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/computeoptimizer/go.mod b/service/computeoptimizer/go.mod index 0859132deb4..4eae78468f3 100644 --- a/service/computeoptimizer/go.mod +++ b/service/computeoptimizer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/computeoptimizer/go.sum b/service/computeoptimizer/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/computeoptimizer/go.sum +++ b/service/computeoptimizer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/configservice/api_client.go b/service/configservice/api_client.go index 9a53484e8d7..dbb87e916af 100644 --- a/service/configservice/api_client.go +++ b/service/configservice/api_client.go @@ -4,7 +4,9 @@ package configservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/configservice/go.mod b/service/configservice/go.mod index 1d46398f7ea..464aa81414b 100644 --- a/service/configservice/go.mod +++ b/service/configservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/configservice/go.sum b/service/configservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/configservice/go.sum +++ b/service/configservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/connect/api_client.go b/service/connect/api_client.go index 9ae527750cf..26ec86cee40 100644 --- a/service/connect/api_client.go +++ b/service/connect/api_client.go @@ -5,7 +5,9 @@ package connect import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/connect/go.mod b/service/connect/go.mod index d2b516368e6..96506c28127 100644 --- a/service/connect/go.mod +++ b/service/connect/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/connect/go.sum b/service/connect/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/connect/go.sum +++ b/service/connect/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/connectcontactlens/api_client.go b/service/connectcontactlens/api_client.go index dc36e52bd3e..72cc514aed9 100644 --- a/service/connectcontactlens/api_client.go +++ b/service/connectcontactlens/api_client.go @@ -4,7 +4,9 @@ package connectcontactlens import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/connectcontactlens/go.mod b/service/connectcontactlens/go.mod index 4c11edd4d46..0442965dbd8 100644 --- a/service/connectcontactlens/go.mod +++ b/service/connectcontactlens/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/connectcontactlens/go.sum b/service/connectcontactlens/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/connectcontactlens/go.sum +++ b/service/connectcontactlens/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/connectparticipant/api_client.go b/service/connectparticipant/api_client.go index 26382553f90..f6c03cdd8ad 100644 --- a/service/connectparticipant/api_client.go +++ b/service/connectparticipant/api_client.go @@ -5,7 +5,9 @@ package connectparticipant import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/connectparticipant/go.mod b/service/connectparticipant/go.mod index 94d922e3eed..e38cd27b39f 100644 --- a/service/connectparticipant/go.mod +++ b/service/connectparticipant/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/connectparticipant/go.sum b/service/connectparticipant/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/connectparticipant/go.sum +++ b/service/connectparticipant/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/costandusagereportservice/api_client.go b/service/costandusagereportservice/api_client.go index 6b6121a19cd..2a9bebb1ad6 100644 --- a/service/costandusagereportservice/api_client.go +++ b/service/costandusagereportservice/api_client.go @@ -4,7 +4,9 @@ package costandusagereportservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/costandusagereportservice/go.mod b/service/costandusagereportservice/go.mod index 9b065cfb8a3..9a3596ce895 100644 --- a/service/costandusagereportservice/go.mod +++ b/service/costandusagereportservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/costandusagereportservice/go.sum b/service/costandusagereportservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/costandusagereportservice/go.sum +++ b/service/costandusagereportservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/costexplorer/api_client.go b/service/costexplorer/api_client.go index aa1a0366030..8afbea8d3a8 100644 --- a/service/costexplorer/api_client.go +++ b/service/costexplorer/api_client.go @@ -4,7 +4,9 @@ package costexplorer import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/costexplorer/go.mod b/service/costexplorer/go.mod index ce09911910d..5253a5840a7 100644 --- a/service/costexplorer/go.mod +++ b/service/costexplorer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/costexplorer/go.sum b/service/costexplorer/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/costexplorer/go.sum +++ b/service/costexplorer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/customerprofiles/api_client.go b/service/customerprofiles/api_client.go index 755e045bf17..1bcec41af9a 100644 --- a/service/customerprofiles/api_client.go +++ b/service/customerprofiles/api_client.go @@ -4,7 +4,9 @@ package customerprofiles import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/customerprofiles/go.mod b/service/customerprofiles/go.mod index b42e048840d..f1167a07c28 100644 --- a/service/customerprofiles/go.mod +++ b/service/customerprofiles/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/customerprofiles/go.sum b/service/customerprofiles/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/customerprofiles/go.sum +++ b/service/customerprofiles/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/databasemigrationservice/api_client.go b/service/databasemigrationservice/api_client.go index 26c6a076844..a846cf39ae0 100644 --- a/service/databasemigrationservice/api_client.go +++ b/service/databasemigrationservice/api_client.go @@ -4,7 +4,9 @@ package databasemigrationservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/databasemigrationservice/go.mod b/service/databasemigrationservice/go.mod index 19223b2b0ac..161b0992326 100644 --- a/service/databasemigrationservice/go.mod +++ b/service/databasemigrationservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/databasemigrationservice/go.sum b/service/databasemigrationservice/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/databasemigrationservice/go.sum +++ b/service/databasemigrationservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/databrew/api_client.go b/service/databrew/api_client.go index b44a2bacd65..9f275347324 100644 --- a/service/databrew/api_client.go +++ b/service/databrew/api_client.go @@ -4,7 +4,9 @@ package databrew import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/databrew/go.mod b/service/databrew/go.mod index dd4e5839dff..73a95ae84cc 100644 --- a/service/databrew/go.mod +++ b/service/databrew/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/databrew/go.sum b/service/databrew/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/databrew/go.sum +++ b/service/databrew/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/dataexchange/api_client.go b/service/dataexchange/api_client.go index 97e3612eb05..5694d9c8697 100644 --- a/service/dataexchange/api_client.go +++ b/service/dataexchange/api_client.go @@ -4,7 +4,9 @@ package dataexchange import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/dataexchange/go.mod b/service/dataexchange/go.mod index fc6ca5f628e..d6b09ce4e90 100644 --- a/service/dataexchange/go.mod +++ b/service/dataexchange/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/dataexchange/go.sum b/service/dataexchange/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/dataexchange/go.sum +++ b/service/dataexchange/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/datapipeline/api_client.go b/service/datapipeline/api_client.go index a8af747d866..e3745cc0d62 100644 --- a/service/datapipeline/api_client.go +++ b/service/datapipeline/api_client.go @@ -4,7 +4,9 @@ package datapipeline import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/datapipeline/go.mod b/service/datapipeline/go.mod index 187915c0cf5..5111085f120 100644 --- a/service/datapipeline/go.mod +++ b/service/datapipeline/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/datapipeline/go.sum b/service/datapipeline/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/datapipeline/go.sum +++ b/service/datapipeline/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/datasync/api_client.go b/service/datasync/api_client.go index 303e6293e6f..1326ee6212f 100644 --- a/service/datasync/api_client.go +++ b/service/datasync/api_client.go @@ -4,7 +4,9 @@ package datasync import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/datasync/go.mod b/service/datasync/go.mod index 674856cbe8f..7b9f5ec27c5 100644 --- a/service/datasync/go.mod +++ b/service/datasync/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/datasync/go.sum b/service/datasync/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/datasync/go.sum +++ b/service/datasync/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/dax/api_client.go b/service/dax/api_client.go index 815a27f49ed..6776bb593e7 100644 --- a/service/dax/api_client.go +++ b/service/dax/api_client.go @@ -4,7 +4,9 @@ package dax import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/dax/go.mod b/service/dax/go.mod index 6a44a56cc50..ff223ecad1f 100644 --- a/service/dax/go.mod +++ b/service/dax/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/dax/go.sum b/service/dax/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/dax/go.sum +++ b/service/dax/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/detective/api_client.go b/service/detective/api_client.go index c64a2eea679..4b1da23ac03 100644 --- a/service/detective/api_client.go +++ b/service/detective/api_client.go @@ -4,7 +4,9 @@ package detective import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/detective/go.mod b/service/detective/go.mod index ab468ab7d0a..57e7ed04da1 100644 --- a/service/detective/go.mod +++ b/service/detective/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/detective/go.sum b/service/detective/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/detective/go.sum +++ b/service/detective/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/devicefarm/api_client.go b/service/devicefarm/api_client.go index c80899620fe..207ddf244c4 100644 --- a/service/devicefarm/api_client.go +++ b/service/devicefarm/api_client.go @@ -4,7 +4,9 @@ package devicefarm import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/devicefarm/go.mod b/service/devicefarm/go.mod index 7ba9ab053af..124d537b05e 100644 --- a/service/devicefarm/go.mod +++ b/service/devicefarm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/devicefarm/go.sum b/service/devicefarm/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/devicefarm/go.sum +++ b/service/devicefarm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/devopsguru/api_client.go b/service/devopsguru/api_client.go index b33944376ae..142352e906b 100644 --- a/service/devopsguru/api_client.go +++ b/service/devopsguru/api_client.go @@ -5,7 +5,9 @@ package devopsguru import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/devopsguru/go.mod b/service/devopsguru/go.mod index 78394d7ae06..b09fc163312 100644 --- a/service/devopsguru/go.mod +++ b/service/devopsguru/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/devopsguru/go.sum b/service/devopsguru/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/devopsguru/go.sum +++ b/service/devopsguru/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/directconnect/api_client.go b/service/directconnect/api_client.go index 941ecf1afa3..8e20e36f115 100644 --- a/service/directconnect/api_client.go +++ b/service/directconnect/api_client.go @@ -4,7 +4,9 @@ package directconnect import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/directconnect/go.mod b/service/directconnect/go.mod index 7d519251d1d..1a1746e244f 100644 --- a/service/directconnect/go.mod +++ b/service/directconnect/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/directconnect/go.sum b/service/directconnect/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/directconnect/go.sum +++ b/service/directconnect/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/directoryservice/api_client.go b/service/directoryservice/api_client.go index 3e384865aff..f448539809c 100644 --- a/service/directoryservice/api_client.go +++ b/service/directoryservice/api_client.go @@ -4,7 +4,9 @@ package directoryservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/directoryservice/go.mod b/service/directoryservice/go.mod index 4e51d94942f..09497d70577 100644 --- a/service/directoryservice/go.mod +++ b/service/directoryservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/directoryservice/go.sum b/service/directoryservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/directoryservice/go.sum +++ b/service/directoryservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/dlm/api_client.go b/service/dlm/api_client.go index be8d8de18c7..7e53f2b0969 100644 --- a/service/dlm/api_client.go +++ b/service/dlm/api_client.go @@ -4,7 +4,9 @@ package dlm import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/dlm/go.mod b/service/dlm/go.mod index 52a517b6f3a..25b755b1c33 100644 --- a/service/dlm/go.mod +++ b/service/dlm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/dlm/go.sum b/service/dlm/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/dlm/go.sum +++ b/service/dlm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/docdb/api_client.go b/service/docdb/api_client.go index edd3a633c77..3f8545e2391 100644 --- a/service/docdb/api_client.go +++ b/service/docdb/api_client.go @@ -4,7 +4,9 @@ package docdb import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/protocol/query" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -69,6 +74,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -88,9 +97,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -118,6 +140,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +198,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +215,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +307,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/docdb/go.mod b/service/docdb/go.mod index ff67fd36126..15125c69da6 100644 --- a/service/docdb/go.mod +++ b/service/docdb/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/docdb/go.sum b/service/docdb/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/docdb/go.sum +++ b/service/docdb/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/drs/api_client.go b/service/drs/api_client.go index 6cec3dc8ee8..d6a82d7e8ba 100644 --- a/service/drs/api_client.go +++ b/service/drs/api_client.go @@ -4,7 +4,9 @@ package drs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/drs/go.mod b/service/drs/go.mod index 56957a4aeb8..4ce34b02d5e 100644 --- a/service/drs/go.mod +++ b/service/drs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/drs/go.sum b/service/drs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/drs/go.sum +++ b/service/drs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/dynamodb/api_client.go b/service/dynamodb/api_client.go index 94bce94fa51..cf03bfed91c 100644 --- a/service/dynamodb/api_client.go +++ b/service/dynamodb/api_client.go @@ -7,6 +7,7 @@ import ( cryptorand "crypto/rand" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -21,6 +22,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "net/url" "strings" @@ -52,6 +54,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -83,6 +87,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // Allows you to disable the client's validation of response integrity using CRC32 // checksum. Enabled by default. DisableValidateResponseChecksum bool @@ -117,9 +125,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -147,6 +168,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -199,12 +226,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -215,10 +244,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -273,6 +336,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/dynamodb/go.mod b/service/dynamodb/go.mod index cf665616ed2..dcd9259597a 100644 --- a/service/dynamodb/go.mod +++ b/service/dynamodb/go.mod @@ -8,7 +8,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.6.0 github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.4.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/dynamodb/go.sum b/service/dynamodb/go.sum index 7ed756b99ee..55f13ae4e93 100644 --- a/service/dynamodb/go.sum +++ b/service/dynamodb/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= diff --git a/service/dynamodbstreams/api_client.go b/service/dynamodbstreams/api_client.go index 40c54cf8298..c4ec72bb14c 100644 --- a/service/dynamodbstreams/api_client.go +++ b/service/dynamodbstreams/api_client.go @@ -4,7 +4,9 @@ package dynamodbstreams import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/dynamodbstreams/go.mod b/service/dynamodbstreams/go.mod index 7108d8fb37d..aad5df0f416 100644 --- a/service/dynamodbstreams/go.mod +++ b/service/dynamodbstreams/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/dynamodbstreams/go.sum b/service/dynamodbstreams/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/dynamodbstreams/go.sum +++ b/service/dynamodbstreams/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ebs/api_client.go b/service/ebs/api_client.go index 180d11903bd..292c30056b7 100644 --- a/service/ebs/api_client.go +++ b/service/ebs/api_client.go @@ -5,7 +5,9 @@ package ebs import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/ebs/go.mod b/service/ebs/go.mod index deb5bc01905..dca93086a45 100644 --- a/service/ebs/go.mod +++ b/service/ebs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ebs/go.sum b/service/ebs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ebs/go.sum +++ b/service/ebs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ec2/api_client.go b/service/ec2/api_client.go index 2c87c12b43a..d6bf5e3b4af 100644 --- a/service/ec2/api_client.go +++ b/service/ec2/api_client.go @@ -5,7 +5,9 @@ package ec2 import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/protocol/query" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -19,6 +21,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -46,6 +49,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -73,6 +78,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -96,9 +105,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -126,6 +148,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -178,12 +206,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -193,10 +223,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -251,6 +315,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/ec2/go.mod b/service/ec2/go.mod index 63225d1050a..b40369e259c 100644 --- a/service/ec2/go.mod +++ b/service/ec2/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ec2/go.sum b/service/ec2/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ec2/go.sum +++ b/service/ec2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/ec2instanceconnect/api_client.go b/service/ec2instanceconnect/api_client.go index 0126d4d8031..d8a2c475240 100644 --- a/service/ec2instanceconnect/api_client.go +++ b/service/ec2instanceconnect/api_client.go @@ -4,7 +4,9 @@ package ec2instanceconnect import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ec2instanceconnect/go.mod b/service/ec2instanceconnect/go.mod index 33d8fe56853..06107d8299b 100644 --- a/service/ec2instanceconnect/go.mod +++ b/service/ec2instanceconnect/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ec2instanceconnect/go.sum b/service/ec2instanceconnect/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ec2instanceconnect/go.sum +++ b/service/ec2instanceconnect/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ecr/api_client.go b/service/ecr/api_client.go index 4e274f2714c..83ba65dd108 100644 --- a/service/ecr/api_client.go +++ b/service/ecr/api_client.go @@ -4,7 +4,9 @@ package ecr import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ecr/go.mod b/service/ecr/go.mod index fa9259d6f46..1f822005c71 100644 --- a/service/ecr/go.mod +++ b/service/ecr/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ecr/go.sum b/service/ecr/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ecr/go.sum +++ b/service/ecr/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/ecrpublic/api_client.go b/service/ecrpublic/api_client.go index d8e2f569ba5..ffb20826a51 100644 --- a/service/ecrpublic/api_client.go +++ b/service/ecrpublic/api_client.go @@ -4,7 +4,9 @@ package ecrpublic import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ecrpublic/go.mod b/service/ecrpublic/go.mod index 27ec0af3757..fac57901b8b 100644 --- a/service/ecrpublic/go.mod +++ b/service/ecrpublic/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ecrpublic/go.sum b/service/ecrpublic/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ecrpublic/go.sum +++ b/service/ecrpublic/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ecs/api_client.go b/service/ecs/api_client.go index 55ae6a0c909..9b77878f143 100644 --- a/service/ecs/api_client.go +++ b/service/ecs/api_client.go @@ -4,7 +4,9 @@ package ecs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ecs/go.mod b/service/ecs/go.mod index 9d8c60c33be..85f014a5e50 100644 --- a/service/ecs/go.mod +++ b/service/ecs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ecs/go.sum b/service/ecs/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ecs/go.sum +++ b/service/ecs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/efs/api_client.go b/service/efs/api_client.go index c7660c5a7dc..d2b4f52aa04 100644 --- a/service/efs/api_client.go +++ b/service/efs/api_client.go @@ -5,7 +5,9 @@ package efs import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/efs/go.mod b/service/efs/go.mod index d993dc3b203..4386f1485b5 100644 --- a/service/efs/go.mod +++ b/service/efs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/efs/go.sum b/service/efs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/efs/go.sum +++ b/service/efs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/eks/api_client.go b/service/eks/api_client.go index 63f36e5f571..ee6c944a84e 100644 --- a/service/eks/api_client.go +++ b/service/eks/api_client.go @@ -5,7 +5,9 @@ package eks import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/eks/go.mod b/service/eks/go.mod index 1ac686d09ad..2d36d5c2269 100644 --- a/service/eks/go.mod +++ b/service/eks/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/eks/go.sum b/service/eks/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/eks/go.sum +++ b/service/eks/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/elasticache/api_client.go b/service/elasticache/api_client.go index 3b5a3121327..5534ba6f529 100644 --- a/service/elasticache/api_client.go +++ b/service/elasticache/api_client.go @@ -4,7 +4,9 @@ package elasticache import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticache/go.mod b/service/elasticache/go.mod index 793693f7ecd..a7fc3c09cf1 100644 --- a/service/elasticache/go.mod +++ b/service/elasticache/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/elasticache/go.sum b/service/elasticache/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/elasticache/go.sum +++ b/service/elasticache/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/elasticbeanstalk/api_client.go b/service/elasticbeanstalk/api_client.go index dd62e68f9c6..4f71751b857 100644 --- a/service/elasticbeanstalk/api_client.go +++ b/service/elasticbeanstalk/api_client.go @@ -4,7 +4,9 @@ package elasticbeanstalk import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticbeanstalk/go.mod b/service/elasticbeanstalk/go.mod index 0ca441d858d..37b3b185619 100644 --- a/service/elasticbeanstalk/go.mod +++ b/service/elasticbeanstalk/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/elasticbeanstalk/go.sum b/service/elasticbeanstalk/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/elasticbeanstalk/go.sum +++ b/service/elasticbeanstalk/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/elasticinference/api_client.go b/service/elasticinference/api_client.go index ed1322fc8cc..18591545080 100644 --- a/service/elasticinference/api_client.go +++ b/service/elasticinference/api_client.go @@ -4,7 +4,9 @@ package elasticinference import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticinference/go.mod b/service/elasticinference/go.mod index 5fc9f704ce9..4723d853366 100644 --- a/service/elasticinference/go.mod +++ b/service/elasticinference/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/elasticinference/go.sum b/service/elasticinference/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/elasticinference/go.sum +++ b/service/elasticinference/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/elasticloadbalancing/api_client.go b/service/elasticloadbalancing/api_client.go index 5f6a55a5767..2c88efab4f4 100644 --- a/service/elasticloadbalancing/api_client.go +++ b/service/elasticloadbalancing/api_client.go @@ -4,7 +4,9 @@ package elasticloadbalancing import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticloadbalancing/go.mod b/service/elasticloadbalancing/go.mod index b796931526e..62abe3721bb 100644 --- a/service/elasticloadbalancing/go.mod +++ b/service/elasticloadbalancing/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/elasticloadbalancing/go.sum b/service/elasticloadbalancing/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/elasticloadbalancing/go.sum +++ b/service/elasticloadbalancing/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/elasticloadbalancingv2/api_client.go b/service/elasticloadbalancingv2/api_client.go index e5691ba35bc..d1d37a3dda0 100644 --- a/service/elasticloadbalancingv2/api_client.go +++ b/service/elasticloadbalancingv2/api_client.go @@ -4,7 +4,9 @@ package elasticloadbalancingv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticloadbalancingv2/go.mod b/service/elasticloadbalancingv2/go.mod index 23625fd92db..1a479aa77a5 100644 --- a/service/elasticloadbalancingv2/go.mod +++ b/service/elasticloadbalancingv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/elasticloadbalancingv2/go.sum b/service/elasticloadbalancingv2/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/elasticloadbalancingv2/go.sum +++ b/service/elasticloadbalancingv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/elasticsearchservice/api_client.go b/service/elasticsearchservice/api_client.go index eb281eb41ca..9faaa440c37 100644 --- a/service/elasticsearchservice/api_client.go +++ b/service/elasticsearchservice/api_client.go @@ -4,7 +4,9 @@ package elasticsearchservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elasticsearchservice/go.mod b/service/elasticsearchservice/go.mod index 40301ef4de9..e8c3e87e22d 100644 --- a/service/elasticsearchservice/go.mod +++ b/service/elasticsearchservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/elasticsearchservice/go.sum b/service/elasticsearchservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/elasticsearchservice/go.sum +++ b/service/elasticsearchservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/elastictranscoder/api_client.go b/service/elastictranscoder/api_client.go index 7eefaef0c5a..295c028f715 100644 --- a/service/elastictranscoder/api_client.go +++ b/service/elastictranscoder/api_client.go @@ -4,7 +4,9 @@ package elastictranscoder import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/elastictranscoder/go.mod b/service/elastictranscoder/go.mod index abcfd44d248..a13f629c7dd 100644 --- a/service/elastictranscoder/go.mod +++ b/service/elastictranscoder/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/elastictranscoder/go.sum b/service/elastictranscoder/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/elastictranscoder/go.sum +++ b/service/elastictranscoder/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/emr/api_client.go b/service/emr/api_client.go index 32d7d776571..c8b3d8e3a4a 100644 --- a/service/emr/api_client.go +++ b/service/emr/api_client.go @@ -4,7 +4,9 @@ package emr import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/emr/go.mod b/service/emr/go.mod index 21e8deceff8..de067b48b58 100644 --- a/service/emr/go.mod +++ b/service/emr/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/emr/go.sum b/service/emr/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/emr/go.sum +++ b/service/emr/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/emrcontainers/api_client.go b/service/emrcontainers/api_client.go index 14599345160..ccc76c4d964 100644 --- a/service/emrcontainers/api_client.go +++ b/service/emrcontainers/api_client.go @@ -5,7 +5,9 @@ package emrcontainers import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/emrcontainers/go.mod b/service/emrcontainers/go.mod index 069158244bb..2e31c4af511 100644 --- a/service/emrcontainers/go.mod +++ b/service/emrcontainers/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/emrcontainers/go.sum b/service/emrcontainers/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/emrcontainers/go.sum +++ b/service/emrcontainers/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/eventbridge/api_client.go b/service/eventbridge/api_client.go index 8819268177c..b6b24df7d66 100644 --- a/service/eventbridge/api_client.go +++ b/service/eventbridge/api_client.go @@ -4,7 +4,9 @@ package eventbridge import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/eventbridge/go.mod b/service/eventbridge/go.mod index e84826a6a94..c0529d91e48 100644 --- a/service/eventbridge/go.mod +++ b/service/eventbridge/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/eventbridge/go.sum b/service/eventbridge/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/eventbridge/go.sum +++ b/service/eventbridge/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/evidently/api_client.go b/service/evidently/api_client.go index b184f799906..6c759500f6a 100644 --- a/service/evidently/api_client.go +++ b/service/evidently/api_client.go @@ -4,7 +4,9 @@ package evidently import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/evidently/go.mod b/service/evidently/go.mod index 391700ae944..c450d1f0532 100644 --- a/service/evidently/go.mod +++ b/service/evidently/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/evidently/go.sum b/service/evidently/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/evidently/go.sum +++ b/service/evidently/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/finspace/api_client.go b/service/finspace/api_client.go index 8feed162ee5..2d648e3680a 100644 --- a/service/finspace/api_client.go +++ b/service/finspace/api_client.go @@ -6,6 +6,7 @@ import ( "context" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -16,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "strings" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -69,6 +73,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -88,9 +96,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -118,6 +139,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +197,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +214,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +306,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/finspace/go.mod b/service/finspace/go.mod index 25e852521ad..1c4cfaa6a55 100644 --- a/service/finspace/go.mod +++ b/service/finspace/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/finspace/go.sum b/service/finspace/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/finspace/go.sum +++ b/service/finspace/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/finspacedata/api_client.go b/service/finspacedata/api_client.go index 46d9d6d6b22..edcf1a636a3 100644 --- a/service/finspacedata/api_client.go +++ b/service/finspacedata/api_client.go @@ -7,6 +7,7 @@ import ( cryptorand "crypto/rand" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -18,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "strings" "time" @@ -45,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -72,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -95,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -125,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -177,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -192,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -250,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/finspacedata/go.mod b/service/finspacedata/go.mod index 11688b414ca..522a44c4bbc 100644 --- a/service/finspacedata/go.mod +++ b/service/finspacedata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/finspacedata/go.sum b/service/finspacedata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/finspacedata/go.sum +++ b/service/finspacedata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/firehose/api_client.go b/service/firehose/api_client.go index 55995909886..ceae282a5b2 100644 --- a/service/firehose/api_client.go +++ b/service/firehose/api_client.go @@ -4,7 +4,9 @@ package firehose import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/firehose/go.mod b/service/firehose/go.mod index e40985fc715..49d32ee5418 100644 --- a/service/firehose/go.mod +++ b/service/firehose/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/firehose/go.sum b/service/firehose/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/firehose/go.sum +++ b/service/firehose/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/fis/api_client.go b/service/fis/api_client.go index 0d798f8bc2a..abb863c1931 100644 --- a/service/fis/api_client.go +++ b/service/fis/api_client.go @@ -5,7 +5,9 @@ package fis import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/fis/go.mod b/service/fis/go.mod index cbda39178d1..e2ae73fc16c 100644 --- a/service/fis/go.mod +++ b/service/fis/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/fis/go.sum b/service/fis/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/fis/go.sum +++ b/service/fis/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/fms/api_client.go b/service/fms/api_client.go index 5804b3b2373..abbe01b8ed2 100644 --- a/service/fms/api_client.go +++ b/service/fms/api_client.go @@ -4,7 +4,9 @@ package fms import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/fms/go.mod b/service/fms/go.mod index bec22b99df4..74080cd83bc 100644 --- a/service/fms/go.mod +++ b/service/fms/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/fms/go.sum b/service/fms/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/fms/go.sum +++ b/service/fms/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/forecast/api_client.go b/service/forecast/api_client.go index 665041b1d47..cbf383f65e4 100644 --- a/service/forecast/api_client.go +++ b/service/forecast/api_client.go @@ -4,7 +4,9 @@ package forecast import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/forecast/go.mod b/service/forecast/go.mod index 1ccc2ecfb23..04f64d184dd 100644 --- a/service/forecast/go.mod +++ b/service/forecast/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/forecast/go.sum b/service/forecast/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/forecast/go.sum +++ b/service/forecast/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/forecastquery/api_client.go b/service/forecastquery/api_client.go index 09c37a9df5c..6f07acbb4d1 100644 --- a/service/forecastquery/api_client.go +++ b/service/forecastquery/api_client.go @@ -4,7 +4,9 @@ package forecastquery import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/forecastquery/go.mod b/service/forecastquery/go.mod index 4603fb311ed..96cdc1139ef 100644 --- a/service/forecastquery/go.mod +++ b/service/forecastquery/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/forecastquery/go.sum b/service/forecastquery/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/forecastquery/go.sum +++ b/service/forecastquery/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/frauddetector/api_client.go b/service/frauddetector/api_client.go index e46e520636c..bfc7d9df552 100644 --- a/service/frauddetector/api_client.go +++ b/service/frauddetector/api_client.go @@ -4,7 +4,9 @@ package frauddetector import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/frauddetector/go.mod b/service/frauddetector/go.mod index 09585515840..3c91897088a 100644 --- a/service/frauddetector/go.mod +++ b/service/frauddetector/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/frauddetector/go.sum b/service/frauddetector/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/frauddetector/go.sum +++ b/service/frauddetector/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/fsx/api_client.go b/service/fsx/api_client.go index dddff0f42a1..a47cdd23f1c 100644 --- a/service/fsx/api_client.go +++ b/service/fsx/api_client.go @@ -5,7 +5,9 @@ package fsx import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/fsx/go.mod b/service/fsx/go.mod index 51053f56bb1..a12e5239467 100644 --- a/service/fsx/go.mod +++ b/service/fsx/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/fsx/go.sum b/service/fsx/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/fsx/go.sum +++ b/service/fsx/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/gamelift/api_client.go b/service/gamelift/api_client.go index f6f1fceaad1..98f13e47762 100644 --- a/service/gamelift/api_client.go +++ b/service/gamelift/api_client.go @@ -4,7 +4,9 @@ package gamelift import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/gamelift/go.mod b/service/gamelift/go.mod index 44f62590169..cacb7481426 100644 --- a/service/gamelift/go.mod +++ b/service/gamelift/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/gamelift/go.sum b/service/gamelift/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/gamelift/go.sum +++ b/service/gamelift/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/glacier/api_client.go b/service/glacier/api_client.go index e607783e076..79a238a07ca 100644 --- a/service/glacier/api_client.go +++ b/service/glacier/api_client.go @@ -4,7 +4,9 @@ package glacier import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/glacier/go.mod b/service/glacier/go.mod index 98e78df920e..6f348759761 100644 --- a/service/glacier/go.mod +++ b/service/glacier/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/glacier/go.sum b/service/glacier/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/glacier/go.sum +++ b/service/glacier/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/globalaccelerator/api_client.go b/service/globalaccelerator/api_client.go index 79196de6319..f02371f8073 100644 --- a/service/globalaccelerator/api_client.go +++ b/service/globalaccelerator/api_client.go @@ -5,7 +5,9 @@ package globalaccelerator import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/globalaccelerator/go.mod b/service/globalaccelerator/go.mod index d039a31530b..78fe4f94a84 100644 --- a/service/globalaccelerator/go.mod +++ b/service/globalaccelerator/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/globalaccelerator/go.sum b/service/globalaccelerator/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/globalaccelerator/go.sum +++ b/service/globalaccelerator/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/glue/api_client.go b/service/glue/api_client.go index 075243e9d0f..872d598cb5c 100644 --- a/service/glue/api_client.go +++ b/service/glue/api_client.go @@ -4,7 +4,9 @@ package glue import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/glue/go.mod b/service/glue/go.mod index 0b7ff4fbbe7..86076337c3d 100644 --- a/service/glue/go.mod +++ b/service/glue/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/glue/go.sum b/service/glue/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/glue/go.sum +++ b/service/glue/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/grafana/api_client.go b/service/grafana/api_client.go index 3605d847d07..7e2852bf5e1 100644 --- a/service/grafana/api_client.go +++ b/service/grafana/api_client.go @@ -5,7 +5,9 @@ package grafana import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/grafana/go.mod b/service/grafana/go.mod index 9c2def3c545..a159ad42ab3 100644 --- a/service/grafana/go.mod +++ b/service/grafana/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/grafana/go.sum b/service/grafana/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/grafana/go.sum +++ b/service/grafana/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/greengrass/api_client.go b/service/greengrass/api_client.go index 75a434b6280..db80e1faa77 100644 --- a/service/greengrass/api_client.go +++ b/service/greengrass/api_client.go @@ -4,7 +4,9 @@ package greengrass import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/greengrass/go.mod b/service/greengrass/go.mod index 4aab6920975..78ce1b9bef3 100644 --- a/service/greengrass/go.mod +++ b/service/greengrass/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/greengrass/go.sum b/service/greengrass/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/greengrass/go.sum +++ b/service/greengrass/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/greengrassv2/api_client.go b/service/greengrassv2/api_client.go index dc8d6ca6e90..3306172a78c 100644 --- a/service/greengrassv2/api_client.go +++ b/service/greengrassv2/api_client.go @@ -5,7 +5,9 @@ package greengrassv2 import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/greengrassv2/go.mod b/service/greengrassv2/go.mod index 50f3e8110ba..9d3f5c8426b 100644 --- a/service/greengrassv2/go.mod +++ b/service/greengrassv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/greengrassv2/go.sum b/service/greengrassv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/greengrassv2/go.sum +++ b/service/greengrassv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/groundstation/api_client.go b/service/groundstation/api_client.go index 86da4af5a49..e4e379bd908 100644 --- a/service/groundstation/api_client.go +++ b/service/groundstation/api_client.go @@ -4,7 +4,9 @@ package groundstation import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/groundstation/go.mod b/service/groundstation/go.mod index b0fb9d7bddd..757256dc151 100644 --- a/service/groundstation/go.mod +++ b/service/groundstation/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/groundstation/go.sum b/service/groundstation/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/groundstation/go.sum +++ b/service/groundstation/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/guardduty/api_client.go b/service/guardduty/api_client.go index 584769b9909..50989163c18 100644 --- a/service/guardduty/api_client.go +++ b/service/guardduty/api_client.go @@ -5,7 +5,9 @@ package guardduty import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/guardduty/go.mod b/service/guardduty/go.mod index 73a3cbf6319..1d307ea66e1 100644 --- a/service/guardduty/go.mod +++ b/service/guardduty/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/guardduty/go.sum b/service/guardduty/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/guardduty/go.sum +++ b/service/guardduty/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/health/api_client.go b/service/health/api_client.go index 0575dbff056..3457c19732a 100644 --- a/service/health/api_client.go +++ b/service/health/api_client.go @@ -4,7 +4,9 @@ package health import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/health/go.mod b/service/health/go.mod index 1e1f25fe827..24075a4e014 100644 --- a/service/health/go.mod +++ b/service/health/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/health/go.sum b/service/health/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/health/go.sum +++ b/service/health/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/healthlake/api_client.go b/service/healthlake/api_client.go index b30be495d41..857be6f419e 100644 --- a/service/healthlake/api_client.go +++ b/service/healthlake/api_client.go @@ -5,7 +5,9 @@ package healthlake import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/healthlake/go.mod b/service/healthlake/go.mod index 7674b435c44..bd358fb9292 100644 --- a/service/healthlake/go.mod +++ b/service/healthlake/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/healthlake/go.sum b/service/healthlake/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/healthlake/go.sum +++ b/service/healthlake/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/honeycode/api_client.go b/service/honeycode/api_client.go index 6cc40d95a91..7df8805bc77 100644 --- a/service/honeycode/api_client.go +++ b/service/honeycode/api_client.go @@ -4,7 +4,9 @@ package honeycode import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/honeycode/go.mod b/service/honeycode/go.mod index 7112df402bd..1745bd6fd57 100644 --- a/service/honeycode/go.mod +++ b/service/honeycode/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/honeycode/go.sum b/service/honeycode/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/honeycode/go.sum +++ b/service/honeycode/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iam/api_client.go b/service/iam/api_client.go index 40826b4a0e6..1265eadfd05 100644 --- a/service/iam/api_client.go +++ b/service/iam/api_client.go @@ -4,7 +4,9 @@ package iam import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iam/go.mod b/service/iam/go.mod index a69768028f8..ce0544d8759 100644 --- a/service/iam/go.mod +++ b/service/iam/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iam/go.sum b/service/iam/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iam/go.sum +++ b/service/iam/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/identitystore/api_client.go b/service/identitystore/api_client.go index 40b3a3b9eff..3cf415ae4f2 100644 --- a/service/identitystore/api_client.go +++ b/service/identitystore/api_client.go @@ -4,7 +4,9 @@ package identitystore import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/identitystore/go.mod b/service/identitystore/go.mod index 6c8b7ab116c..d220ae57343 100644 --- a/service/identitystore/go.mod +++ b/service/identitystore/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/identitystore/go.sum b/service/identitystore/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/identitystore/go.sum +++ b/service/identitystore/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/imagebuilder/api_client.go b/service/imagebuilder/api_client.go index 18198401ee1..20cd3fa10a2 100644 --- a/service/imagebuilder/api_client.go +++ b/service/imagebuilder/api_client.go @@ -5,7 +5,9 @@ package imagebuilder import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/imagebuilder/go.mod b/service/imagebuilder/go.mod index 3b612b2523f..f28dc3d29b2 100644 --- a/service/imagebuilder/go.mod +++ b/service/imagebuilder/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/imagebuilder/go.sum b/service/imagebuilder/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/imagebuilder/go.sum +++ b/service/imagebuilder/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/inspector/api_client.go b/service/inspector/api_client.go index 1d47d8c1132..fc4a0876cb2 100644 --- a/service/inspector/api_client.go +++ b/service/inspector/api_client.go @@ -4,7 +4,9 @@ package inspector import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/inspector/go.mod b/service/inspector/go.mod index 63fd3f25bac..6283ac4298f 100644 --- a/service/inspector/go.mod +++ b/service/inspector/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/inspector/go.sum b/service/inspector/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/inspector/go.sum +++ b/service/inspector/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/inspector2/api_client.go b/service/inspector2/api_client.go index a2f0277ed14..67a9e6baf9d 100644 --- a/service/inspector2/api_client.go +++ b/service/inspector2/api_client.go @@ -5,7 +5,9 @@ package inspector2 import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/inspector2/go.mod b/service/inspector2/go.mod index 9a2324b7681..94671338087 100644 --- a/service/inspector2/go.mod +++ b/service/inspector2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/inspector2/go.sum b/service/inspector2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/inspector2/go.sum +++ b/service/inspector2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/internal/accept-encoding/go.mod b/service/internal/accept-encoding/go.mod index 6976738e9bb..49cff8dcfb6 100644 --- a/service/internal/accept-encoding/go.mod +++ b/service/internal/accept-encoding/go.mod @@ -2,4 +2,4 @@ module github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding go 1.15 -require github.com/aws/smithy-go v1.9.1 +require github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 diff --git a/service/internal/accept-encoding/go.sum b/service/internal/accept-encoding/go.sum index df5a9aba956..8bfe0ac95ae 100644 --- a/service/internal/accept-encoding/go.sum +++ b/service/internal/accept-encoding/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= diff --git a/service/internal/benchmark/go.mod b/service/internal/benchmark/go.mod index c7ad0ff4008..e3f8db375f0 100644 --- a/service/internal/benchmark/go.mod +++ b/service/internal/benchmark/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.12.0 github.com/aws/aws-sdk-go-v2/service/lexruntimeservice v1.9.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../../ diff --git a/service/internal/benchmark/go.sum b/service/internal/benchmark/go.sum index 256fc38b5f6..2a04ece675e 100644 --- a/service/internal/benchmark/go.sum +++ b/service/internal/benchmark/go.sum @@ -1,7 +1,7 @@ github.com/aws/aws-sdk-go v1.34.33 h1:ymkFm0rNPEOlgjyX3ojEd4zqzW6kGICBkqWs7LqgHtU= github.com/aws/aws-sdk-go v1.34.33/go.mod h1:H7NKnBqNVzoTJpGfLrQkkD+ytBA93eiDYi/+8rV9s48= -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= diff --git a/service/internal/endpoint-discovery/go.mod b/service/internal/endpoint-discovery/go.mod index 2f36b72b36f..6501aa606bd 100644 --- a/service/internal/endpoint-discovery/go.mod +++ b/service/internal/endpoint-discovery/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( github.com/aws/aws-sdk-go-v2 v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../../ diff --git a/service/internal/endpoint-discovery/go.sum b/service/internal/endpoint-discovery/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/internal/endpoint-discovery/go.sum +++ b/service/internal/endpoint-discovery/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/internal/eventstreamtesting/go.sum b/service/internal/eventstreamtesting/go.sum index 441f5df8111..932d041c390 100644 --- a/service/internal/eventstreamtesting/go.sum +++ b/service/internal/eventstreamtesting/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/internal/integrationtest/go.mod b/service/internal/integrationtest/go.mod index eac084a3504..0f2867a01eb 100644 --- a/service/internal/integrationtest/go.mod +++ b/service/internal/integrationtest/go.mod @@ -86,7 +86,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/wafregional v1.9.0 github.com/aws/aws-sdk-go-v2/service/wafv2 v1.15.0 github.com/aws/aws-sdk-go-v2/service/workspaces v1.13.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/service/internal/integrationtest/go.sum b/service/internal/integrationtest/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/internal/integrationtest/go.sum +++ b/service/internal/integrationtest/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/internal/presigned-url/go.mod b/service/internal/presigned-url/go.mod index b9ecca59e06..dd2a01203b3 100644 --- a/service/internal/presigned-url/go.mod +++ b/service/internal/presigned-url/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( github.com/aws/aws-sdk-go-v2 v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/service/internal/presigned-url/go.sum b/service/internal/presigned-url/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/internal/presigned-url/go.sum +++ b/service/internal/presigned-url/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/internal/s3shared/go.mod b/service/internal/s3shared/go.mod index d220af6efbc..db1c61eaa56 100644 --- a/service/internal/s3shared/go.mod +++ b/service/internal/s3shared/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( github.com/aws/aws-sdk-go-v2 v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../../ diff --git a/service/internal/s3shared/go.sum b/service/internal/s3shared/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/internal/s3shared/go.sum +++ b/service/internal/s3shared/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iot/api_client.go b/service/iot/api_client.go index 16b66e6751b..07d50420849 100644 --- a/service/iot/api_client.go +++ b/service/iot/api_client.go @@ -5,7 +5,9 @@ package iot import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/iot/go.mod b/service/iot/go.mod index a99467862d7..530000516c8 100644 --- a/service/iot/go.mod +++ b/service/iot/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iot/go.sum b/service/iot/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iot/go.sum +++ b/service/iot/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iot1clickdevicesservice/api_client.go b/service/iot1clickdevicesservice/api_client.go index 316f7739850..26a637cb105 100644 --- a/service/iot1clickdevicesservice/api_client.go +++ b/service/iot1clickdevicesservice/api_client.go @@ -4,7 +4,9 @@ package iot1clickdevicesservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iot1clickdevicesservice/go.mod b/service/iot1clickdevicesservice/go.mod index 650edaa7e5a..41da1b3ea73 100644 --- a/service/iot1clickdevicesservice/go.mod +++ b/service/iot1clickdevicesservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iot1clickdevicesservice/go.sum b/service/iot1clickdevicesservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iot1clickdevicesservice/go.sum +++ b/service/iot1clickdevicesservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iot1clickprojects/api_client.go b/service/iot1clickprojects/api_client.go index 032ca767368..2fc2e7b20f3 100644 --- a/service/iot1clickprojects/api_client.go +++ b/service/iot1clickprojects/api_client.go @@ -4,7 +4,9 @@ package iot1clickprojects import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iot1clickprojects/go.mod b/service/iot1clickprojects/go.mod index 3098fdd0264..82e4aa3d86b 100644 --- a/service/iot1clickprojects/go.mod +++ b/service/iot1clickprojects/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iot1clickprojects/go.sum b/service/iot1clickprojects/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iot1clickprojects/go.sum +++ b/service/iot1clickprojects/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotanalytics/api_client.go b/service/iotanalytics/api_client.go index dd2ec058633..2bc1affaa36 100644 --- a/service/iotanalytics/api_client.go +++ b/service/iotanalytics/api_client.go @@ -4,7 +4,9 @@ package iotanalytics import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotanalytics/go.mod b/service/iotanalytics/go.mod index 2c1009035cf..88dbf4c4557 100644 --- a/service/iotanalytics/go.mod +++ b/service/iotanalytics/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotanalytics/go.sum b/service/iotanalytics/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotanalytics/go.sum +++ b/service/iotanalytics/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotdataplane/api_client.go b/service/iotdataplane/api_client.go index 76ab9d9603c..936e07ec21c 100644 --- a/service/iotdataplane/api_client.go +++ b/service/iotdataplane/api_client.go @@ -4,7 +4,9 @@ package iotdataplane import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotdataplane/go.mod b/service/iotdataplane/go.mod index 3140cec2205..ce742b58fce 100644 --- a/service/iotdataplane/go.mod +++ b/service/iotdataplane/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotdataplane/go.sum b/service/iotdataplane/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotdataplane/go.sum +++ b/service/iotdataplane/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotdeviceadvisor/api_client.go b/service/iotdeviceadvisor/api_client.go index ec33531accf..2122d9a1544 100644 --- a/service/iotdeviceadvisor/api_client.go +++ b/service/iotdeviceadvisor/api_client.go @@ -4,7 +4,9 @@ package iotdeviceadvisor import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotdeviceadvisor/go.mod b/service/iotdeviceadvisor/go.mod index 78040386abe..59bb5ccb847 100644 --- a/service/iotdeviceadvisor/go.mod +++ b/service/iotdeviceadvisor/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotdeviceadvisor/go.sum b/service/iotdeviceadvisor/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotdeviceadvisor/go.sum +++ b/service/iotdeviceadvisor/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotevents/api_client.go b/service/iotevents/api_client.go index d9f5d002cfa..6734bc2b564 100644 --- a/service/iotevents/api_client.go +++ b/service/iotevents/api_client.go @@ -4,7 +4,9 @@ package iotevents import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotevents/go.mod b/service/iotevents/go.mod index 6d0afbc60ee..dd8640f4a13 100644 --- a/service/iotevents/go.mod +++ b/service/iotevents/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotevents/go.sum b/service/iotevents/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotevents/go.sum +++ b/service/iotevents/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ioteventsdata/api_client.go b/service/ioteventsdata/api_client.go index a421741634a..920346a1c26 100644 --- a/service/ioteventsdata/api_client.go +++ b/service/ioteventsdata/api_client.go @@ -4,7 +4,9 @@ package ioteventsdata import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ioteventsdata/go.mod b/service/ioteventsdata/go.mod index 85d25b355ed..e16926d0ae0 100644 --- a/service/ioteventsdata/go.mod +++ b/service/ioteventsdata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ioteventsdata/go.sum b/service/ioteventsdata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ioteventsdata/go.sum +++ b/service/ioteventsdata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotfleethub/api_client.go b/service/iotfleethub/api_client.go index b05ecfffdef..7ce38a8009b 100644 --- a/service/iotfleethub/api_client.go +++ b/service/iotfleethub/api_client.go @@ -5,7 +5,9 @@ package iotfleethub import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/iotfleethub/go.mod b/service/iotfleethub/go.mod index 2be14e4fe29..9b8c0ae861c 100644 --- a/service/iotfleethub/go.mod +++ b/service/iotfleethub/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotfleethub/go.sum b/service/iotfleethub/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotfleethub/go.sum +++ b/service/iotfleethub/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotjobsdataplane/api_client.go b/service/iotjobsdataplane/api_client.go index b22f0f93f2c..092a98d9938 100644 --- a/service/iotjobsdataplane/api_client.go +++ b/service/iotjobsdataplane/api_client.go @@ -4,7 +4,9 @@ package iotjobsdataplane import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotjobsdataplane/go.mod b/service/iotjobsdataplane/go.mod index a91802a04fe..9ff48b3b1cd 100644 --- a/service/iotjobsdataplane/go.mod +++ b/service/iotjobsdataplane/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotjobsdataplane/go.sum b/service/iotjobsdataplane/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotjobsdataplane/go.sum +++ b/service/iotjobsdataplane/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotsecuretunneling/api_client.go b/service/iotsecuretunneling/api_client.go index ef65b0d7980..5047daa9b26 100644 --- a/service/iotsecuretunneling/api_client.go +++ b/service/iotsecuretunneling/api_client.go @@ -4,7 +4,9 @@ package iotsecuretunneling import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotsecuretunneling/go.mod b/service/iotsecuretunneling/go.mod index bcae52d3c42..db165c931b3 100644 --- a/service/iotsecuretunneling/go.mod +++ b/service/iotsecuretunneling/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotsecuretunneling/go.sum b/service/iotsecuretunneling/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotsecuretunneling/go.sum +++ b/service/iotsecuretunneling/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotsitewise/api_client.go b/service/iotsitewise/api_client.go index 885686bf9b0..dbae101e48c 100644 --- a/service/iotsitewise/api_client.go +++ b/service/iotsitewise/api_client.go @@ -5,7 +5,9 @@ package iotsitewise import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/iotsitewise/go.mod b/service/iotsitewise/go.mod index d2d1e93e04b..e9ac585f9e4 100644 --- a/service/iotsitewise/go.mod +++ b/service/iotsitewise/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/iotsitewise/go.sum b/service/iotsitewise/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/iotsitewise/go.sum +++ b/service/iotsitewise/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/iotthingsgraph/api_client.go b/service/iotthingsgraph/api_client.go index 701115c2c04..31ee536ab32 100644 --- a/service/iotthingsgraph/api_client.go +++ b/service/iotthingsgraph/api_client.go @@ -4,7 +4,9 @@ package iotthingsgraph import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iotthingsgraph/go.mod b/service/iotthingsgraph/go.mod index 7b0b52603e3..32e0f106644 100644 --- a/service/iotthingsgraph/go.mod +++ b/service/iotthingsgraph/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotthingsgraph/go.sum b/service/iotthingsgraph/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotthingsgraph/go.sum +++ b/service/iotthingsgraph/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iottwinmaker/api_client.go b/service/iottwinmaker/api_client.go index d15490143c2..e8cfd38c0b1 100644 --- a/service/iottwinmaker/api_client.go +++ b/service/iottwinmaker/api_client.go @@ -4,7 +4,9 @@ package iottwinmaker import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/iottwinmaker/go.mod b/service/iottwinmaker/go.mod index 86f0a60cc6a..78cff7945bc 100644 --- a/service/iottwinmaker/go.mod +++ b/service/iottwinmaker/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iottwinmaker/go.sum b/service/iottwinmaker/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iottwinmaker/go.sum +++ b/service/iottwinmaker/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/iotwireless/api_client.go b/service/iotwireless/api_client.go index a2c11473dd1..dad6f01cd8b 100644 --- a/service/iotwireless/api_client.go +++ b/service/iotwireless/api_client.go @@ -5,7 +5,9 @@ package iotwireless import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/iotwireless/go.mod b/service/iotwireless/go.mod index 8a750190686..f0614ca916e 100644 --- a/service/iotwireless/go.mod +++ b/service/iotwireless/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/iotwireless/go.sum b/service/iotwireless/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/iotwireless/go.sum +++ b/service/iotwireless/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ivs/api_client.go b/service/ivs/api_client.go index 598db3f0f63..d574cf44486 100644 --- a/service/ivs/api_client.go +++ b/service/ivs/api_client.go @@ -4,7 +4,9 @@ package ivs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ivs/go.mod b/service/ivs/go.mod index 9e31dc7d208..387a6a8f743 100644 --- a/service/ivs/go.mod +++ b/service/ivs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ivs/go.sum b/service/ivs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ivs/go.sum +++ b/service/ivs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kafka/api_client.go b/service/kafka/api_client.go index 7bf5ee3d396..028d8f20f33 100644 --- a/service/kafka/api_client.go +++ b/service/kafka/api_client.go @@ -4,7 +4,9 @@ package kafka import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kafka/go.mod b/service/kafka/go.mod index 0ee66c7298e..b9d7f37123f 100644 --- a/service/kafka/go.mod +++ b/service/kafka/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kafka/go.sum b/service/kafka/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kafka/go.sum +++ b/service/kafka/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kafkaconnect/api_client.go b/service/kafkaconnect/api_client.go index bfb279bc8b3..c013f09bdce 100644 --- a/service/kafkaconnect/api_client.go +++ b/service/kafkaconnect/api_client.go @@ -4,7 +4,9 @@ package kafkaconnect import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kafkaconnect/go.mod b/service/kafkaconnect/go.mod index 8f997328765..b551ae6b943 100644 --- a/service/kafkaconnect/go.mod +++ b/service/kafkaconnect/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kafkaconnect/go.sum b/service/kafkaconnect/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kafkaconnect/go.sum +++ b/service/kafkaconnect/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kendra/api_client.go b/service/kendra/api_client.go index f499c9bd47c..f1b4579b255 100644 --- a/service/kendra/api_client.go +++ b/service/kendra/api_client.go @@ -5,7 +5,9 @@ package kendra import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/kendra/go.mod b/service/kendra/go.mod index 867b2aefe5f..e8709af3293 100644 --- a/service/kendra/go.mod +++ b/service/kendra/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kendra/go.sum b/service/kendra/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kendra/go.sum +++ b/service/kendra/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesis/api_client.go b/service/kinesis/api_client.go index 9cc1ecf2079..af2a6b9c43e 100644 --- a/service/kinesis/api_client.go +++ b/service/kinesis/api_client.go @@ -4,7 +4,9 @@ package kinesis import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -169,12 +197,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -184,10 +214,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -242,6 +306,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesis/go.mod b/service/kinesis/go.mod index 2ed7cf6d907..0537c6aefe0 100644 --- a/service/kinesis/go.mod +++ b/service/kinesis/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.1.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/kinesis/go.sum b/service/kinesis/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/kinesis/go.sum +++ b/service/kinesis/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/kinesis/internal/testing/go.mod b/service/kinesis/internal/testing/go.mod index b0359b62706..0d430ac7a2d 100644 --- a/service/kinesis/internal/testing/go.mod +++ b/service/kinesis/internal/testing/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.1.0 github.com/aws/aws-sdk-go-v2/service/internal/eventstreamtesting v1.0.6 github.com/aws/aws-sdk-go-v2/service/kinesis v1.12.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/service/kinesis/internal/testing/go.sum b/service/kinesis/internal/testing/go.sum index 86c59f09cf9..623c8a377c2 100644 --- a/service/kinesis/internal/testing/go.sum +++ b/service/kinesis/internal/testing/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/kinesisanalytics/api_client.go b/service/kinesisanalytics/api_client.go index 249edcd801e..697dda6bd10 100644 --- a/service/kinesisanalytics/api_client.go +++ b/service/kinesisanalytics/api_client.go @@ -4,7 +4,9 @@ package kinesisanalytics import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisanalytics/go.mod b/service/kinesisanalytics/go.mod index 55507245bae..df448209a72 100644 --- a/service/kinesisanalytics/go.mod +++ b/service/kinesisanalytics/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisanalytics/go.sum b/service/kinesisanalytics/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisanalytics/go.sum +++ b/service/kinesisanalytics/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesisanalyticsv2/api_client.go b/service/kinesisanalyticsv2/api_client.go index 4086730c560..3771db0a880 100644 --- a/service/kinesisanalyticsv2/api_client.go +++ b/service/kinesisanalyticsv2/api_client.go @@ -4,7 +4,9 @@ package kinesisanalyticsv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisanalyticsv2/go.mod b/service/kinesisanalyticsv2/go.mod index dad718e71c0..ebe43c3673c 100644 --- a/service/kinesisanalyticsv2/go.mod +++ b/service/kinesisanalyticsv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisanalyticsv2/go.sum b/service/kinesisanalyticsv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisanalyticsv2/go.sum +++ b/service/kinesisanalyticsv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesisvideo/api_client.go b/service/kinesisvideo/api_client.go index 3d1f087624f..9f29a9f8323 100644 --- a/service/kinesisvideo/api_client.go +++ b/service/kinesisvideo/api_client.go @@ -4,7 +4,9 @@ package kinesisvideo import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisvideo/go.mod b/service/kinesisvideo/go.mod index 455be71b94a..954c12cebb9 100644 --- a/service/kinesisvideo/go.mod +++ b/service/kinesisvideo/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisvideo/go.sum b/service/kinesisvideo/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisvideo/go.sum +++ b/service/kinesisvideo/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesisvideoarchivedmedia/api_client.go b/service/kinesisvideoarchivedmedia/api_client.go index cf8e31b798e..208be4206b0 100644 --- a/service/kinesisvideoarchivedmedia/api_client.go +++ b/service/kinesisvideoarchivedmedia/api_client.go @@ -4,7 +4,9 @@ package kinesisvideoarchivedmedia import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisvideoarchivedmedia/go.mod b/service/kinesisvideoarchivedmedia/go.mod index 44dfc24265d..924684f7bb8 100644 --- a/service/kinesisvideoarchivedmedia/go.mod +++ b/service/kinesisvideoarchivedmedia/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisvideoarchivedmedia/go.sum b/service/kinesisvideoarchivedmedia/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisvideoarchivedmedia/go.sum +++ b/service/kinesisvideoarchivedmedia/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesisvideomedia/api_client.go b/service/kinesisvideomedia/api_client.go index 3edaa11f41d..ec5dd243f1d 100644 --- a/service/kinesisvideomedia/api_client.go +++ b/service/kinesisvideomedia/api_client.go @@ -4,7 +4,9 @@ package kinesisvideomedia import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisvideomedia/go.mod b/service/kinesisvideomedia/go.mod index d17c8f28101..2a91e324afb 100644 --- a/service/kinesisvideomedia/go.mod +++ b/service/kinesisvideomedia/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisvideomedia/go.sum b/service/kinesisvideomedia/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisvideomedia/go.sum +++ b/service/kinesisvideomedia/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kinesisvideosignaling/api_client.go b/service/kinesisvideosignaling/api_client.go index 21e0e36482c..df18e2b8437 100644 --- a/service/kinesisvideosignaling/api_client.go +++ b/service/kinesisvideosignaling/api_client.go @@ -4,7 +4,9 @@ package kinesisvideosignaling import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kinesisvideosignaling/go.mod b/service/kinesisvideosignaling/go.mod index 8bbcb0d58fd..fc9af3c9358 100644 --- a/service/kinesisvideosignaling/go.mod +++ b/service/kinesisvideosignaling/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kinesisvideosignaling/go.sum b/service/kinesisvideosignaling/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kinesisvideosignaling/go.sum +++ b/service/kinesisvideosignaling/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/kms/api_client.go b/service/kms/api_client.go index 0bc829e22b9..d2ec07ec845 100644 --- a/service/kms/api_client.go +++ b/service/kms/api_client.go @@ -4,7 +4,9 @@ package kms import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/kms/go.mod b/service/kms/go.mod index f2477979308..d5359401d84 100644 --- a/service/kms/go.mod +++ b/service/kms/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/kms/go.sum b/service/kms/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/kms/go.sum +++ b/service/kms/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lakeformation/api_client.go b/service/lakeformation/api_client.go index c0d63664a88..0e903036bb8 100644 --- a/service/lakeformation/api_client.go +++ b/service/lakeformation/api_client.go @@ -4,7 +4,9 @@ package lakeformation import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lakeformation/go.mod b/service/lakeformation/go.mod index 9c75efb608c..c01a242b8aa 100644 --- a/service/lakeformation/go.mod +++ b/service/lakeformation/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lakeformation/go.sum b/service/lakeformation/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lakeformation/go.sum +++ b/service/lakeformation/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lambda/api_client.go b/service/lambda/api_client.go index 770dd4ca943..f021cf0be77 100644 --- a/service/lambda/api_client.go +++ b/service/lambda/api_client.go @@ -4,7 +4,9 @@ package lambda import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lambda/go.mod b/service/lambda/go.mod index 2cfeefbf2b6..2a30199012a 100644 --- a/service/lambda/go.mod +++ b/service/lambda/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/lambda/go.sum b/service/lambda/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/lambda/go.sum +++ b/service/lambda/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/lexmodelbuildingservice/api_client.go b/service/lexmodelbuildingservice/api_client.go index 3aed57b2ec5..c1b32b7fe38 100644 --- a/service/lexmodelbuildingservice/api_client.go +++ b/service/lexmodelbuildingservice/api_client.go @@ -4,7 +4,9 @@ package lexmodelbuildingservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lexmodelbuildingservice/go.mod b/service/lexmodelbuildingservice/go.mod index 88a4b8dc9b3..2cd1ac00e27 100644 --- a/service/lexmodelbuildingservice/go.mod +++ b/service/lexmodelbuildingservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lexmodelbuildingservice/go.sum b/service/lexmodelbuildingservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lexmodelbuildingservice/go.sum +++ b/service/lexmodelbuildingservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lexmodelsv2/api_client.go b/service/lexmodelsv2/api_client.go index 1fa3b77b462..891a38b12a8 100644 --- a/service/lexmodelsv2/api_client.go +++ b/service/lexmodelsv2/api_client.go @@ -4,7 +4,9 @@ package lexmodelsv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lexmodelsv2/go.mod b/service/lexmodelsv2/go.mod index e717ecc6220..80b41f864c0 100644 --- a/service/lexmodelsv2/go.mod +++ b/service/lexmodelsv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/lexmodelsv2/go.sum b/service/lexmodelsv2/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/lexmodelsv2/go.sum +++ b/service/lexmodelsv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/lexruntimeservice/api_client.go b/service/lexruntimeservice/api_client.go index 7085144c4d0..634e8c360d3 100644 --- a/service/lexruntimeservice/api_client.go +++ b/service/lexruntimeservice/api_client.go @@ -4,7 +4,9 @@ package lexruntimeservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lexruntimeservice/go.mod b/service/lexruntimeservice/go.mod index 15c147df716..62d52d696e9 100644 --- a/service/lexruntimeservice/go.mod +++ b/service/lexruntimeservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lexruntimeservice/go.sum b/service/lexruntimeservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lexruntimeservice/go.sum +++ b/service/lexruntimeservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lexruntimev2/api_client.go b/service/lexruntimev2/api_client.go index 7151f4c188b..e1503465929 100644 --- a/service/lexruntimev2/api_client.go +++ b/service/lexruntimev2/api_client.go @@ -4,7 +4,9 @@ package lexruntimev2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +198,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +215,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +307,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lexruntimev2/go.mod b/service/lexruntimev2/go.mod index 786c47ff657..041b4f4073b 100644 --- a/service/lexruntimev2/go.mod +++ b/service/lexruntimev2/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.1.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lexruntimev2/go.sum b/service/lexruntimev2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lexruntimev2/go.sum +++ b/service/lexruntimev2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/licensemanager/api_client.go b/service/licensemanager/api_client.go index a09b8714518..0696e8650e4 100644 --- a/service/licensemanager/api_client.go +++ b/service/licensemanager/api_client.go @@ -4,7 +4,9 @@ package licensemanager import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/licensemanager/go.mod b/service/licensemanager/go.mod index 3bd82c9b043..c541f57b468 100644 --- a/service/licensemanager/go.mod +++ b/service/licensemanager/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/licensemanager/go.sum b/service/licensemanager/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/licensemanager/go.sum +++ b/service/licensemanager/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lightsail/api_client.go b/service/lightsail/api_client.go index 60a6d9401bb..e46502484f3 100644 --- a/service/lightsail/api_client.go +++ b/service/lightsail/api_client.go @@ -4,7 +4,9 @@ package lightsail import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lightsail/go.mod b/service/lightsail/go.mod index e713fa3e601..3aadaf0f954 100644 --- a/service/lightsail/go.mod +++ b/service/lightsail/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lightsail/go.sum b/service/lightsail/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lightsail/go.sum +++ b/service/lightsail/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/location/api_client.go b/service/location/api_client.go index 12f9b642559..5b1a5ff65c1 100644 --- a/service/location/api_client.go +++ b/service/location/api_client.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/location/go.mod b/service/location/go.mod index 30e22fe8b42..faa89c0f42c 100644 --- a/service/location/go.mod +++ b/service/location/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/location/go.sum b/service/location/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/location/go.sum +++ b/service/location/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lookoutequipment/api_client.go b/service/lookoutequipment/api_client.go index 9ccc3594582..b4c7e7aa065 100644 --- a/service/lookoutequipment/api_client.go +++ b/service/lookoutequipment/api_client.go @@ -5,7 +5,9 @@ package lookoutequipment import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/lookoutequipment/go.mod b/service/lookoutequipment/go.mod index d6f70e6472f..0c4eb734ac1 100644 --- a/service/lookoutequipment/go.mod +++ b/service/lookoutequipment/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lookoutequipment/go.sum b/service/lookoutequipment/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lookoutequipment/go.sum +++ b/service/lookoutequipment/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lookoutmetrics/api_client.go b/service/lookoutmetrics/api_client.go index efd21ee6616..767a6807f44 100644 --- a/service/lookoutmetrics/api_client.go +++ b/service/lookoutmetrics/api_client.go @@ -4,7 +4,9 @@ package lookoutmetrics import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/lookoutmetrics/go.mod b/service/lookoutmetrics/go.mod index 9f3f600faee..4150bbe055b 100644 --- a/service/lookoutmetrics/go.mod +++ b/service/lookoutmetrics/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lookoutmetrics/go.sum b/service/lookoutmetrics/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lookoutmetrics/go.sum +++ b/service/lookoutmetrics/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/lookoutvision/api_client.go b/service/lookoutvision/api_client.go index 293b8d102b1..3c6184136b1 100644 --- a/service/lookoutvision/api_client.go +++ b/service/lookoutvision/api_client.go @@ -5,7 +5,9 @@ package lookoutvision import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/lookoutvision/go.mod b/service/lookoutvision/go.mod index a1e46f6266d..5853033923a 100644 --- a/service/lookoutvision/go.mod +++ b/service/lookoutvision/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/lookoutvision/go.sum b/service/lookoutvision/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/lookoutvision/go.sum +++ b/service/lookoutvision/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/machinelearning/api_client.go b/service/machinelearning/api_client.go index ac2042157ee..735ff04bd1d 100644 --- a/service/machinelearning/api_client.go +++ b/service/machinelearning/api_client.go @@ -4,7 +4,9 @@ package machinelearning import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/machinelearning/go.mod b/service/machinelearning/go.mod index 474429a9d6a..73c35149621 100644 --- a/service/machinelearning/go.mod +++ b/service/machinelearning/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/machinelearning/go.sum b/service/machinelearning/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/machinelearning/go.sum +++ b/service/machinelearning/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/macie/api_client.go b/service/macie/api_client.go index 392ba5756d3..a56c68a241f 100644 --- a/service/macie/api_client.go +++ b/service/macie/api_client.go @@ -4,7 +4,9 @@ package macie import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/macie/go.mod b/service/macie/go.mod index a6a380fc722..e6f1fd2df37 100644 --- a/service/macie/go.mod +++ b/service/macie/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/macie/go.sum b/service/macie/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/macie/go.sum +++ b/service/macie/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/macie2/api_client.go b/service/macie2/api_client.go index 4ca29964d2b..148b751e216 100644 --- a/service/macie2/api_client.go +++ b/service/macie2/api_client.go @@ -5,7 +5,9 @@ package macie2 import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/macie2/go.mod b/service/macie2/go.mod index a1b0707a706..80ddd458046 100644 --- a/service/macie2/go.mod +++ b/service/macie2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/macie2/go.sum b/service/macie2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/macie2/go.sum +++ b/service/macie2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/managedblockchain/api_client.go b/service/managedblockchain/api_client.go index 07005e54c5e..8b0b217f7d4 100644 --- a/service/managedblockchain/api_client.go +++ b/service/managedblockchain/api_client.go @@ -5,7 +5,9 @@ package managedblockchain import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/managedblockchain/go.mod b/service/managedblockchain/go.mod index 2ef6f1bfc95..b0e470f713c 100644 --- a/service/managedblockchain/go.mod +++ b/service/managedblockchain/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/managedblockchain/go.sum b/service/managedblockchain/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/managedblockchain/go.sum +++ b/service/managedblockchain/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/marketplacecatalog/api_client.go b/service/marketplacecatalog/api_client.go index a8118344300..7b18aefdc6e 100644 --- a/service/marketplacecatalog/api_client.go +++ b/service/marketplacecatalog/api_client.go @@ -4,7 +4,9 @@ package marketplacecatalog import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/marketplacecatalog/go.mod b/service/marketplacecatalog/go.mod index 958b69bc465..40388b174a0 100644 --- a/service/marketplacecatalog/go.mod +++ b/service/marketplacecatalog/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/marketplacecatalog/go.sum b/service/marketplacecatalog/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/marketplacecatalog/go.sum +++ b/service/marketplacecatalog/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/marketplacecommerceanalytics/api_client.go b/service/marketplacecommerceanalytics/api_client.go index 1b91404b043..581a879cc72 100644 --- a/service/marketplacecommerceanalytics/api_client.go +++ b/service/marketplacecommerceanalytics/api_client.go @@ -4,7 +4,9 @@ package marketplacecommerceanalytics import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/marketplacecommerceanalytics/go.mod b/service/marketplacecommerceanalytics/go.mod index 26d04d53073..6f09028028d 100644 --- a/service/marketplacecommerceanalytics/go.mod +++ b/service/marketplacecommerceanalytics/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/marketplacecommerceanalytics/go.sum b/service/marketplacecommerceanalytics/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/marketplacecommerceanalytics/go.sum +++ b/service/marketplacecommerceanalytics/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/marketplaceentitlementservice/api_client.go b/service/marketplaceentitlementservice/api_client.go index 9d15c76de37..be17d171315 100644 --- a/service/marketplaceentitlementservice/api_client.go +++ b/service/marketplaceentitlementservice/api_client.go @@ -4,7 +4,9 @@ package marketplaceentitlementservice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/marketplaceentitlementservice/go.mod b/service/marketplaceentitlementservice/go.mod index 1a4f31b3912..335ad9e123d 100644 --- a/service/marketplaceentitlementservice/go.mod +++ b/service/marketplaceentitlementservice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/marketplaceentitlementservice/go.sum b/service/marketplaceentitlementservice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/marketplaceentitlementservice/go.sum +++ b/service/marketplaceentitlementservice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/marketplacemetering/api_client.go b/service/marketplacemetering/api_client.go index a2fb2d1dfa1..f3afe61cd47 100644 --- a/service/marketplacemetering/api_client.go +++ b/service/marketplacemetering/api_client.go @@ -4,7 +4,9 @@ package marketplacemetering import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/marketplacemetering/go.mod b/service/marketplacemetering/go.mod index 965f0ae3148..7cba7168851 100644 --- a/service/marketplacemetering/go.mod +++ b/service/marketplacemetering/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/marketplacemetering/go.sum b/service/marketplacemetering/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/marketplacemetering/go.sum +++ b/service/marketplacemetering/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mediaconnect/api_client.go b/service/mediaconnect/api_client.go index be4d152e32d..51b7ec82ec9 100644 --- a/service/mediaconnect/api_client.go +++ b/service/mediaconnect/api_client.go @@ -4,7 +4,9 @@ package mediaconnect import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediaconnect/go.mod b/service/mediaconnect/go.mod index a57eb164e2e..d860ba093e6 100644 --- a/service/mediaconnect/go.mod +++ b/service/mediaconnect/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/mediaconnect/go.sum b/service/mediaconnect/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/mediaconnect/go.sum +++ b/service/mediaconnect/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/mediaconvert/api_client.go b/service/mediaconvert/api_client.go index 4c1bdd05a7b..ac92d2f83db 100644 --- a/service/mediaconvert/api_client.go +++ b/service/mediaconvert/api_client.go @@ -5,7 +5,9 @@ package mediaconvert import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/mediaconvert/go.mod b/service/mediaconvert/go.mod index a9a24606ba9..8ec108eb906 100644 --- a/service/mediaconvert/go.mod +++ b/service/mediaconvert/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediaconvert/go.sum b/service/mediaconvert/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediaconvert/go.sum +++ b/service/mediaconvert/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/medialive/api_client.go b/service/medialive/api_client.go index d86010cdfb2..a41f7d50202 100644 --- a/service/medialive/api_client.go +++ b/service/medialive/api_client.go @@ -5,7 +5,9 @@ package medialive import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/medialive/go.mod b/service/medialive/go.mod index b65ea4e9776..f81b1b89a1e 100644 --- a/service/medialive/go.mod +++ b/service/medialive/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/medialive/go.sum b/service/medialive/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/medialive/go.sum +++ b/service/medialive/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/mediapackage/api_client.go b/service/mediapackage/api_client.go index db77449cfbf..d3760f9682f 100644 --- a/service/mediapackage/api_client.go +++ b/service/mediapackage/api_client.go @@ -4,7 +4,9 @@ package mediapackage import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediapackage/go.mod b/service/mediapackage/go.mod index a03c982d56f..f8a9bfd07d8 100644 --- a/service/mediapackage/go.mod +++ b/service/mediapackage/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediapackage/go.sum b/service/mediapackage/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediapackage/go.sum +++ b/service/mediapackage/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mediapackagevod/api_client.go b/service/mediapackagevod/api_client.go index 4d602749411..bfdc99af738 100644 --- a/service/mediapackagevod/api_client.go +++ b/service/mediapackagevod/api_client.go @@ -4,7 +4,9 @@ package mediapackagevod import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediapackagevod/go.mod b/service/mediapackagevod/go.mod index d27f2bd64c8..423de7dbedc 100644 --- a/service/mediapackagevod/go.mod +++ b/service/mediapackagevod/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediapackagevod/go.sum b/service/mediapackagevod/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediapackagevod/go.sum +++ b/service/mediapackagevod/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mediastore/api_client.go b/service/mediastore/api_client.go index fba84f951d3..5bae8a644e5 100644 --- a/service/mediastore/api_client.go +++ b/service/mediastore/api_client.go @@ -4,7 +4,9 @@ package mediastore import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediastore/go.mod b/service/mediastore/go.mod index 9c5d0a1eb9c..56c39e9f19b 100644 --- a/service/mediastore/go.mod +++ b/service/mediastore/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediastore/go.sum b/service/mediastore/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediastore/go.sum +++ b/service/mediastore/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mediastoredata/api_client.go b/service/mediastoredata/api_client.go index bf3e5a5a087..188742fa233 100644 --- a/service/mediastoredata/api_client.go +++ b/service/mediastoredata/api_client.go @@ -4,7 +4,9 @@ package mediastoredata import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediastoredata/go.mod b/service/mediastoredata/go.mod index d6e01ea31c8..ba5ca4fca62 100644 --- a/service/mediastoredata/go.mod +++ b/service/mediastoredata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediastoredata/go.sum b/service/mediastoredata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediastoredata/go.sum +++ b/service/mediastoredata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mediatailor/api_client.go b/service/mediatailor/api_client.go index 1c0f354cb20..df7d92df33f 100644 --- a/service/mediatailor/api_client.go +++ b/service/mediatailor/api_client.go @@ -4,7 +4,9 @@ package mediatailor import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mediatailor/go.mod b/service/mediatailor/go.mod index 89f15ac339d..5756646b9bb 100644 --- a/service/mediatailor/go.mod +++ b/service/mediatailor/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mediatailor/go.sum b/service/mediatailor/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mediatailor/go.sum +++ b/service/mediatailor/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/memorydb/api_client.go b/service/memorydb/api_client.go index 74adb00bf3d..06b635397e2 100644 --- a/service/memorydb/api_client.go +++ b/service/memorydb/api_client.go @@ -4,7 +4,9 @@ package memorydb import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/memorydb/go.mod b/service/memorydb/go.mod index 9afaf556064..1f74aeeda5f 100644 --- a/service/memorydb/go.mod +++ b/service/memorydb/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/memorydb/go.sum b/service/memorydb/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/memorydb/go.sum +++ b/service/memorydb/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mgn/api_client.go b/service/mgn/api_client.go index 305aa603cde..b68537ecd68 100644 --- a/service/mgn/api_client.go +++ b/service/mgn/api_client.go @@ -4,7 +4,9 @@ package mgn import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mgn/go.mod b/service/mgn/go.mod index f8604f86348..87046017dd0 100644 --- a/service/mgn/go.mod +++ b/service/mgn/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mgn/go.sum b/service/mgn/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mgn/go.sum +++ b/service/mgn/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/migrationhub/api_client.go b/service/migrationhub/api_client.go index 9f94687cc86..ca5a4f6c888 100644 --- a/service/migrationhub/api_client.go +++ b/service/migrationhub/api_client.go @@ -4,7 +4,9 @@ package migrationhub import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/migrationhub/go.mod b/service/migrationhub/go.mod index 49e452c6826..02787da3aca 100644 --- a/service/migrationhub/go.mod +++ b/service/migrationhub/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/migrationhub/go.sum b/service/migrationhub/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/migrationhub/go.sum +++ b/service/migrationhub/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/migrationhubconfig/api_client.go b/service/migrationhubconfig/api_client.go index f2015d54ab1..ab902ffdee6 100644 --- a/service/migrationhubconfig/api_client.go +++ b/service/migrationhubconfig/api_client.go @@ -4,7 +4,9 @@ package migrationhubconfig import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/migrationhubconfig/go.mod b/service/migrationhubconfig/go.mod index 4ebf7b05d37..a186f9b1345 100644 --- a/service/migrationhubconfig/go.mod +++ b/service/migrationhubconfig/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/migrationhubconfig/go.sum b/service/migrationhubconfig/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/migrationhubconfig/go.sum +++ b/service/migrationhubconfig/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/migrationhubrefactorspaces/api_client.go b/service/migrationhubrefactorspaces/api_client.go index 0ab54d9a6c0..bc9133f46d8 100644 --- a/service/migrationhubrefactorspaces/api_client.go +++ b/service/migrationhubrefactorspaces/api_client.go @@ -5,7 +5,9 @@ package migrationhubrefactorspaces import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/migrationhubrefactorspaces/go.mod b/service/migrationhubrefactorspaces/go.mod index 49669e3e22f..4a300c66ea5 100644 --- a/service/migrationhubrefactorspaces/go.mod +++ b/service/migrationhubrefactorspaces/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/migrationhubrefactorspaces/go.sum b/service/migrationhubrefactorspaces/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/migrationhubrefactorspaces/go.sum +++ b/service/migrationhubrefactorspaces/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/migrationhubstrategy/api_client.go b/service/migrationhubstrategy/api_client.go index ec6fa0d3025..d2a3c51aea0 100644 --- a/service/migrationhubstrategy/api_client.go +++ b/service/migrationhubstrategy/api_client.go @@ -4,7 +4,9 @@ package migrationhubstrategy import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/migrationhubstrategy/go.mod b/service/migrationhubstrategy/go.mod index b76321490bd..0c3791a3f6b 100644 --- a/service/migrationhubstrategy/go.mod +++ b/service/migrationhubstrategy/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/migrationhubstrategy/go.sum b/service/migrationhubstrategy/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/migrationhubstrategy/go.sum +++ b/service/migrationhubstrategy/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mobile/api_client.go b/service/mobile/api_client.go index 9a31eeca0c9..642712811fb 100644 --- a/service/mobile/api_client.go +++ b/service/mobile/api_client.go @@ -4,7 +4,9 @@ package mobile import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mobile/go.mod b/service/mobile/go.mod index 4a5b04dd822..0ae54617957 100644 --- a/service/mobile/go.mod +++ b/service/mobile/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mobile/go.sum b/service/mobile/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mobile/go.sum +++ b/service/mobile/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mq/api_client.go b/service/mq/api_client.go index 840d085a24c..96637a23df2 100644 --- a/service/mq/api_client.go +++ b/service/mq/api_client.go @@ -5,7 +5,9 @@ package mq import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/mq/go.mod b/service/mq/go.mod index c18dcd61598..22a1f716b00 100644 --- a/service/mq/go.mod +++ b/service/mq/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mq/go.sum b/service/mq/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mq/go.sum +++ b/service/mq/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mturk/api_client.go b/service/mturk/api_client.go index 073b943f166..9f4f23a7e5e 100644 --- a/service/mturk/api_client.go +++ b/service/mturk/api_client.go @@ -4,7 +4,9 @@ package mturk import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mturk/go.mod b/service/mturk/go.mod index aed7742e1b1..3c0d8d858ba 100644 --- a/service/mturk/go.mod +++ b/service/mturk/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mturk/go.sum b/service/mturk/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mturk/go.sum +++ b/service/mturk/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/mwaa/api_client.go b/service/mwaa/api_client.go index 3d3dc4c5911..3015f4caeb9 100644 --- a/service/mwaa/api_client.go +++ b/service/mwaa/api_client.go @@ -4,7 +4,9 @@ package mwaa import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/mwaa/go.mod b/service/mwaa/go.mod index ca45f8603a8..bf71d61b4fe 100644 --- a/service/mwaa/go.mod +++ b/service/mwaa/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/mwaa/go.sum b/service/mwaa/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/mwaa/go.sum +++ b/service/mwaa/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/neptune/api_client.go b/service/neptune/api_client.go index 3ec95e82120..693ffb1a752 100644 --- a/service/neptune/api_client.go +++ b/service/neptune/api_client.go @@ -4,7 +4,9 @@ package neptune import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/protocol/query" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -68,6 +73,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -87,9 +96,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -117,6 +139,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -169,12 +197,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -184,10 +214,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -242,6 +306,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/neptune/go.mod b/service/neptune/go.mod index a870ed5a55d..7daf1ccea54 100644 --- a/service/neptune/go.mod +++ b/service/neptune/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/neptune/go.sum b/service/neptune/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/neptune/go.sum +++ b/service/neptune/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/networkfirewall/api_client.go b/service/networkfirewall/api_client.go index 4cfa78ee1a5..f93f04ba8c2 100644 --- a/service/networkfirewall/api_client.go +++ b/service/networkfirewall/api_client.go @@ -4,7 +4,9 @@ package networkfirewall import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/networkfirewall/go.mod b/service/networkfirewall/go.mod index b6c51be8807..d74e7e01583 100644 --- a/service/networkfirewall/go.mod +++ b/service/networkfirewall/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/networkfirewall/go.sum b/service/networkfirewall/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/networkfirewall/go.sum +++ b/service/networkfirewall/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/networkmanager/api_client.go b/service/networkmanager/api_client.go index cc3409e23da..f9f69b63249 100644 --- a/service/networkmanager/api_client.go +++ b/service/networkmanager/api_client.go @@ -5,7 +5,9 @@ package networkmanager import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/networkmanager/go.mod b/service/networkmanager/go.mod index 3e032390f5a..83680f5bb59 100644 --- a/service/networkmanager/go.mod +++ b/service/networkmanager/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/networkmanager/go.sum b/service/networkmanager/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/networkmanager/go.sum +++ b/service/networkmanager/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/nimble/api_client.go b/service/nimble/api_client.go index cb17a1b7886..584cdec5ce1 100644 --- a/service/nimble/api_client.go +++ b/service/nimble/api_client.go @@ -5,7 +5,9 @@ package nimble import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/nimble/go.mod b/service/nimble/go.mod index 02893ee8063..9fbd210531a 100644 --- a/service/nimble/go.mod +++ b/service/nimble/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/nimble/go.sum b/service/nimble/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/nimble/go.sum +++ b/service/nimble/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/opensearch/api_client.go b/service/opensearch/api_client.go index e74881c4f9d..679ef9912d2 100644 --- a/service/opensearch/api_client.go +++ b/service/opensearch/api_client.go @@ -4,7 +4,9 @@ package opensearch import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/opensearch/go.mod b/service/opensearch/go.mod index fb5556bdbc2..76667e59bf9 100644 --- a/service/opensearch/go.mod +++ b/service/opensearch/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/opensearch/go.sum b/service/opensearch/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/opensearch/go.sum +++ b/service/opensearch/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/opsworks/api_client.go b/service/opsworks/api_client.go index c436653ab23..583ecd2f190 100644 --- a/service/opsworks/api_client.go +++ b/service/opsworks/api_client.go @@ -4,7 +4,9 @@ package opsworks import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/opsworks/go.mod b/service/opsworks/go.mod index 1291e0eb663..c5bb063c6c4 100644 --- a/service/opsworks/go.mod +++ b/service/opsworks/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/opsworks/go.sum b/service/opsworks/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/opsworks/go.sum +++ b/service/opsworks/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/opsworkscm/api_client.go b/service/opsworkscm/api_client.go index 0f248c4ea28..dc864f5343f 100644 --- a/service/opsworkscm/api_client.go +++ b/service/opsworkscm/api_client.go @@ -4,7 +4,9 @@ package opsworkscm import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/opsworkscm/go.mod b/service/opsworkscm/go.mod index 88acaea4885..8f9495f2177 100644 --- a/service/opsworkscm/go.mod +++ b/service/opsworkscm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/opsworkscm/go.sum b/service/opsworkscm/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/opsworkscm/go.sum +++ b/service/opsworkscm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/organizations/api_client.go b/service/organizations/api_client.go index 0ce750bf99e..257e3120747 100644 --- a/service/organizations/api_client.go +++ b/service/organizations/api_client.go @@ -4,7 +4,9 @@ package organizations import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/organizations/go.mod b/service/organizations/go.mod index 5b16745fa9d..e020ab46a81 100644 --- a/service/organizations/go.mod +++ b/service/organizations/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/organizations/go.sum b/service/organizations/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/organizations/go.sum +++ b/service/organizations/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/outposts/api_client.go b/service/outposts/api_client.go index 9803e6c1925..d76dd61007a 100644 --- a/service/outposts/api_client.go +++ b/service/outposts/api_client.go @@ -4,7 +4,9 @@ package outposts import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/outposts/go.mod b/service/outposts/go.mod index c3061f5521c..d57f6a46c78 100644 --- a/service/outposts/go.mod +++ b/service/outposts/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/outposts/go.sum b/service/outposts/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/outposts/go.sum +++ b/service/outposts/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/panorama/api_client.go b/service/panorama/api_client.go index 851f4742618..699c1e1d7d3 100644 --- a/service/panorama/api_client.go +++ b/service/panorama/api_client.go @@ -4,7 +4,9 @@ package panorama import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/panorama/go.mod b/service/panorama/go.mod index 7a2ddff170b..e8631829503 100644 --- a/service/panorama/go.mod +++ b/service/panorama/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/panorama/go.sum b/service/panorama/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/panorama/go.sum +++ b/service/panorama/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/personalize/api_client.go b/service/personalize/api_client.go index 2c9ad427c64..3884adf7d35 100644 --- a/service/personalize/api_client.go +++ b/service/personalize/api_client.go @@ -4,7 +4,9 @@ package personalize import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/personalize/go.mod b/service/personalize/go.mod index 08bcfd0a5c9..2047f2469d3 100644 --- a/service/personalize/go.mod +++ b/service/personalize/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/personalize/go.sum b/service/personalize/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/personalize/go.sum +++ b/service/personalize/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/personalizeevents/api_client.go b/service/personalizeevents/api_client.go index 7b87a501aa7..44607a03abf 100644 --- a/service/personalizeevents/api_client.go +++ b/service/personalizeevents/api_client.go @@ -4,7 +4,9 @@ package personalizeevents import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/personalizeevents/go.mod b/service/personalizeevents/go.mod index 219fc15a89a..456d449225a 100644 --- a/service/personalizeevents/go.mod +++ b/service/personalizeevents/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/personalizeevents/go.sum b/service/personalizeevents/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/personalizeevents/go.sum +++ b/service/personalizeevents/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/personalizeruntime/api_client.go b/service/personalizeruntime/api_client.go index 8576310fb69..60a3a7926f5 100644 --- a/service/personalizeruntime/api_client.go +++ b/service/personalizeruntime/api_client.go @@ -4,7 +4,9 @@ package personalizeruntime import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/personalizeruntime/go.mod b/service/personalizeruntime/go.mod index 7c5f02cedb9..e10eae3a08d 100644 --- a/service/personalizeruntime/go.mod +++ b/service/personalizeruntime/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/personalizeruntime/go.sum b/service/personalizeruntime/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/personalizeruntime/go.sum +++ b/service/personalizeruntime/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/pi/api_client.go b/service/pi/api_client.go index 307eac2abfe..3f3be91d32e 100644 --- a/service/pi/api_client.go +++ b/service/pi/api_client.go @@ -4,7 +4,9 @@ package pi import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/pi/go.mod b/service/pi/go.mod index 351e707d8d9..9bfd051a301 100644 --- a/service/pi/go.mod +++ b/service/pi/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/pi/go.sum b/service/pi/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/pi/go.sum +++ b/service/pi/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/pinpoint/api_client.go b/service/pinpoint/api_client.go index 5be5d300d71..7a119da07c8 100644 --- a/service/pinpoint/api_client.go +++ b/service/pinpoint/api_client.go @@ -4,7 +4,9 @@ package pinpoint import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/pinpoint/go.mod b/service/pinpoint/go.mod index d074e9bb7c1..1b0a8789d16 100644 --- a/service/pinpoint/go.mod +++ b/service/pinpoint/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/pinpoint/go.sum b/service/pinpoint/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/pinpoint/go.sum +++ b/service/pinpoint/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/pinpointemail/api_client.go b/service/pinpointemail/api_client.go index 8f89c7de9c7..94ba731c563 100644 --- a/service/pinpointemail/api_client.go +++ b/service/pinpointemail/api_client.go @@ -4,7 +4,9 @@ package pinpointemail import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/pinpointemail/go.mod b/service/pinpointemail/go.mod index 69820c3b0bd..f41b55539ec 100644 --- a/service/pinpointemail/go.mod +++ b/service/pinpointemail/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/pinpointemail/go.sum b/service/pinpointemail/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/pinpointemail/go.sum +++ b/service/pinpointemail/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/pinpointsmsvoice/api_client.go b/service/pinpointsmsvoice/api_client.go index 1ffea969245..ff8b2617b3c 100644 --- a/service/pinpointsmsvoice/api_client.go +++ b/service/pinpointsmsvoice/api_client.go @@ -4,7 +4,9 @@ package pinpointsmsvoice import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/pinpointsmsvoice/go.mod b/service/pinpointsmsvoice/go.mod index d38f40f4f01..24371a6b82a 100644 --- a/service/pinpointsmsvoice/go.mod +++ b/service/pinpointsmsvoice/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/pinpointsmsvoice/go.sum b/service/pinpointsmsvoice/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/pinpointsmsvoice/go.sum +++ b/service/pinpointsmsvoice/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/polly/api_client.go b/service/polly/api_client.go index 9a79d7de6b1..c99a6c60e9b 100644 --- a/service/polly/api_client.go +++ b/service/polly/api_client.go @@ -4,7 +4,9 @@ package polly import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/polly/go.mod b/service/polly/go.mod index b65e222b586..f9822738993 100644 --- a/service/polly/go.mod +++ b/service/polly/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/polly/go.sum b/service/polly/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/polly/go.sum +++ b/service/polly/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/pricing/api_client.go b/service/pricing/api_client.go index 4349b90cfa2..8f5b6f8bc3b 100644 --- a/service/pricing/api_client.go +++ b/service/pricing/api_client.go @@ -4,7 +4,9 @@ package pricing import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/pricing/go.mod b/service/pricing/go.mod index 2ef06e4beeb..b78cabd9ee8 100644 --- a/service/pricing/go.mod +++ b/service/pricing/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/pricing/go.sum b/service/pricing/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/pricing/go.sum +++ b/service/pricing/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/proton/api_client.go b/service/proton/api_client.go index 6d958cc5137..05c2917c619 100644 --- a/service/proton/api_client.go +++ b/service/proton/api_client.go @@ -5,7 +5,9 @@ package proton import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/proton/go.mod b/service/proton/go.mod index 92582e631a3..83238de197b 100644 --- a/service/proton/go.mod +++ b/service/proton/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/proton/go.sum b/service/proton/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/proton/go.sum +++ b/service/proton/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/qldb/api_client.go b/service/qldb/api_client.go index 26c0ac3b74c..859086d31a4 100644 --- a/service/qldb/api_client.go +++ b/service/qldb/api_client.go @@ -4,7 +4,9 @@ package qldb import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/qldb/go.mod b/service/qldb/go.mod index 0585e31009c..5bbf9e28629 100644 --- a/service/qldb/go.mod +++ b/service/qldb/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/qldb/go.sum b/service/qldb/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/qldb/go.sum +++ b/service/qldb/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/qldbsession/api_client.go b/service/qldbsession/api_client.go index 3d386a80151..b40020c7012 100644 --- a/service/qldbsession/api_client.go +++ b/service/qldbsession/api_client.go @@ -4,7 +4,9 @@ package qldbsession import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/qldbsession/go.mod b/service/qldbsession/go.mod index 33ac77a935d..8b586a95da0 100644 --- a/service/qldbsession/go.mod +++ b/service/qldbsession/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/qldbsession/go.sum b/service/qldbsession/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/qldbsession/go.sum +++ b/service/qldbsession/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/quicksight/api_client.go b/service/quicksight/api_client.go index 7d2020e4495..a8144d6cfd2 100644 --- a/service/quicksight/api_client.go +++ b/service/quicksight/api_client.go @@ -4,7 +4,9 @@ package quicksight import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/quicksight/go.mod b/service/quicksight/go.mod index 593089f69f0..c6e55cb2ea0 100644 --- a/service/quicksight/go.mod +++ b/service/quicksight/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/quicksight/go.sum b/service/quicksight/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/quicksight/go.sum +++ b/service/quicksight/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ram/api_client.go b/service/ram/api_client.go index fe568838144..b208623571e 100644 --- a/service/ram/api_client.go +++ b/service/ram/api_client.go @@ -4,7 +4,9 @@ package ram import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ram/go.mod b/service/ram/go.mod index 046f50a73b6..e8d825ac783 100644 --- a/service/ram/go.mod +++ b/service/ram/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ram/go.sum b/service/ram/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ram/go.sum +++ b/service/ram/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/rbin/api_client.go b/service/rbin/api_client.go index ac8290e525e..5ee634bc566 100644 --- a/service/rbin/api_client.go +++ b/service/rbin/api_client.go @@ -4,7 +4,9 @@ package rbin import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/rbin/go.mod b/service/rbin/go.mod index 3ac6cce338f..f209490ecf1 100644 --- a/service/rbin/go.mod +++ b/service/rbin/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/rbin/go.sum b/service/rbin/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/rbin/go.sum +++ b/service/rbin/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/rds/api_client.go b/service/rds/api_client.go index 143d13f6779..3b0548badba 100644 --- a/service/rds/api_client.go +++ b/service/rds/api_client.go @@ -4,7 +4,9 @@ package rds import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/protocol/query" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -69,6 +74,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -88,9 +97,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -118,6 +140,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +198,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +215,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +307,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/rds/go.mod b/service/rds/go.mod index a0f02d5beed..413aaab194d 100644 --- a/service/rds/go.mod +++ b/service/rds/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/rds/go.sum b/service/rds/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/rds/go.sum +++ b/service/rds/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/rdsdata/api_client.go b/service/rdsdata/api_client.go index 41a14ca6746..809f519a1e6 100644 --- a/service/rdsdata/api_client.go +++ b/service/rdsdata/api_client.go @@ -4,7 +4,9 @@ package rdsdata import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/rdsdata/go.mod b/service/rdsdata/go.mod index c6efe66925c..2dd5b2c90ec 100644 --- a/service/rdsdata/go.mod +++ b/service/rdsdata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/rdsdata/go.sum b/service/rdsdata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/rdsdata/go.sum +++ b/service/rdsdata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/redshift/api_client.go b/service/redshift/api_client.go index c272628c214..515d2c89a72 100644 --- a/service/redshift/api_client.go +++ b/service/redshift/api_client.go @@ -4,7 +4,9 @@ package redshift import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/redshift/go.mod b/service/redshift/go.mod index 0c6be93a53d..f47e2950ea9 100644 --- a/service/redshift/go.mod +++ b/service/redshift/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/redshift/go.sum b/service/redshift/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/redshift/go.sum +++ b/service/redshift/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/redshiftdata/api_client.go b/service/redshiftdata/api_client.go index 81c586e0399..36c49e580d8 100644 --- a/service/redshiftdata/api_client.go +++ b/service/redshiftdata/api_client.go @@ -4,7 +4,9 @@ package redshiftdata import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/redshiftdata/go.mod b/service/redshiftdata/go.mod index c7e81a9cf19..3b4426bb914 100644 --- a/service/redshiftdata/go.mod +++ b/service/redshiftdata/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/redshiftdata/go.sum b/service/redshiftdata/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/redshiftdata/go.sum +++ b/service/redshiftdata/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/rekognition/api_client.go b/service/rekognition/api_client.go index 2ca1f462349..471406a927e 100644 --- a/service/rekognition/api_client.go +++ b/service/rekognition/api_client.go @@ -4,7 +4,9 @@ package rekognition import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/rekognition/go.mod b/service/rekognition/go.mod index 9666c26e317..137c4ae8a6b 100644 --- a/service/rekognition/go.mod +++ b/service/rekognition/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/rekognition/go.sum b/service/rekognition/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/rekognition/go.sum +++ b/service/rekognition/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/resiliencehub/api_client.go b/service/resiliencehub/api_client.go index 90f47c10ec8..69e39a9caad 100644 --- a/service/resiliencehub/api_client.go +++ b/service/resiliencehub/api_client.go @@ -5,7 +5,9 @@ package resiliencehub import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/resiliencehub/go.mod b/service/resiliencehub/go.mod index d9e0ebf2731..0d3d2f345fe 100644 --- a/service/resiliencehub/go.mod +++ b/service/resiliencehub/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/resiliencehub/go.sum b/service/resiliencehub/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/resiliencehub/go.sum +++ b/service/resiliencehub/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/resourcegroups/api_client.go b/service/resourcegroups/api_client.go index 31bd8d6a029..1db4500ae3e 100644 --- a/service/resourcegroups/api_client.go +++ b/service/resourcegroups/api_client.go @@ -4,7 +4,9 @@ package resourcegroups import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/resourcegroups/go.mod b/service/resourcegroups/go.mod index fef898d4762..b7a1b5c6211 100644 --- a/service/resourcegroups/go.mod +++ b/service/resourcegroups/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/resourcegroups/go.sum b/service/resourcegroups/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/resourcegroups/go.sum +++ b/service/resourcegroups/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/resourcegroupstaggingapi/api_client.go b/service/resourcegroupstaggingapi/api_client.go index 4a7118600ed..dc7255f5fb4 100644 --- a/service/resourcegroupstaggingapi/api_client.go +++ b/service/resourcegroupstaggingapi/api_client.go @@ -4,7 +4,9 @@ package resourcegroupstaggingapi import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/resourcegroupstaggingapi/go.mod b/service/resourcegroupstaggingapi/go.mod index b31327bdb5c..990fc846986 100644 --- a/service/resourcegroupstaggingapi/go.mod +++ b/service/resourcegroupstaggingapi/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/resourcegroupstaggingapi/go.sum b/service/resourcegroupstaggingapi/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/resourcegroupstaggingapi/go.sum +++ b/service/resourcegroupstaggingapi/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/robomaker/api_client.go b/service/robomaker/api_client.go index fd386046380..40095d74734 100644 --- a/service/robomaker/api_client.go +++ b/service/robomaker/api_client.go @@ -5,7 +5,9 @@ package robomaker import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/robomaker/go.mod b/service/robomaker/go.mod index 8121269dbe6..fbc146a7a51 100644 --- a/service/robomaker/go.mod +++ b/service/robomaker/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/robomaker/go.sum b/service/robomaker/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/robomaker/go.sum +++ b/service/robomaker/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/route53/api_client.go b/service/route53/api_client.go index 631a0379ccf..961b3a7ff73 100644 --- a/service/route53/api_client.go +++ b/service/route53/api_client.go @@ -4,7 +4,9 @@ package route53 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -16,6 +18,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "strings" "time" @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -68,6 +73,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -87,9 +96,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -117,6 +139,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -169,12 +197,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -184,10 +214,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -242,6 +306,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/route53/go.mod b/service/route53/go.mod index b591ddcc2b8..f8c4c352a73 100644 --- a/service/route53/go.mod +++ b/service/route53/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/route53/go.sum b/service/route53/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/route53/go.sum +++ b/service/route53/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/route53domains/api_client.go b/service/route53domains/api_client.go index f14e4a921f0..10c88a3f9d8 100644 --- a/service/route53domains/api_client.go +++ b/service/route53domains/api_client.go @@ -4,7 +4,9 @@ package route53domains import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/route53domains/go.mod b/service/route53domains/go.mod index 49ba9d5acce..e0094e4524d 100644 --- a/service/route53domains/go.mod +++ b/service/route53domains/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/route53domains/go.sum b/service/route53domains/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/route53domains/go.sum +++ b/service/route53domains/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/route53recoverycluster/api_client.go b/service/route53recoverycluster/api_client.go index 0adfa8838f1..b7c3e39dfc9 100644 --- a/service/route53recoverycluster/api_client.go +++ b/service/route53recoverycluster/api_client.go @@ -4,7 +4,9 @@ package route53recoverycluster import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/route53recoverycluster/go.mod b/service/route53recoverycluster/go.mod index 07153e105a1..26789c23516 100644 --- a/service/route53recoverycluster/go.mod +++ b/service/route53recoverycluster/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/route53recoverycluster/go.sum b/service/route53recoverycluster/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/route53recoverycluster/go.sum +++ b/service/route53recoverycluster/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/route53recoverycontrolconfig/api_client.go b/service/route53recoverycontrolconfig/api_client.go index d58501955f1..50cfc721ba4 100644 --- a/service/route53recoverycontrolconfig/api_client.go +++ b/service/route53recoverycontrolconfig/api_client.go @@ -5,7 +5,9 @@ package route53recoverycontrolconfig import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/route53recoverycontrolconfig/go.mod b/service/route53recoverycontrolconfig/go.mod index 98a63ed479a..979f41e2489 100644 --- a/service/route53recoverycontrolconfig/go.mod +++ b/service/route53recoverycontrolconfig/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/route53recoverycontrolconfig/go.sum b/service/route53recoverycontrolconfig/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/route53recoverycontrolconfig/go.sum +++ b/service/route53recoverycontrolconfig/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/route53recoveryreadiness/api_client.go b/service/route53recoveryreadiness/api_client.go index 40bef15a63b..688057054d4 100644 --- a/service/route53recoveryreadiness/api_client.go +++ b/service/route53recoveryreadiness/api_client.go @@ -4,7 +4,9 @@ package route53recoveryreadiness import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/route53recoveryreadiness/go.mod b/service/route53recoveryreadiness/go.mod index cc37ffa00d6..4add231e0d1 100644 --- a/service/route53recoveryreadiness/go.mod +++ b/service/route53recoveryreadiness/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/route53recoveryreadiness/go.sum b/service/route53recoveryreadiness/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/route53recoveryreadiness/go.sum +++ b/service/route53recoveryreadiness/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/route53resolver/api_client.go b/service/route53resolver/api_client.go index 49ac37626c5..2905a729b79 100644 --- a/service/route53resolver/api_client.go +++ b/service/route53resolver/api_client.go @@ -5,7 +5,9 @@ package route53resolver import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/route53resolver/go.mod b/service/route53resolver/go.mod index da2522576a1..d23b89d72b0 100644 --- a/service/route53resolver/go.mod +++ b/service/route53resolver/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/route53resolver/go.sum b/service/route53resolver/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/route53resolver/go.sum +++ b/service/route53resolver/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/rum/api_client.go b/service/rum/api_client.go index d652e38ca5c..aaff5abfafe 100644 --- a/service/rum/api_client.go +++ b/service/rum/api_client.go @@ -4,7 +4,9 @@ package rum import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/rum/go.mod b/service/rum/go.mod index deec1732fd5..5ec50fcfd09 100644 --- a/service/rum/go.mod +++ b/service/rum/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/rum/go.sum b/service/rum/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/rum/go.sum +++ b/service/rum/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/s3/api_client.go b/service/s3/api_client.go index c5ab34de2d7..28416dd542a 100644 --- a/service/s3/api_client.go +++ b/service/s3/api_client.go @@ -6,6 +6,7 @@ import ( "context" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -22,6 +23,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -49,6 +51,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveHTTPSignerV4a(&options) @@ -78,6 +82,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // Allows you to disable S3 Multi-Region access points feature. DisableMultiRegionAccessPoints bool @@ -100,6 +108,12 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + // Allows you to enable arn region support for the service. UseARNRegion bool @@ -126,9 +140,16 @@ type Options struct { // Signature Version 4a (SigV4a) Signer httpSignerV4a httpSignerV4a + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -156,6 +177,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -212,12 +239,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -228,10 +257,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -287,6 +350,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/s3/go.mod b/service/s3/go.mod index 485f942df3b..1f5c3634bc8 100644 --- a/service/s3/go.mod +++ b/service/s3/go.mod @@ -10,7 +10,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.6.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.10.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/service/s3/go.sum b/service/s3/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/s3/go.sum +++ b/service/s3/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/s3/internal/configtesting/go.sum b/service/s3/internal/configtesting/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/s3/internal/configtesting/go.sum +++ b/service/s3/internal/configtesting/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/s3control/api_client.go b/service/s3control/api_client.go index db075282397..2c276bfa2c2 100644 --- a/service/s3control/api_client.go +++ b/service/s3control/api_client.go @@ -5,7 +5,9 @@ package s3control import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -19,6 +21,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -45,6 +48,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -72,6 +77,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -95,6 +104,12 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + // Allows you to enable arn region support for the service. UseARNRegion bool @@ -105,9 +120,16 @@ type Options struct { // field is set it overrides this field value. UseDualstack bool + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -135,6 +157,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -187,12 +215,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -203,10 +233,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -261,6 +325,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/s3control/go.mod b/service/s3control/go.mod index 19d0b9f7e63..a7cc5c792e5 100644 --- a/service/s3control/go.mod +++ b/service/s3control/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.10.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/s3control/go.sum b/service/s3control/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/s3control/go.sum +++ b/service/s3control/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/s3outposts/api_client.go b/service/s3outposts/api_client.go index 306535ff155..192811551fc 100644 --- a/service/s3outposts/api_client.go +++ b/service/s3outposts/api_client.go @@ -4,7 +4,9 @@ package s3outposts import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/s3outposts/go.mod b/service/s3outposts/go.mod index cb8a93fcdee..6e3be7185a8 100644 --- a/service/s3outposts/go.mod +++ b/service/s3outposts/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/s3outposts/go.sum b/service/s3outposts/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/s3outposts/go.sum +++ b/service/s3outposts/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sagemaker/api_client.go b/service/sagemaker/api_client.go index 3ed0595b432..8d71bb5d85c 100644 --- a/service/sagemaker/api_client.go +++ b/service/sagemaker/api_client.go @@ -5,7 +5,9 @@ package sagemaker import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/sagemaker/go.mod b/service/sagemaker/go.mod index 97a54018aad..1d9603b04a8 100644 --- a/service/sagemaker/go.mod +++ b/service/sagemaker/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/sagemaker/go.sum b/service/sagemaker/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/sagemaker/go.sum +++ b/service/sagemaker/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/sagemakera2iruntime/api_client.go b/service/sagemakera2iruntime/api_client.go index a9079832011..d9d4dc6c0ce 100644 --- a/service/sagemakera2iruntime/api_client.go +++ b/service/sagemakera2iruntime/api_client.go @@ -4,7 +4,9 @@ package sagemakera2iruntime import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sagemakera2iruntime/go.mod b/service/sagemakera2iruntime/go.mod index e7f5b358b63..b002a01e86e 100644 --- a/service/sagemakera2iruntime/go.mod +++ b/service/sagemakera2iruntime/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sagemakera2iruntime/go.sum b/service/sagemakera2iruntime/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sagemakera2iruntime/go.sum +++ b/service/sagemakera2iruntime/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sagemakeredge/api_client.go b/service/sagemakeredge/api_client.go index 452c86e4991..cf7a81763e1 100644 --- a/service/sagemakeredge/api_client.go +++ b/service/sagemakeredge/api_client.go @@ -4,7 +4,9 @@ package sagemakeredge import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sagemakeredge/go.mod b/service/sagemakeredge/go.mod index bcaa1f36651..aae2982b4bc 100644 --- a/service/sagemakeredge/go.mod +++ b/service/sagemakeredge/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sagemakeredge/go.sum b/service/sagemakeredge/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sagemakeredge/go.sum +++ b/service/sagemakeredge/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sagemakerfeaturestoreruntime/api_client.go b/service/sagemakerfeaturestoreruntime/api_client.go index 7e6f2ba9b96..b544a3e0876 100644 --- a/service/sagemakerfeaturestoreruntime/api_client.go +++ b/service/sagemakerfeaturestoreruntime/api_client.go @@ -4,7 +4,9 @@ package sagemakerfeaturestoreruntime import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sagemakerfeaturestoreruntime/go.mod b/service/sagemakerfeaturestoreruntime/go.mod index f797b7077f7..4dfdb4aa6df 100644 --- a/service/sagemakerfeaturestoreruntime/go.mod +++ b/service/sagemakerfeaturestoreruntime/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sagemakerfeaturestoreruntime/go.sum b/service/sagemakerfeaturestoreruntime/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sagemakerfeaturestoreruntime/go.sum +++ b/service/sagemakerfeaturestoreruntime/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sagemakerruntime/api_client.go b/service/sagemakerruntime/api_client.go index dcc028e20f8..0acccfc5061 100644 --- a/service/sagemakerruntime/api_client.go +++ b/service/sagemakerruntime/api_client.go @@ -4,7 +4,9 @@ package sagemakerruntime import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sagemakerruntime/go.mod b/service/sagemakerruntime/go.mod index 2e255273194..bb5b5b6999f 100644 --- a/service/sagemakerruntime/go.mod +++ b/service/sagemakerruntime/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sagemakerruntime/go.sum b/service/sagemakerruntime/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sagemakerruntime/go.sum +++ b/service/sagemakerruntime/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/savingsplans/api_client.go b/service/savingsplans/api_client.go index d295bc95544..f11e464065d 100644 --- a/service/savingsplans/api_client.go +++ b/service/savingsplans/api_client.go @@ -5,7 +5,9 @@ package savingsplans import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/savingsplans/go.mod b/service/savingsplans/go.mod index 20a9690d769..6d28fac3444 100644 --- a/service/savingsplans/go.mod +++ b/service/savingsplans/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/savingsplans/go.sum b/service/savingsplans/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/savingsplans/go.sum +++ b/service/savingsplans/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/schemas/api_client.go b/service/schemas/api_client.go index 6ab9afce8ba..e78825804f3 100644 --- a/service/schemas/api_client.go +++ b/service/schemas/api_client.go @@ -5,7 +5,9 @@ package schemas import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/schemas/go.mod b/service/schemas/go.mod index cb03435d7f5..82b8989761d 100644 --- a/service/schemas/go.mod +++ b/service/schemas/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/schemas/go.sum b/service/schemas/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/schemas/go.sum +++ b/service/schemas/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/secretsmanager/api_client.go b/service/secretsmanager/api_client.go index 9e17bf16356..61acb03db6d 100644 --- a/service/secretsmanager/api_client.go +++ b/service/secretsmanager/api_client.go @@ -5,7 +5,9 @@ package secretsmanager import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/secretsmanager/go.mod b/service/secretsmanager/go.mod index 2f47f2c7ccf..9f009f77595 100644 --- a/service/secretsmanager/go.mod +++ b/service/secretsmanager/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/secretsmanager/go.sum b/service/secretsmanager/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/secretsmanager/go.sum +++ b/service/secretsmanager/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/securityhub/api_client.go b/service/securityhub/api_client.go index 6ea968c8b24..2e5bb573cc1 100644 --- a/service/securityhub/api_client.go +++ b/service/securityhub/api_client.go @@ -4,7 +4,9 @@ package securityhub import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/securityhub/go.mod b/service/securityhub/go.mod index cb5504b974d..340eb35c5dc 100644 --- a/service/securityhub/go.mod +++ b/service/securityhub/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/securityhub/go.sum b/service/securityhub/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/securityhub/go.sum +++ b/service/securityhub/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/serverlessapplicationrepository/api_client.go b/service/serverlessapplicationrepository/api_client.go index d8c9d2e6d43..c6db9785a71 100644 --- a/service/serverlessapplicationrepository/api_client.go +++ b/service/serverlessapplicationrepository/api_client.go @@ -4,7 +4,9 @@ package serverlessapplicationrepository import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/serverlessapplicationrepository/go.mod b/service/serverlessapplicationrepository/go.mod index 8630948157b..f5da4c6e9e1 100644 --- a/service/serverlessapplicationrepository/go.mod +++ b/service/serverlessapplicationrepository/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/serverlessapplicationrepository/go.sum b/service/serverlessapplicationrepository/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/serverlessapplicationrepository/go.sum +++ b/service/serverlessapplicationrepository/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/servicecatalog/api_client.go b/service/servicecatalog/api_client.go index 54b30ce7274..69d11b995ad 100644 --- a/service/servicecatalog/api_client.go +++ b/service/servicecatalog/api_client.go @@ -5,7 +5,9 @@ package servicecatalog import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/servicecatalog/go.mod b/service/servicecatalog/go.mod index c6a81d2cc71..7d63381ecd5 100644 --- a/service/servicecatalog/go.mod +++ b/service/servicecatalog/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/servicecatalog/go.sum b/service/servicecatalog/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/servicecatalog/go.sum +++ b/service/servicecatalog/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/servicecatalogappregistry/api_client.go b/service/servicecatalogappregistry/api_client.go index ba4105d9ad2..d24a41fad6d 100644 --- a/service/servicecatalogappregistry/api_client.go +++ b/service/servicecatalogappregistry/api_client.go @@ -5,7 +5,9 @@ package servicecatalogappregistry import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/servicecatalogappregistry/go.mod b/service/servicecatalogappregistry/go.mod index d37bc251ea0..a4783b82b69 100644 --- a/service/servicecatalogappregistry/go.mod +++ b/service/servicecatalogappregistry/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/servicecatalogappregistry/go.sum b/service/servicecatalogappregistry/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/servicecatalogappregistry/go.sum +++ b/service/servicecatalogappregistry/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/servicediscovery/api_client.go b/service/servicediscovery/api_client.go index be5cb36cae3..36f4437d8dc 100644 --- a/service/servicediscovery/api_client.go +++ b/service/servicediscovery/api_client.go @@ -5,7 +5,9 @@ package servicediscovery import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/servicediscovery/go.mod b/service/servicediscovery/go.mod index 236e4a4eabe..96ced3b2d0b 100644 --- a/service/servicediscovery/go.mod +++ b/service/servicediscovery/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/servicediscovery/go.sum b/service/servicediscovery/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/servicediscovery/go.sum +++ b/service/servicediscovery/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/servicequotas/api_client.go b/service/servicequotas/api_client.go index 6bd0dd0de3c..247e170cd6c 100644 --- a/service/servicequotas/api_client.go +++ b/service/servicequotas/api_client.go @@ -4,7 +4,9 @@ package servicequotas import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/servicequotas/go.mod b/service/servicequotas/go.mod index e8cc0ca79e5..3efa655de03 100644 --- a/service/servicequotas/go.mod +++ b/service/servicequotas/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/servicequotas/go.sum b/service/servicequotas/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/servicequotas/go.sum +++ b/service/servicequotas/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ses/api_client.go b/service/ses/api_client.go index ad666c79874..3b19d48aa4a 100644 --- a/service/ses/api_client.go +++ b/service/ses/api_client.go @@ -4,7 +4,9 @@ package ses import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ses/go.mod b/service/ses/go.mod index 6836ee419e4..5397e5cb3a4 100644 --- a/service/ses/go.mod +++ b/service/ses/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ses/go.sum b/service/ses/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ses/go.sum +++ b/service/ses/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/sesv2/api_client.go b/service/sesv2/api_client.go index bc2c3db0a3f..dfb62dbc026 100644 --- a/service/sesv2/api_client.go +++ b/service/sesv2/api_client.go @@ -4,7 +4,9 @@ package sesv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sesv2/go.mod b/service/sesv2/go.mod index 24f834ac160..3f1e9e5dd2f 100644 --- a/service/sesv2/go.mod +++ b/service/sesv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sesv2/go.sum b/service/sesv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sesv2/go.sum +++ b/service/sesv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sfn/api_client.go b/service/sfn/api_client.go index a392ed72ca5..be5e365d130 100644 --- a/service/sfn/api_client.go +++ b/service/sfn/api_client.go @@ -4,7 +4,9 @@ package sfn import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sfn/go.mod b/service/sfn/go.mod index a82b1499b92..506d16dd979 100644 --- a/service/sfn/go.mod +++ b/service/sfn/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sfn/go.sum b/service/sfn/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sfn/go.sum +++ b/service/sfn/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/shield/api_client.go b/service/shield/api_client.go index f4b645b74c8..8607c0264d2 100644 --- a/service/shield/api_client.go +++ b/service/shield/api_client.go @@ -4,7 +4,9 @@ package shield import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/shield/go.mod b/service/shield/go.mod index 8e494b6ae97..97820121399 100644 --- a/service/shield/go.mod +++ b/service/shield/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/shield/go.sum b/service/shield/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/shield/go.sum +++ b/service/shield/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/signer/api_client.go b/service/signer/api_client.go index 21e91b6d9e1..021f1a1cc53 100644 --- a/service/signer/api_client.go +++ b/service/signer/api_client.go @@ -5,7 +5,9 @@ package signer import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/signer/go.mod b/service/signer/go.mod index cad8362f5ed..13081acc989 100644 --- a/service/signer/go.mod +++ b/service/signer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/signer/go.sum b/service/signer/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/signer/go.sum +++ b/service/signer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/sms/api_client.go b/service/sms/api_client.go index 6f8878f589f..c6ca2c21d01 100644 --- a/service/sms/api_client.go +++ b/service/sms/api_client.go @@ -4,7 +4,9 @@ package sms import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sms/go.mod b/service/sms/go.mod index 948f0e7b05a..478ad523c33 100644 --- a/service/sms/go.mod +++ b/service/sms/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sms/go.sum b/service/sms/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sms/go.sum +++ b/service/sms/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/snowball/api_client.go b/service/snowball/api_client.go index 2a26cb45d37..9044c7b577c 100644 --- a/service/snowball/api_client.go +++ b/service/snowball/api_client.go @@ -4,7 +4,9 @@ package snowball import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/snowball/go.mod b/service/snowball/go.mod index fbe6b5202f8..8799f258424 100644 --- a/service/snowball/go.mod +++ b/service/snowball/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/snowball/go.sum b/service/snowball/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/snowball/go.sum +++ b/service/snowball/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/snowdevicemanagement/api_client.go b/service/snowdevicemanagement/api_client.go index 845af8419d6..b9fc5cd882a 100644 --- a/service/snowdevicemanagement/api_client.go +++ b/service/snowdevicemanagement/api_client.go @@ -5,7 +5,9 @@ package snowdevicemanagement import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/snowdevicemanagement/go.mod b/service/snowdevicemanagement/go.mod index 9d290e855ab..a31532e7583 100644 --- a/service/snowdevicemanagement/go.mod +++ b/service/snowdevicemanagement/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/snowdevicemanagement/go.sum b/service/snowdevicemanagement/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/snowdevicemanagement/go.sum +++ b/service/snowdevicemanagement/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sns/api_client.go b/service/sns/api_client.go index d32d2676926..98700e494fb 100644 --- a/service/sns/api_client.go +++ b/service/sns/api_client.go @@ -4,7 +4,9 @@ package sns import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sns/go.mod b/service/sns/go.mod index 1a179079926..2eb223302df 100644 --- a/service/sns/go.mod +++ b/service/sns/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sns/go.sum b/service/sns/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sns/go.sum +++ b/service/sns/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sqs/api_client.go b/service/sqs/api_client.go index eeecc931c50..3054745749d 100644 --- a/service/sqs/api_client.go +++ b/service/sqs/api_client.go @@ -4,7 +4,9 @@ package sqs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sqs/go.mod b/service/sqs/go.mod index 0dff5610dfc..dfd5ef9d608 100644 --- a/service/sqs/go.mod +++ b/service/sqs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sqs/go.sum b/service/sqs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sqs/go.sum +++ b/service/sqs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ssm/api_client.go b/service/ssm/api_client.go index a785b03947b..d2898a66699 100644 --- a/service/ssm/api_client.go +++ b/service/ssm/api_client.go @@ -5,7 +5,9 @@ package ssm import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/ssm/go.mod b/service/ssm/go.mod index 2d8d9902750..d7c64544d49 100644 --- a/service/ssm/go.mod +++ b/service/ssm/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ssm/go.sum b/service/ssm/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ssm/go.sum +++ b/service/ssm/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/ssmcontacts/api_client.go b/service/ssmcontacts/api_client.go index 98d7f225829..7c4d9bb3470 100644 --- a/service/ssmcontacts/api_client.go +++ b/service/ssmcontacts/api_client.go @@ -5,7 +5,9 @@ package ssmcontacts import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/ssmcontacts/go.mod b/service/ssmcontacts/go.mod index e5996835b25..4138320062c 100644 --- a/service/ssmcontacts/go.mod +++ b/service/ssmcontacts/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ssmcontacts/go.sum b/service/ssmcontacts/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ssmcontacts/go.sum +++ b/service/ssmcontacts/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ssmincidents/api_client.go b/service/ssmincidents/api_client.go index 9373c5702a9..488e8175fb9 100644 --- a/service/ssmincidents/api_client.go +++ b/service/ssmincidents/api_client.go @@ -5,7 +5,9 @@ package ssmincidents import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/ssmincidents/go.mod b/service/ssmincidents/go.mod index b9007298608..efd8ba20bb4 100644 --- a/service/ssmincidents/go.mod +++ b/service/ssmincidents/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/jmespath/go-jmespath v0.4.0 ) diff --git a/service/ssmincidents/go.sum b/service/ssmincidents/go.sum index ce121d1d318..c8c1b89cbfd 100644 --- a/service/ssmincidents/go.sum +++ b/service/ssmincidents/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= diff --git a/service/sso/api_client.go b/service/sso/api_client.go index 4fed68b6f9d..26451e62cbc 100644 --- a/service/sso/api_client.go +++ b/service/sso/api_client.go @@ -4,7 +4,9 @@ package sso import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sso/go.mod b/service/sso/go.mod index 8005b62ce8e..644071a3000 100644 --- a/service/sso/go.mod +++ b/service/sso/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sso/go.sum b/service/sso/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sso/go.sum +++ b/service/sso/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ssoadmin/api_client.go b/service/ssoadmin/api_client.go index 2607cb86215..f167053ea97 100644 --- a/service/ssoadmin/api_client.go +++ b/service/ssoadmin/api_client.go @@ -4,7 +4,9 @@ package ssoadmin import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ssoadmin/go.mod b/service/ssoadmin/go.mod index c1cd4d33052..75841c44d8c 100644 --- a/service/ssoadmin/go.mod +++ b/service/ssoadmin/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ssoadmin/go.sum b/service/ssoadmin/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ssoadmin/go.sum +++ b/service/ssoadmin/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/ssooidc/api_client.go b/service/ssooidc/api_client.go index 0f2e100f801..48eb695b47b 100644 --- a/service/ssooidc/api_client.go +++ b/service/ssooidc/api_client.go @@ -4,7 +4,9 @@ package ssooidc import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/ssooidc/go.mod b/service/ssooidc/go.mod index 779e0fa9a82..1c652a82c9b 100644 --- a/service/ssooidc/go.mod +++ b/service/ssooidc/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/ssooidc/go.sum b/service/ssooidc/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/ssooidc/go.sum +++ b/service/ssooidc/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/storagegateway/api_client.go b/service/storagegateway/api_client.go index 9b269399781..ba4ad7d2a1f 100644 --- a/service/storagegateway/api_client.go +++ b/service/storagegateway/api_client.go @@ -4,7 +4,9 @@ package storagegateway import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/storagegateway/go.mod b/service/storagegateway/go.mod index 4fb536c0c9c..1de9966e928 100644 --- a/service/storagegateway/go.mod +++ b/service/storagegateway/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/storagegateway/go.sum b/service/storagegateway/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/storagegateway/go.sum +++ b/service/storagegateway/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/sts/api_client.go b/service/sts/api_client.go index 6614d01b007..5422597881b 100644 --- a/service/sts/api_client.go +++ b/service/sts/api_client.go @@ -4,7 +4,9 @@ package sts import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/protocol/query" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -69,6 +74,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -88,9 +97,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -118,6 +140,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +198,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +215,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +307,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/sts/go.mod b/service/sts/go.mod index f36b057dc3a..11b34fbddd6 100644 --- a/service/sts/go.mod +++ b/service/sts/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.6.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/sts/go.sum b/service/sts/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/sts/go.sum +++ b/service/sts/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/support/api_client.go b/service/support/api_client.go index 71b5174f53f..30de094c8f6 100644 --- a/service/support/api_client.go +++ b/service/support/api_client.go @@ -4,7 +4,9 @@ package support import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/support/go.mod b/service/support/go.mod index 7af9e695b6b..05687ed54ef 100644 --- a/service/support/go.mod +++ b/service/support/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/support/go.sum b/service/support/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/support/go.sum +++ b/service/support/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/swf/api_client.go b/service/swf/api_client.go index 485ffffa0ca..4e00c8455cb 100644 --- a/service/swf/api_client.go +++ b/service/swf/api_client.go @@ -4,7 +4,9 @@ package swf import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/swf/go.mod b/service/swf/go.mod index 3e3c274132c..ff19adef0a1 100644 --- a/service/swf/go.mod +++ b/service/swf/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/swf/go.sum b/service/swf/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/swf/go.sum +++ b/service/swf/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/synthetics/api_client.go b/service/synthetics/api_client.go index ee19b060b92..6a84242a2da 100644 --- a/service/synthetics/api_client.go +++ b/service/synthetics/api_client.go @@ -4,7 +4,9 @@ package synthetics import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/synthetics/go.mod b/service/synthetics/go.mod index 4c443b6f5d5..6fbafd7965d 100644 --- a/service/synthetics/go.mod +++ b/service/synthetics/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/synthetics/go.sum b/service/synthetics/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/synthetics/go.sum +++ b/service/synthetics/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/textract/api_client.go b/service/textract/api_client.go index fce4cafdcc1..f08a5c3be77 100644 --- a/service/textract/api_client.go +++ b/service/textract/api_client.go @@ -4,7 +4,9 @@ package textract import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/textract/go.mod b/service/textract/go.mod index 04455c0b32a..8c52f05509a 100644 --- a/service/textract/go.mod +++ b/service/textract/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/textract/go.sum b/service/textract/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/textract/go.sum +++ b/service/textract/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/timestreamquery/api_client.go b/service/timestreamquery/api_client.go index adafd4e65a0..7f5922b7837 100644 --- a/service/timestreamquery/api_client.go +++ b/service/timestreamquery/api_client.go @@ -7,6 +7,7 @@ import ( cryptorand "crypto/rand" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -19,6 +20,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "net/url" "strings" @@ -51,6 +53,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -82,6 +86,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // Allows configuring endpoint discovery EndpointDiscovery EndpointDiscoveryOptions @@ -108,9 +116,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -138,6 +159,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -190,12 +217,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -206,10 +235,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -264,6 +327,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/timestreamquery/go.mod b/service/timestreamquery/go.mod index 35887c6c777..f7b748b62b5 100644 --- a/service/timestreamquery/go.mod +++ b/service/timestreamquery/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.4.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/timestreamquery/go.sum b/service/timestreamquery/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/timestreamquery/go.sum +++ b/service/timestreamquery/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/timestreamwrite/api_client.go b/service/timestreamwrite/api_client.go index 685a9c060cd..c66705447f1 100644 --- a/service/timestreamwrite/api_client.go +++ b/service/timestreamwrite/api_client.go @@ -6,6 +6,7 @@ import ( "context" "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +18,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "net/url" "strings" @@ -49,6 +51,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveEnableEndpointDiscovery(&options) @@ -78,6 +82,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // Allows configuring endpoint discovery EndpointDiscovery EndpointDiscoveryOptions @@ -100,9 +108,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -130,6 +151,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -182,12 +209,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -198,10 +227,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -256,6 +319,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/timestreamwrite/go.mod b/service/timestreamwrite/go.mod index cbcc917a445..361312c6c49 100644 --- a/service/timestreamwrite/go.mod +++ b/service/timestreamwrite/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.4.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/timestreamwrite/go.sum b/service/timestreamwrite/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/timestreamwrite/go.sum +++ b/service/timestreamwrite/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/transcribe/api_client.go b/service/transcribe/api_client.go index d95a696e6ce..f70dab4bc82 100644 --- a/service/transcribe/api_client.go +++ b/service/transcribe/api_client.go @@ -4,7 +4,9 @@ package transcribe import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/transcribe/go.mod b/service/transcribe/go.mod index 7531292bcd2..89da28b2767 100644 --- a/service/transcribe/go.mod +++ b/service/transcribe/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/transcribe/go.sum b/service/transcribe/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/transcribe/go.sum +++ b/service/transcribe/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/transcribestreaming/api_client.go b/service/transcribestreaming/api_client.go index c81dbdfdc5a..0c15082c3b2 100644 --- a/service/transcribestreaming/api_client.go +++ b/service/transcribestreaming/api_client.go @@ -4,7 +4,9 @@ package transcribestreaming import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -170,12 +198,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -185,10 +215,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -243,6 +307,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/transcribestreaming/go.mod b/service/transcribestreaming/go.mod index 64da1961888..bad420690a0 100644 --- a/service/transcribestreaming/go.mod +++ b/service/transcribestreaming/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.1.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/transcribestreaming/go.sum b/service/transcribestreaming/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/transcribestreaming/go.sum +++ b/service/transcribestreaming/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/transcribestreaming/internal/testing/go.mod b/service/transcribestreaming/internal/testing/go.mod index 026075e5601..18dde200e29 100644 --- a/service/transcribestreaming/internal/testing/go.mod +++ b/service/transcribestreaming/internal/testing/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.1.0 github.com/aws/aws-sdk-go-v2/service/internal/eventstreamtesting v1.0.6 github.com/aws/aws-sdk-go-v2/service/transcribestreaming v1.2.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 github.com/google/go-cmp v0.5.6 ) diff --git a/service/transcribestreaming/internal/testing/go.sum b/service/transcribestreaming/internal/testing/go.sum index 441f5df8111..932d041c390 100644 --- a/service/transcribestreaming/internal/testing/go.sum +++ b/service/transcribestreaming/internal/testing/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/transfer/api_client.go b/service/transfer/api_client.go index ccf689c088d..ef0fff273eb 100644 --- a/service/transfer/api_client.go +++ b/service/transfer/api_client.go @@ -4,7 +4,9 @@ package transfer import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/transfer/go.mod b/service/transfer/go.mod index eeb0e5b9f5d..47f228aa2d4 100644 --- a/service/transfer/go.mod +++ b/service/transfer/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/transfer/go.sum b/service/transfer/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/transfer/go.sum +++ b/service/transfer/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/translate/api_client.go b/service/translate/api_client.go index 29f5555c466..8aceca86287 100644 --- a/service/translate/api_client.go +++ b/service/translate/api_client.go @@ -5,7 +5,9 @@ package translate import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/translate/go.mod b/service/translate/go.mod index df596fb0c2a..7d751d4b3bc 100644 --- a/service/translate/go.mod +++ b/service/translate/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/translate/go.sum b/service/translate/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/translate/go.sum +++ b/service/translate/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/voiceid/api_client.go b/service/voiceid/api_client.go index 2f8b253bc73..fa5ec106da5 100644 --- a/service/voiceid/api_client.go +++ b/service/voiceid/api_client.go @@ -5,7 +5,9 @@ package voiceid import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/voiceid/go.mod b/service/voiceid/go.mod index 67307b92e41..c73670c16e1 100644 --- a/service/voiceid/go.mod +++ b/service/voiceid/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/voiceid/go.sum b/service/voiceid/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/voiceid/go.sum +++ b/service/voiceid/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/waf/api_client.go b/service/waf/api_client.go index a6de09d8d78..12a6adc4eb6 100644 --- a/service/waf/api_client.go +++ b/service/waf/api_client.go @@ -4,7 +4,9 @@ package waf import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/waf/go.mod b/service/waf/go.mod index e164004b51b..92c098b2b9b 100644 --- a/service/waf/go.mod +++ b/service/waf/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/waf/go.sum b/service/waf/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/waf/go.sum +++ b/service/waf/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/wafregional/api_client.go b/service/wafregional/api_client.go index 79177caa9ef..e38350a555b 100644 --- a/service/wafregional/api_client.go +++ b/service/wafregional/api_client.go @@ -4,7 +4,9 @@ package wafregional import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/wafregional/go.mod b/service/wafregional/go.mod index 1acbb503813..a7b380357fc 100644 --- a/service/wafregional/go.mod +++ b/service/wafregional/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/wafregional/go.sum b/service/wafregional/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/wafregional/go.sum +++ b/service/wafregional/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/wafv2/api_client.go b/service/wafv2/api_client.go index df8a314829d..86b6079d352 100644 --- a/service/wafv2/api_client.go +++ b/service/wafv2/api_client.go @@ -4,7 +4,9 @@ package wafv2 import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/wafv2/go.mod b/service/wafv2/go.mod index ef5fd56e258..07eae746540 100644 --- a/service/wafv2/go.mod +++ b/service/wafv2/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/wafv2/go.sum b/service/wafv2/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/wafv2/go.sum +++ b/service/wafv2/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/wellarchitected/api_client.go b/service/wellarchitected/api_client.go index b94e8fdfabc..ddbac9daa78 100644 --- a/service/wellarchitected/api_client.go +++ b/service/wellarchitected/api_client.go @@ -5,7 +5,9 @@ package wellarchitected import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/wellarchitected/go.mod b/service/wellarchitected/go.mod index 1c34ec2234f..bff997cdc6c 100644 --- a/service/wellarchitected/go.mod +++ b/service/wellarchitected/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/wellarchitected/go.sum b/service/wellarchitected/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/wellarchitected/go.sum +++ b/service/wellarchitected/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/wisdom/api_client.go b/service/wisdom/api_client.go index dbb1b4a9fac..669e1dff4ab 100644 --- a/service/wisdom/api_client.go +++ b/service/wisdom/api_client.go @@ -5,7 +5,9 @@ package wisdom import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/wisdom/go.mod b/service/wisdom/go.mod index aca021ed581..e21381c4b90 100644 --- a/service/wisdom/go.mod +++ b/service/wisdom/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/wisdom/go.sum b/service/wisdom/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/wisdom/go.sum +++ b/service/wisdom/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/workdocs/api_client.go b/service/workdocs/api_client.go index 2e724d0f654..65f71167339 100644 --- a/service/workdocs/api_client.go +++ b/service/workdocs/api_client.go @@ -4,7 +4,9 @@ package workdocs import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/workdocs/go.mod b/service/workdocs/go.mod index ca7184c13c5..1eaa36f68a5 100644 --- a/service/workdocs/go.mod +++ b/service/workdocs/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/workdocs/go.sum b/service/workdocs/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/workdocs/go.sum +++ b/service/workdocs/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/worklink/api_client.go b/service/worklink/api_client.go index b4676f6b85e..0e5584b73ee 100644 --- a/service/worklink/api_client.go +++ b/service/worklink/api_client.go @@ -4,7 +4,9 @@ package worklink import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/worklink/go.mod b/service/worklink/go.mod index 9504e51657d..b3665ebcbd5 100644 --- a/service/worklink/go.mod +++ b/service/worklink/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/worklink/go.sum b/service/worklink/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/worklink/go.sum +++ b/service/worklink/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/workmail/api_client.go b/service/workmail/api_client.go index 4bb3ff8f5e8..e8a1c6ce3e7 100644 --- a/service/workmail/api_client.go +++ b/service/workmail/api_client.go @@ -5,7 +5,9 @@ package workmail import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -43,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -70,6 +75,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -93,9 +102,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -123,6 +145,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -175,12 +203,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -190,10 +220,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -248,6 +312,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/workmail/go.mod b/service/workmail/go.mod index 3a6b6b2ff28..7bc1e0c4149 100644 --- a/service/workmail/go.mod +++ b/service/workmail/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/workmail/go.sum b/service/workmail/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/workmail/go.sum +++ b/service/workmail/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/workmailmessageflow/api_client.go b/service/workmailmessageflow/api_client.go index 045cd2af6a5..90127641661 100644 --- a/service/workmailmessageflow/api_client.go +++ b/service/workmailmessageflow/api_client.go @@ -4,7 +4,9 @@ package workmailmessageflow import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -42,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -67,6 +72,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -86,9 +95,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -116,6 +138,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -168,12 +196,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -183,10 +213,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -241,6 +305,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/workmailmessageflow/go.mod b/service/workmailmessageflow/go.mod index 2ae6849ae9b..be60b6455d9 100644 --- a/service/workmailmessageflow/go.mod +++ b/service/workmailmessageflow/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/workmailmessageflow/go.sum b/service/workmailmessageflow/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/workmailmessageflow/go.sum +++ b/service/workmailmessageflow/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/workspaces/api_client.go b/service/workspaces/api_client.go index 030037a6c61..113ca450789 100644 --- a/service/workspaces/api_client.go +++ b/service/workspaces/api_client.go @@ -4,7 +4,9 @@ package workspaces import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/workspaces/go.mod b/service/workspaces/go.mod index bcc70617406..01803baba31 100644 --- a/service/workspaces/go.mod +++ b/service/workspaces/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/workspaces/go.sum b/service/workspaces/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/workspaces/go.sum +++ b/service/workspaces/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/workspacesweb/api_client.go b/service/workspacesweb/api_client.go index 1bc7cc8d3c1..8032f3ca3e0 100644 --- a/service/workspacesweb/api_client.go +++ b/service/workspacesweb/api_client.go @@ -5,7 +5,9 @@ package workspacesweb import ( "context" cryptorand "crypto/rand" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -17,6 +19,7 @@ import ( "github.com/aws/smithy-go/middleware" smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -44,6 +47,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) resolveIdempotencyTokenProvider(&options) @@ -71,6 +76,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -94,9 +103,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -124,6 +146,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -176,12 +204,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -191,10 +221,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -249,6 +313,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func resolveIdempotencyTokenProvider(o *Options) { if o.IdempotencyTokenProvider != nil { return diff --git a/service/workspacesweb/go.mod b/service/workspacesweb/go.mod index c42dca188a9..ade1e8d3f4d 100644 --- a/service/workspacesweb/go.mod +++ b/service/workspacesweb/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/workspacesweb/go.sum b/service/workspacesweb/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/workspacesweb/go.sum +++ b/service/workspacesweb/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= diff --git a/service/xray/api_client.go b/service/xray/api_client.go index 5d6da2140d0..e5cf5337de3 100644 --- a/service/xray/api_client.go +++ b/service/xray/api_client.go @@ -4,7 +4,9 @@ package xray import ( "context" + "fmt" "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" @@ -15,6 +17,7 @@ import ( "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" + "net" "net/http" "time" ) @@ -41,6 +44,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveHTTPSignerV4(&options) + setResolvedDefaultsMode(&options) + resolveDefaultEndpointConfiguration(&options) for _, fn := range optFns { @@ -66,6 +71,10 @@ type Options struct { // The credentials object to use when signing requests. Credentials aws.CredentialsProvider + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + // The endpoint options to be used when attempting to resolve an endpoint. EndpointOptions EndpointResolverOptions @@ -85,9 +94,22 @@ type Options struct { // failures. When nil the API client will use a default retryer. Retryer aws.Retryer + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to AutoDefaultsMode and is initialized using config.LoadDefaultConfig. You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.AutoDefaultsMode this will store what the resolved + // value was at that point in time. + resolvedDefaultsMode aws.DefaultsMode + // The HTTP client to invoke API calls with. Defaults to client's default HTTP // implementation if nil. HTTPClient HTTPClient + + clientInitializedOptions map[struct{}]interface{} } // WithAPIOptions returns a functional option for setting the Client's APIOptions @@ -115,6 +137,12 @@ func (o Options) Copy() Options { to := o to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) copy(to.APIOptions, o.APIOptions) + + to.clientInitializedOptions = make(map[struct{}]interface{}, len(o.clientInitializedOptions)) + for k, v := range o.clientInitializedOptions { + to.clientInitializedOptions[k] = v + } + return to } func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) { @@ -167,12 +195,14 @@ func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error { // NewFromConfig returns a new client from the provided config. func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { opts := Options{ - Region: cfg.Region, - HTTPClient: cfg.HTTPClient, - Credentials: cfg.Credentials, - APIOptions: cfg.APIOptions, - Logger: cfg.Logger, - ClientLogMode: cfg.ClientLogMode, + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, } resolveAWSRetryerProvider(cfg, &opts) resolveAWSEndpointResolver(cfg, &opts) @@ -182,10 +212,44 @@ func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { } func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + if o.HTTPClient != nil { - return + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + var mode aws.DefaultsMode + if ok := mode.SetFromString(string(o.DefaultsMode)); !ok { + panic(fmt.Errorf("unsupported defaults mode constant %v", mode)) + } + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) } - o.HTTPClient = awshttp.NewBuildableClient() + + if mode != aws.DefaultsModeLegacy { + modeConfig, _ := defaults.GetModeConfiguration(mode) + + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + o.HTTPClient = buildable } func resolveRetryer(o *Options) { @@ -240,6 +304,21 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, diff --git a/service/xray/go.mod b/service/xray/go.mod index 25985bb5662..e1308e5622e 100644 --- a/service/xray/go.mod +++ b/service/xray/go.mod @@ -6,7 +6,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.12.0 github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.3 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.1.0 - github.com/aws/smithy-go v1.9.1 + github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 ) replace github.com/aws/aws-sdk-go-v2 => ../../ diff --git a/service/xray/go.sum b/service/xray/go.sum index e05213ea4b1..7aa0d5516af 100644 --- a/service/xray/go.sum +++ b/service/xray/go.sum @@ -1,5 +1,5 @@ -github.com/aws/smithy-go v1.9.1 h1:5vetTooLk4hPWV8q6ym6+lXKAT1Urnm49YkrRKo2J8o= -github.com/aws/smithy-go v1.9.1/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63 h1:sczjOTbX9viYhobSMDT/vzMs1ZqJsyZPXhlkwPxd9zY= +github.com/aws/smithy-go v1.9.2-0.20220113020543-dec09760da63/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=