1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package sts
4
5import (
6 "context"
7 "fmt"
8 "github.com/aws/aws-sdk-go-v2/aws"
9 "github.com/aws/aws-sdk-go-v2/aws/defaults"
10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
11 "github.com/aws/aws-sdk-go-v2/aws/protocol/query"
12 "github.com/aws/aws-sdk-go-v2/aws/retry"
13 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
14 awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
15 internalauth "github.com/aws/aws-sdk-go-v2/internal/auth"
16 internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy"
17 internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
18 internalmiddleware "github.com/aws/aws-sdk-go-v2/internal/middleware"
19 acceptencodingcust "github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding"
20 presignedurlcust "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url"
21 smithy "github.com/aws/smithy-go"
22 smithyauth "github.com/aws/smithy-go/auth"
23 smithydocument "github.com/aws/smithy-go/document"
24 "github.com/aws/smithy-go/logging"
25 "github.com/aws/smithy-go/middleware"
26 smithyhttp "github.com/aws/smithy-go/transport/http"
27 "net"
28 "net/http"
29 "sync/atomic"
30 "time"
31)
32
33const ServiceID = "STS"
34const ServiceAPIVersion = "2011-06-15"
35
36// Client provides the API client to make operations call for AWS Security Token
37// Service.
38type Client struct {
39 options Options
40
41 // Difference between the time reported by the server and the client
42 timeOffset *atomic.Int64
43}
44
45// New returns an initialized Client based on the functional options. Provide
46// additional functional options to further configure the behavior of the client,
47// such as changing the client's endpoint or adding custom middleware behavior.
48func New(options Options, optFns ...func(*Options)) *Client {
49 options = options.Copy()
50
51 resolveDefaultLogger(&options)
52
53 setResolvedDefaultsMode(&options)
54
55 resolveRetryer(&options)
56
57 resolveHTTPClient(&options)
58
59 resolveHTTPSignerV4(&options)
60
61 resolveEndpointResolverV2(&options)
62
63 resolveAuthSchemeResolver(&options)
64
65 for _, fn := range optFns {
66 fn(&options)
67 }
68
69 finalizeRetryMaxAttempts(&options)
70
71 ignoreAnonymousAuth(&options)
72
73 wrapWithAnonymousAuth(&options)
74
75 resolveAuthSchemes(&options)
76
77 client := &Client{
78 options: options,
79 }
80
81 initializeTimeOffsetResolver(client)
82
83 return client
84}
85
86// Options returns a copy of the client configuration.
87//
88// Callers SHOULD NOT perform mutations on any inner structures within client
89// config. Config overrides should instead be made on a per-operation basis through
90// functional options.
91func (c *Client) Options() Options {
92 return c.options.Copy()
93}
94
95func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
96 ctx = middleware.ClearStackValues(ctx)
97 stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
98 options := c.options.Copy()
99
100 for _, fn := range optFns {
101 fn(&options)
102 }
103
104 finalizeOperationRetryMaxAttempts(&options, *c)
105
106 finalizeClientEndpointResolverOptions(&options)
107
108 for _, fn := range stackFns {
109 if err := fn(stack, options); err != nil {
110 return nil, metadata, err
111 }
112 }
113
114 for _, fn := range options.APIOptions {
115 if err := fn(stack); err != nil {
116 return nil, metadata, err
117 }
118 }
119
120 handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
121 result, metadata, err = handler.Handle(ctx, params)
122 if err != nil {
123 err = &smithy.OperationError{
124 ServiceID: ServiceID,
125 OperationName: opID,
126 Err: err,
127 }
128 }
129 return result, metadata, err
130}
131
132type operationInputKey struct{}
133
134func setOperationInput(ctx context.Context, input interface{}) context.Context {
135 return middleware.WithStackValue(ctx, operationInputKey{}, input)
136}
137
138func getOperationInput(ctx context.Context) interface{} {
139 return middleware.GetStackValue(ctx, operationInputKey{})
140}
141
142type setOperationInputMiddleware struct {
143}
144
145func (*setOperationInputMiddleware) ID() string {
146 return "setOperationInput"
147}
148
149func (m *setOperationInputMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
150 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
151) {
152 ctx = setOperationInput(ctx, in.Parameters)
153 return next.HandleSerialize(ctx, in)
154}
155
156func addProtocolFinalizerMiddlewares(stack *middleware.Stack, options Options, operation string) error {
157 if err := stack.Finalize.Add(&resolveAuthSchemeMiddleware{operation: operation, options: options}, middleware.Before); err != nil {
158 return fmt.Errorf("add ResolveAuthScheme: %w", err)
159 }
160 if err := stack.Finalize.Insert(&getIdentityMiddleware{options: options}, "ResolveAuthScheme", middleware.After); err != nil {
161 return fmt.Errorf("add GetIdentity: %v", err)
162 }
163 if err := stack.Finalize.Insert(&resolveEndpointV2Middleware{options: options}, "GetIdentity", middleware.After); err != nil {
164 return fmt.Errorf("add ResolveEndpointV2: %v", err)
165 }
166 if err := stack.Finalize.Insert(&signRequestMiddleware{}, "ResolveEndpointV2", middleware.After); err != nil {
167 return fmt.Errorf("add Signing: %w", err)
168 }
169 return nil
170}
171func resolveAuthSchemeResolver(options *Options) {
172 if options.AuthSchemeResolver == nil {
173 options.AuthSchemeResolver = &defaultAuthSchemeResolver{}
174 }
175}
176
177func resolveAuthSchemes(options *Options) {
178 if options.AuthSchemes == nil {
179 options.AuthSchemes = []smithyhttp.AuthScheme{
180 internalauth.NewHTTPAuthScheme("aws.auth#sigv4", &internalauthsmithy.V4SignerAdapter{
181 Signer: options.HTTPSignerV4,
182 Logger: options.Logger,
183 LogSigning: options.ClientLogMode.IsSigning(),
184 }),
185 }
186 }
187}
188
189type noSmithyDocumentSerde = smithydocument.NoSerde
190
191type legacyEndpointContextSetter struct {
192 LegacyResolver EndpointResolver
193}
194
195func (*legacyEndpointContextSetter) ID() string {
196 return "legacyEndpointContextSetter"
197}
198
199func (m *legacyEndpointContextSetter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202 if m.LegacyResolver != nil {
203 ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true)
204 }
205
206 return next.HandleInitialize(ctx, in)
207
208}
209func addlegacyEndpointContextSetter(stack *middleware.Stack, o Options) error {
210 return stack.Initialize.Add(&legacyEndpointContextSetter{
211 LegacyResolver: o.EndpointResolver,
212 }, middleware.Before)
213}
214
215func resolveDefaultLogger(o *Options) {
216 if o.Logger != nil {
217 return
218 }
219 o.Logger = logging.Nop{}
220}
221
222func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
223 return middleware.AddSetLoggerMiddleware(stack, o.Logger)
224}
225
226func setResolvedDefaultsMode(o *Options) {
227 if len(o.resolvedDefaultsMode) > 0 {
228 return
229 }
230
231 var mode aws.DefaultsMode
232 mode.SetFromString(string(o.DefaultsMode))
233
234 if mode == aws.DefaultsModeAuto {
235 mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
236 }
237
238 o.resolvedDefaultsMode = mode
239}
240
241// NewFromConfig returns a new client from the provided config.
242func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
243 opts := Options{
244 Region: cfg.Region,
245 DefaultsMode: cfg.DefaultsMode,
246 RuntimeEnvironment: cfg.RuntimeEnvironment,
247 HTTPClient: cfg.HTTPClient,
248 Credentials: cfg.Credentials,
249 APIOptions: cfg.APIOptions,
250 Logger: cfg.Logger,
251 ClientLogMode: cfg.ClientLogMode,
252 AppID: cfg.AppID,
253 AccountIDEndpointMode: cfg.AccountIDEndpointMode,
254 }
255 resolveAWSRetryerProvider(cfg, &opts)
256 resolveAWSRetryMaxAttempts(cfg, &opts)
257 resolveAWSRetryMode(cfg, &opts)
258 resolveAWSEndpointResolver(cfg, &opts)
259 resolveUseDualStackEndpoint(cfg, &opts)
260 resolveUseFIPSEndpoint(cfg, &opts)
261 resolveBaseEndpoint(cfg, &opts)
262 return New(opts, optFns...)
263}
264
265func resolveHTTPClient(o *Options) {
266 var buildable *awshttp.BuildableClient
267
268 if o.HTTPClient != nil {
269 var ok bool
270 buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
271 if !ok {
272 return
273 }
274 } else {
275 buildable = awshttp.NewBuildableClient()
276 }
277
278 modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
279 if err == nil {
280 buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
281 if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
282 dialer.Timeout = dialerTimeout
283 }
284 })
285
286 buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
287 if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
288 transport.TLSHandshakeTimeout = tlsHandshakeTimeout
289 }
290 })
291 }
292
293 o.HTTPClient = buildable
294}
295
296func resolveRetryer(o *Options) {
297 if o.Retryer != nil {
298 return
299 }
300
301 if len(o.RetryMode) == 0 {
302 modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
303 if err == nil {
304 o.RetryMode = modeConfig.RetryMode
305 }
306 }
307 if len(o.RetryMode) == 0 {
308 o.RetryMode = aws.RetryModeStandard
309 }
310
311 var standardOptions []func(*retry.StandardOptions)
312 if v := o.RetryMaxAttempts; v != 0 {
313 standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
314 so.MaxAttempts = v
315 })
316 }
317
318 switch o.RetryMode {
319 case aws.RetryModeAdaptive:
320 var adaptiveOptions []func(*retry.AdaptiveModeOptions)
321 if len(standardOptions) != 0 {
322 adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
323 ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
324 })
325 }
326 o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
327
328 default:
329 o.Retryer = retry.NewStandard(standardOptions...)
330 }
331}
332
333func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
334 if cfg.Retryer == nil {
335 return
336 }
337 o.Retryer = cfg.Retryer()
338}
339
340func resolveAWSRetryMode(cfg aws.Config, o *Options) {
341 if len(cfg.RetryMode) == 0 {
342 return
343 }
344 o.RetryMode = cfg.RetryMode
345}
346func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
347 if cfg.RetryMaxAttempts == 0 {
348 return
349 }
350 o.RetryMaxAttempts = cfg.RetryMaxAttempts
351}
352
353func finalizeRetryMaxAttempts(o *Options) {
354 if o.RetryMaxAttempts == 0 {
355 return
356 }
357
358 o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
359}
360
361func finalizeOperationRetryMaxAttempts(o *Options, client Client) {
362 if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
363 return
364 }
365
366 o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
367}
368
369func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
370 if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
371 return
372 }
373 o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions)
374}
375
376func addClientUserAgent(stack *middleware.Stack, options Options) error {
377 ua, err := getOrAddRequestUserAgent(stack)
378 if err != nil {
379 return err
380 }
381
382 ua.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sts", goModuleVersion)
383 if len(options.AppID) > 0 {
384 ua.AddSDKAgentKey(awsmiddleware.ApplicationIdentifier, options.AppID)
385 }
386
387 return nil
388}
389
390func getOrAddRequestUserAgent(stack *middleware.Stack) (*awsmiddleware.RequestUserAgent, error) {
391 id := (*awsmiddleware.RequestUserAgent)(nil).ID()
392 mw, ok := stack.Build.Get(id)
393 if !ok {
394 mw = awsmiddleware.NewRequestUserAgent()
395 if err := stack.Build.Add(mw, middleware.After); err != nil {
396 return nil, err
397 }
398 }
399
400 ua, ok := mw.(*awsmiddleware.RequestUserAgent)
401 if !ok {
402 return nil, fmt.Errorf("%T for %s middleware did not match expected type", mw, id)
403 }
404
405 return ua, nil
406}
407
408type HTTPSignerV4 interface {
409 SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
410}
411
412func resolveHTTPSignerV4(o *Options) {
413 if o.HTTPSignerV4 != nil {
414 return
415 }
416 o.HTTPSignerV4 = newDefaultV4Signer(*o)
417}
418
419func newDefaultV4Signer(o Options) *v4.Signer {
420 return v4.NewSigner(func(so *v4.SignerOptions) {
421 so.Logger = o.Logger
422 so.LogSigning = o.ClientLogMode.IsSigning()
423 })
424}
425
426func addClientRequestID(stack *middleware.Stack) error {
427 return stack.Build.Add(&awsmiddleware.ClientRequestID{}, middleware.After)
428}
429
430func addComputeContentLength(stack *middleware.Stack) error {
431 return stack.Build.Add(&smithyhttp.ComputeContentLength{}, middleware.After)
432}
433
434func addRawResponseToMetadata(stack *middleware.Stack) error {
435 return stack.Deserialize.Add(&awsmiddleware.AddRawResponse{}, middleware.Before)
436}
437
438func addRecordResponseTiming(stack *middleware.Stack) error {
439 return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{}, middleware.After)
440}
441func addStreamingEventsPayload(stack *middleware.Stack) error {
442 return stack.Finalize.Add(&v4.StreamingEventsPayload{}, middleware.Before)
443}
444
445func addUnsignedPayload(stack *middleware.Stack) error {
446 return stack.Finalize.Insert(&v4.UnsignedPayload{}, "ResolveEndpointV2", middleware.After)
447}
448
449func addComputePayloadSHA256(stack *middleware.Stack) error {
450 return stack.Finalize.Insert(&v4.ComputePayloadSHA256{}, "ResolveEndpointV2", middleware.After)
451}
452
453func addContentSHA256Header(stack *middleware.Stack) error {
454 return stack.Finalize.Insert(&v4.ContentSHA256Header{}, (*v4.ComputePayloadSHA256)(nil).ID(), middleware.After)
455}
456
457func addIsWaiterUserAgent(o *Options) {
458 o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
459 ua, err := getOrAddRequestUserAgent(stack)
460 if err != nil {
461 return err
462 }
463
464 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureWaiter)
465 return nil
466 })
467}
468
469func addIsPaginatorUserAgent(o *Options) {
470 o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
471 ua, err := getOrAddRequestUserAgent(stack)
472 if err != nil {
473 return err
474 }
475
476 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeaturePaginator)
477 return nil
478 })
479}
480
481func addRetry(stack *middleware.Stack, o Options) error {
482 attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) {
483 m.LogAttempts = o.ClientLogMode.IsRetries()
484 })
485 if err := stack.Finalize.Insert(attempt, "Signing", middleware.Before); err != nil {
486 return err
487 }
488 if err := stack.Finalize.Insert(&retry.MetricsHeader{}, attempt.ID(), middleware.After); err != nil {
489 return err
490 }
491 return nil
492}
493
494// resolves dual-stack endpoint configuration
495func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
496 if len(cfg.ConfigSources) == 0 {
497 return nil
498 }
499 value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
500 if err != nil {
501 return err
502 }
503 if found {
504 o.EndpointOptions.UseDualStackEndpoint = value
505 }
506 return nil
507}
508
509// resolves FIPS endpoint configuration
510func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
511 if len(cfg.ConfigSources) == 0 {
512 return nil
513 }
514 value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
515 if err != nil {
516 return err
517 }
518 if found {
519 o.EndpointOptions.UseFIPSEndpoint = value
520 }
521 return nil
522}
523
524func resolveAccountID(identity smithyauth.Identity, mode aws.AccountIDEndpointMode) *string {
525 if mode == aws.AccountIDEndpointModeDisabled {
526 return nil
527 }
528
529 if ca, ok := identity.(*internalauthsmithy.CredentialsAdapter); ok && ca.Credentials.AccountID != "" {
530 return aws.String(ca.Credentials.AccountID)
531 }
532
533 return nil
534}
535
536func addTimeOffsetBuild(stack *middleware.Stack, c *Client) error {
537 mw := internalmiddleware.AddTimeOffsetMiddleware{Offset: c.timeOffset}
538 if err := stack.Build.Add(&mw, middleware.After); err != nil {
539 return err
540 }
541 return stack.Deserialize.Insert(&mw, "RecordResponseTiming", middleware.Before)
542}
543func initializeTimeOffsetResolver(c *Client) {
544 c.timeOffset = new(atomic.Int64)
545}
546
547func checkAccountID(identity smithyauth.Identity, mode aws.AccountIDEndpointMode) error {
548 switch mode {
549 case aws.AccountIDEndpointModeUnset:
550 case aws.AccountIDEndpointModePreferred:
551 case aws.AccountIDEndpointModeDisabled:
552 case aws.AccountIDEndpointModeRequired:
553 if ca, ok := identity.(*internalauthsmithy.CredentialsAdapter); !ok {
554 return fmt.Errorf("accountID is required but not set")
555 } else if ca.Credentials.AccountID == "" {
556 return fmt.Errorf("accountID is required but not set")
557 }
558 // default check in case invalid mode is configured through request config
559 default:
560 return fmt.Errorf("invalid accountID endpoint mode %s, must be preferred/required/disabled", mode)
561 }
562
563 return nil
564}
565
566func addUserAgentRetryMode(stack *middleware.Stack, options Options) error {
567 ua, err := getOrAddRequestUserAgent(stack)
568 if err != nil {
569 return err
570 }
571
572 switch options.Retryer.(type) {
573 case *retry.Standard:
574 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeStandard)
575 case *retry.AdaptiveMode:
576 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeAdaptive)
577 }
578 return nil
579}
580
581func addRecursionDetection(stack *middleware.Stack) error {
582 return stack.Build.Add(&awsmiddleware.RecursionDetection{}, middleware.After)
583}
584
585func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
586 return stack.Deserialize.Insert(&awsmiddleware.RequestIDRetriever{}, "OperationDeserializer", middleware.Before)
587
588}
589
590func addResponseErrorMiddleware(stack *middleware.Stack) error {
591 return stack.Deserialize.Insert(&awshttp.ResponseErrorWrapper{}, "RequestIDRetriever", middleware.Before)
592
593}
594
595// HTTPPresignerV4 represents presigner interface used by presign url client
596type HTTPPresignerV4 interface {
597 PresignHTTP(
598 ctx context.Context, credentials aws.Credentials, r *http.Request,
599 payloadHash string, service string, region string, signingTime time.Time,
600 optFns ...func(*v4.SignerOptions),
601 ) (url string, signedHeader http.Header, err error)
602}
603
604// PresignOptions represents the presign client options
605type PresignOptions struct {
606
607 // ClientOptions are list of functional options to mutate client options used by
608 // the presign client.
609 ClientOptions []func(*Options)
610
611 // Presigner is the presigner used by the presign url client
612 Presigner HTTPPresignerV4
613}
614
615func (o PresignOptions) copy() PresignOptions {
616 clientOptions := make([]func(*Options), len(o.ClientOptions))
617 copy(clientOptions, o.ClientOptions)
618 o.ClientOptions = clientOptions
619 return o
620}
621
622// WithPresignClientFromClientOptions is a helper utility to retrieve a function
623// that takes PresignOption as input
624func WithPresignClientFromClientOptions(optFns ...func(*Options)) func(*PresignOptions) {
625 return withPresignClientFromClientOptions(optFns).options
626}
627
628type withPresignClientFromClientOptions []func(*Options)
629
630func (w withPresignClientFromClientOptions) options(o *PresignOptions) {
631 o.ClientOptions = append(o.ClientOptions, w...)
632}
633
634// PresignClient represents the presign url client
635type PresignClient struct {
636 client *Client
637 options PresignOptions
638}
639
640// NewPresignClient generates a presign client using provided API Client and
641// presign options
642func NewPresignClient(c *Client, optFns ...func(*PresignOptions)) *PresignClient {
643 var options PresignOptions
644 for _, fn := range optFns {
645 fn(&options)
646 }
647 if len(options.ClientOptions) != 0 {
648 c = New(c.options, options.ClientOptions...)
649 }
650
651 if options.Presigner == nil {
652 options.Presigner = newDefaultV4Signer(c.options)
653 }
654
655 return &PresignClient{
656 client: c,
657 options: options,
658 }
659}
660
661func withNopHTTPClientAPIOption(o *Options) {
662 o.HTTPClient = smithyhttp.NopClient{}
663}
664
665type presignContextPolyfillMiddleware struct {
666}
667
668func (*presignContextPolyfillMiddleware) ID() string {
669 return "presignContextPolyfill"
670}
671
672func (m *presignContextPolyfillMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
673 out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
674) {
675 rscheme := getResolvedAuthScheme(ctx)
676 if rscheme == nil {
677 return out, metadata, fmt.Errorf("no resolved auth scheme")
678 }
679
680 schemeID := rscheme.Scheme.SchemeID()
681
682 if schemeID == "aws.auth#sigv4" || schemeID == "com.amazonaws.s3#sigv4express" {
683 if sn, ok := smithyhttp.GetSigV4SigningName(&rscheme.SignerProperties); ok {
684 ctx = awsmiddleware.SetSigningName(ctx, sn)
685 }
686 if sr, ok := smithyhttp.GetSigV4SigningRegion(&rscheme.SignerProperties); ok {
687 ctx = awsmiddleware.SetSigningRegion(ctx, sr)
688 }
689 } else if schemeID == "aws.auth#sigv4a" {
690 if sn, ok := smithyhttp.GetSigV4ASigningName(&rscheme.SignerProperties); ok {
691 ctx = awsmiddleware.SetSigningName(ctx, sn)
692 }
693 if sr, ok := smithyhttp.GetSigV4ASigningRegions(&rscheme.SignerProperties); ok {
694 ctx = awsmiddleware.SetSigningRegion(ctx, sr[0])
695 }
696 }
697
698 return next.HandleFinalize(ctx, in)
699}
700
701type presignConverter PresignOptions
702
703func (c presignConverter) convertToPresignMiddleware(stack *middleware.Stack, options Options) (err error) {
704 if _, ok := stack.Finalize.Get((*acceptencodingcust.DisableGzip)(nil).ID()); ok {
705 stack.Finalize.Remove((*acceptencodingcust.DisableGzip)(nil).ID())
706 }
707 if _, ok := stack.Finalize.Get((*retry.Attempt)(nil).ID()); ok {
708 stack.Finalize.Remove((*retry.Attempt)(nil).ID())
709 }
710 if _, ok := stack.Finalize.Get((*retry.MetricsHeader)(nil).ID()); ok {
711 stack.Finalize.Remove((*retry.MetricsHeader)(nil).ID())
712 }
713 stack.Deserialize.Clear()
714 stack.Build.Remove((*awsmiddleware.ClientRequestID)(nil).ID())
715 stack.Build.Remove("UserAgent")
716 if err := stack.Finalize.Insert(&presignContextPolyfillMiddleware{}, "Signing", middleware.Before); err != nil {
717 return err
718 }
719
720 pmw := v4.NewPresignHTTPRequestMiddleware(v4.PresignHTTPRequestMiddlewareOptions{
721 CredentialsProvider: options.Credentials,
722 Presigner: c.Presigner,
723 LogSigning: options.ClientLogMode.IsSigning(),
724 })
725 if _, err := stack.Finalize.Swap("Signing", pmw); err != nil {
726 return err
727 }
728 if err = smithyhttp.AddNoPayloadDefaultContentTypeRemover(stack); err != nil {
729 return err
730 }
731 // convert request to a GET request
732 err = query.AddAsGetRequestMiddleware(stack)
733 if err != nil {
734 return err
735 }
736 err = presignedurlcust.AddAsIsPresigningMiddleware(stack)
737 if err != nil {
738 return err
739 }
740 return nil
741}
742
743func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
744 return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
745 LogRequest: o.ClientLogMode.IsRequest(),
746 LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
747 LogResponse: o.ClientLogMode.IsResponse(),
748 LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
749 }, middleware.After)
750}
751
752type disableHTTPSMiddleware struct {
753 DisableHTTPS bool
754}
755
756func (*disableHTTPSMiddleware) ID() string {
757 return "disableHTTPS"
758}
759
760func (m *disableHTTPSMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
761 out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
762) {
763 req, ok := in.Request.(*smithyhttp.Request)
764 if !ok {
765 return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
766 }
767
768 if m.DisableHTTPS && !smithyhttp.GetHostnameImmutable(ctx) {
769 req.URL.Scheme = "http"
770 }
771
772 return next.HandleFinalize(ctx, in)
773}
774
775func addDisableHTTPSMiddleware(stack *middleware.Stack, o Options) error {
776 return stack.Finalize.Insert(&disableHTTPSMiddleware{
777 DisableHTTPS: o.EndpointOptions.DisableHTTPS,
778 }, "ResolveEndpointV2", middleware.After)
779}