api_client.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package sts
4
5 import (
6 "context"
7 "errors"
8 "fmt"
9 "github.com/aws/aws-sdk-go-v2/aws"
10 "github.com/aws/aws-sdk-go-v2/aws/defaults"
11 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
12 "github.com/aws/aws-sdk-go-v2/aws/protocol/query"
13 "github.com/aws/aws-sdk-go-v2/aws/retry"
14 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
15 awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
16 internalauth "github.com/aws/aws-sdk-go-v2/internal/auth"
17 internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy"
18 internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
19 internalmiddleware "github.com/aws/aws-sdk-go-v2/internal/middleware"
20 acceptencodingcust "github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding"
21 presignedurlcust "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url"
22 smithy "github.com/aws/smithy-go"
23 smithyauth "github.com/aws/smithy-go/auth"
24 smithydocument "github.com/aws/smithy-go/document"
25 "github.com/aws/smithy-go/logging"
26 "github.com/aws/smithy-go/metrics"
27 "github.com/aws/smithy-go/middleware"
28 "github.com/aws/smithy-go/tracing"
29 smithyhttp "github.com/aws/smithy-go/transport/http"
30 "net"
31 "net/http"
32 "sync/atomic"
33 "time"
34 )
35
36 const ServiceID = "STS"
37 const ServiceAPIVersion = "2011-06-15"
38
39 type operationMetrics struct {
40 Duration metrics.Float64Histogram
41 SerializeDuration metrics.Float64Histogram
42 ResolveIdentityDuration metrics.Float64Histogram
43 ResolveEndpointDuration metrics.Float64Histogram
44 SignRequestDuration metrics.Float64Histogram
45 DeserializeDuration metrics.Float64Histogram
46 }
47
48 func (m *operationMetrics) histogramFor(name string) metrics.Float64Histogram {
49 switch name {
50 case "client.call.duration":
51 return m.Duration
52 case "client.call.serialization_duration":
53 return m.SerializeDuration
54 case "client.call.resolve_identity_duration":
55 return m.ResolveIdentityDuration
56 case "client.call.resolve_endpoint_duration":
57 return m.ResolveEndpointDuration
58 case "client.call.signing_duration":
59 return m.SignRequestDuration
60 case "client.call.deserialization_duration":
61 return m.DeserializeDuration
62 default:
63 panic("unrecognized operation metric")
64 }
65 }
66
67 func timeOperationMetric[T any](
68 ctx context.Context, metric string, fn func() (T, error),
69 opts ...metrics.RecordMetricOption,
70 ) (T, error) {
71 mm := getOperationMetrics(ctx)
72 if mm == nil { // not using the metrics system
73 return fn()
74 }
75
76 instr := mm.histogramFor(metric)
77 opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
78
79 start := time.Now()
80 v, err := fn()
81 end := time.Now()
82
83 elapsed := end.Sub(start)
84 instr.Record(ctx, float64(elapsed)/1e9, opts...)
85 return v, err
86 }
87
88 func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() {
89 mm := getOperationMetrics(ctx)
90 if mm == nil { // not using the metrics system
91 return func() {}
92 }
93
94 instr := mm.histogramFor(metric)
95 opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
96
97 var ended bool
98 start := time.Now()
99 return func() {
100 if ended {
101 return
102 }
103 ended = true
104
105 end := time.Now()
106
107 elapsed := end.Sub(start)
108 instr.Record(ctx, float64(elapsed)/1e9, opts...)
109 }
110 }
111
112 func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption {
113 return func(o *metrics.RecordMetricOptions) {
114 o.Properties.Set("rpc.service", middleware.GetServiceID(ctx))
115 o.Properties.Set("rpc.method", middleware.GetOperationName(ctx))
116 }
117 }
118
119 type operationMetricsKey struct{}
120
121 func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) {
122 if _, ok := mp.(metrics.NopMeterProvider); ok {
123 // not using the metrics system - setting up the metrics context is a memory-intensive operation
124 // so we should skip it in this case
125 return parent, nil
126 }
127
128 meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
129 om := &operationMetrics{}
130
131 var err error
132
133 om.Duration, err = operationMetricTimer(meter, "client.call.duration",
134 "Overall call duration (including retries and time to send or receive request and response body)")
135 if err != nil {
136 return nil, err
137 }
138 om.SerializeDuration, err = operationMetricTimer(meter, "client.call.serialization_duration",
139 "The time it takes to serialize a message body")
140 if err != nil {
141 return nil, err
142 }
143 om.ResolveIdentityDuration, err = operationMetricTimer(meter, "client.call.auth.resolve_identity_duration",
144 "The time taken to acquire an identity (AWS credentials, bearer token, etc) from an Identity Provider")
145 if err != nil {
146 return nil, err
147 }
148 om.ResolveEndpointDuration, err = operationMetricTimer(meter, "client.call.resolve_endpoint_duration",
149 "The time it takes to resolve an endpoint (endpoint resolver, not DNS) for the request")
150 if err != nil {
151 return nil, err
152 }
153 om.SignRequestDuration, err = operationMetricTimer(meter, "client.call.auth.signing_duration",
154 "The time it takes to sign a request")
155 if err != nil {
156 return nil, err
157 }
158 om.DeserializeDuration, err = operationMetricTimer(meter, "client.call.deserialization_duration",
159 "The time it takes to deserialize a message body")
160 if err != nil {
161 return nil, err
162 }
163
164 return context.WithValue(parent, operationMetricsKey{}, om), nil
165 }
166
167 func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Histogram, error) {
168 return m.Float64Histogram(name, func(o *metrics.InstrumentOptions) {
169 o.UnitLabel = "s"
170 o.Description = desc
171 })
172 }
173
174 func getOperationMetrics(ctx context.Context) *operationMetrics {
175 if v := ctx.Value(operationMetricsKey{}); v != nil {
176 return v.(*operationMetrics)
177 }
178 return nil
179 }
180
181 func operationTracer(p tracing.TracerProvider) tracing.Tracer {
182 return p.Tracer("github.com/aws/aws-sdk-go-v2/service/sts")
183 }
184
185 // Client provides the API client to make operations call for AWS Security Token
186 // Service.
187 type Client struct {
188 options Options
189
190 // Difference between the time reported by the server and the client
191 timeOffset *atomic.Int64
192 }
193
194 // New returns an initialized Client based on the functional options. Provide
195 // additional functional options to further configure the behavior of the client,
196 // such as changing the client's endpoint or adding custom middleware behavior.
197 func New(options Options, optFns ...func(*Options)) *Client {
198 options = options.Copy()
199
200 resolveDefaultLogger(&options)
201
202 setResolvedDefaultsMode(&options)
203
204 resolveRetryer(&options)
205
206 resolveHTTPClient(&options)
207
208 resolveHTTPSignerV4(&options)
209
210 resolveEndpointResolverV2(&options)
211
212 resolveTracerProvider(&options)
213
214 resolveMeterProvider(&options)
215
216 resolveAuthSchemeResolver(&options)
217
218 for _, fn := range optFns {
219 fn(&options)
220 }
221
222 finalizeRetryMaxAttempts(&options)
223
224 ignoreAnonymousAuth(&options)
225
226 wrapWithAnonymousAuth(&options)
227
228 resolveAuthSchemes(&options)
229
230 client := &Client{
231 options: options,
232 }
233
234 initializeTimeOffsetResolver(client)
235
236 return client
237 }
238
239 // Options returns a copy of the client configuration.
240 //
241 // Callers SHOULD NOT perform mutations on any inner structures within client
242 // config. Config overrides should instead be made on a per-operation basis through
243 // functional options.
244 func (c *Client) Options() Options {
245 return c.options.Copy()
246 }
247
248 func (c *Client) invokeOperation(
249 ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error,
250 ) (
251 result interface{}, metadata middleware.Metadata, err error,
252 ) {
253 ctx = middleware.ClearStackValues(ctx)
254 ctx = middleware.WithServiceID(ctx, ServiceID)
255 ctx = middleware.WithOperationName(ctx, opID)
256
257 stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
258 options := c.options.Copy()
259
260 for _, fn := range optFns {
261 fn(&options)
262 }
263
264 finalizeOperationRetryMaxAttempts(&options, *c)
265
266 finalizeClientEndpointResolverOptions(&options)
267
268 for _, fn := range stackFns {
269 if err := fn(stack, options); err != nil {
270 return nil, metadata, err
271 }
272 }
273
274 for _, fn := range options.APIOptions {
275 if err := fn(stack); err != nil {
276 return nil, metadata, err
277 }
278 }
279
280 ctx, err = withOperationMetrics(ctx, options.MeterProvider)
281 if err != nil {
282 return nil, metadata, err
283 }
284
285 tracer := operationTracer(options.TracerProvider)
286 spanName := fmt.Sprintf("%s.%s", ServiceID, opID)
287
288 ctx = tracing.WithOperationTracer(ctx, tracer)
289
290 ctx, span := tracer.StartSpan(ctx, spanName, func(o *tracing.SpanOptions) {
291 o.Kind = tracing.SpanKindClient
292 o.Properties.Set("rpc.system", "aws-api")
293 o.Properties.Set("rpc.method", opID)
294 o.Properties.Set("rpc.service", ServiceID)
295 })
296 endTimer := startMetricTimer(ctx, "client.call.duration")
297 defer endTimer()
298 defer span.End()
299
300 handler := smithyhttp.NewClientHandlerWithOptions(options.HTTPClient, func(o *smithyhttp.ClientHandler) {
301 o.Meter = options.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
302 })
303 decorated := middleware.DecorateHandler(handler, stack)
304 result, metadata, err = decorated.Handle(ctx, params)
305 if err != nil {
306 span.SetProperty("exception.type", fmt.Sprintf("%T", err))
307 span.SetProperty("exception.message", err.Error())
308
309 var aerr smithy.APIError
310 if errors.As(err, &aerr) {
311 span.SetProperty("api.error_code", aerr.ErrorCode())
312 span.SetProperty("api.error_message", aerr.ErrorMessage())
313 span.SetProperty("api.error_fault", aerr.ErrorFault().String())
314 }
315
316 err = &smithy.OperationError{
317 ServiceID: ServiceID,
318 OperationName: opID,
319 Err: err,
320 }
321 }
322
323 span.SetProperty("error", err != nil)
324 if err == nil {
325 span.SetStatus(tracing.SpanStatusOK)
326 } else {
327 span.SetStatus(tracing.SpanStatusError)
328 }
329
330 return result, metadata, err
331 }
332
333 type operationInputKey struct{}
334
335 func setOperationInput(ctx context.Context, input interface{}) context.Context {
336 return middleware.WithStackValue(ctx, operationInputKey{}, input)
337 }
338
339 func getOperationInput(ctx context.Context) interface{} {
340 return middleware.GetStackValue(ctx, operationInputKey{})
341 }
342
343 type setOperationInputMiddleware struct {
344 }
345
346 func (*setOperationInputMiddleware) ID() string {
347 return "setOperationInput"
348 }
349
350 func (m *setOperationInputMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
351 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
352 ) {
353 ctx = setOperationInput(ctx, in.Parameters)
354 return next.HandleSerialize(ctx, in)
355 }
356
357 func addProtocolFinalizerMiddlewares(stack *middleware.Stack, options Options, operation string) error {
358 if err := stack.Finalize.Add(&resolveAuthSchemeMiddleware{operation: operation, options: options}, middleware.Before); err != nil {
359 return fmt.Errorf("add ResolveAuthScheme: %w", err)
360 }
361 if err := stack.Finalize.Insert(&getIdentityMiddleware{options: options}, "ResolveAuthScheme", middleware.After); err != nil {
362 return fmt.Errorf("add GetIdentity: %v", err)
363 }
364 if err := stack.Finalize.Insert(&resolveEndpointV2Middleware{options: options}, "GetIdentity", middleware.After); err != nil {
365 return fmt.Errorf("add ResolveEndpointV2: %v", err)
366 }
367 if err := stack.Finalize.Insert(&signRequestMiddleware{options: options}, "ResolveEndpointV2", middleware.After); err != nil {
368 return fmt.Errorf("add Signing: %w", err)
369 }
370 return nil
371 }
372 func resolveAuthSchemeResolver(options *Options) {
373 if options.AuthSchemeResolver == nil {
374 options.AuthSchemeResolver = &defaultAuthSchemeResolver{}
375 }
376 }
377
378 func resolveAuthSchemes(options *Options) {
379 if options.AuthSchemes == nil {
380 options.AuthSchemes = []smithyhttp.AuthScheme{
381 internalauth.NewHTTPAuthScheme("aws.auth#sigv4", &internalauthsmithy.V4SignerAdapter{
382 Signer: options.HTTPSignerV4,
383 Logger: options.Logger,
384 LogSigning: options.ClientLogMode.IsSigning(),
385 }),
386 }
387 }
388 }
389
390 type noSmithyDocumentSerde = smithydocument.NoSerde
391
392 type legacyEndpointContextSetter struct {
393 LegacyResolver EndpointResolver
394 }
395
396 func (*legacyEndpointContextSetter) ID() string {
397 return "legacyEndpointContextSetter"
398 }
399
400 func (m *legacyEndpointContextSetter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
401 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
402 ) {
403 if m.LegacyResolver != nil {
404 ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true)
405 }
406
407 return next.HandleInitialize(ctx, in)
408
409 }
410 func addlegacyEndpointContextSetter(stack *middleware.Stack, o Options) error {
411 return stack.Initialize.Add(&legacyEndpointContextSetter{
412 LegacyResolver: o.EndpointResolver,
413 }, middleware.Before)
414 }
415
416 func resolveDefaultLogger(o *Options) {
417 if o.Logger != nil {
418 return
419 }
420 o.Logger = logging.Nop{}
421 }
422
423 func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
424 return middleware.AddSetLoggerMiddleware(stack, o.Logger)
425 }
426
427 func setResolvedDefaultsMode(o *Options) {
428 if len(o.resolvedDefaultsMode) > 0 {
429 return
430 }
431
432 var mode aws.DefaultsMode
433 mode.SetFromString(string(o.DefaultsMode))
434
435 if mode == aws.DefaultsModeAuto {
436 mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
437 }
438
439 o.resolvedDefaultsMode = mode
440 }
441
442 // NewFromConfig returns a new client from the provided config.
443 func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
444 opts := Options{
445 Region: cfg.Region,
446 DefaultsMode: cfg.DefaultsMode,
447 RuntimeEnvironment: cfg.RuntimeEnvironment,
448 HTTPClient: cfg.HTTPClient,
449 Credentials: cfg.Credentials,
450 APIOptions: cfg.APIOptions,
451 Logger: cfg.Logger,
452 ClientLogMode: cfg.ClientLogMode,
453 AppID: cfg.AppID,
454 AuthSchemePreference: cfg.AuthSchemePreference,
455 }
456 resolveAWSRetryerProvider(cfg, &opts)
457 resolveAWSRetryMaxAttempts(cfg, &opts)
458 resolveAWSRetryMode(cfg, &opts)
459 resolveAWSEndpointResolver(cfg, &opts)
460 resolveInterceptors(cfg, &opts)
461 resolveUseDualStackEndpoint(cfg, &opts)
462 resolveUseFIPSEndpoint(cfg, &opts)
463 resolveBaseEndpoint(cfg, &opts)
464 return New(opts, func(o *Options) {
465 for _, opt := range cfg.ServiceOptions {
466 opt(ServiceID, o)
467 }
468 for _, opt := range optFns {
469 opt(o)
470 }
471 })
472 }
473
474 func resolveHTTPClient(o *Options) {
475 var buildable *awshttp.BuildableClient
476
477 if o.HTTPClient != nil {
478 var ok bool
479 buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
480 if !ok {
481 return
482 }
483 } else {
484 buildable = awshttp.NewBuildableClient()
485 }
486
487 modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
488 if err == nil {
489 buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
490 if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
491 dialer.Timeout = dialerTimeout
492 }
493 })
494
495 buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
496 if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
497 transport.TLSHandshakeTimeout = tlsHandshakeTimeout
498 }
499 })
500 }
501
502 o.HTTPClient = buildable
503 }
504
505 func resolveRetryer(o *Options) {
506 if o.Retryer != nil {
507 return
508 }
509
510 if len(o.RetryMode) == 0 {
511 modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
512 if err == nil {
513 o.RetryMode = modeConfig.RetryMode
514 }
515 }
516 if len(o.RetryMode) == 0 {
517 o.RetryMode = aws.RetryModeStandard
518 }
519
520 var standardOptions []func(*retry.StandardOptions)
521 if v := o.RetryMaxAttempts; v != 0 {
522 standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
523 so.MaxAttempts = v
524 })
525 }
526
527 switch o.RetryMode {
528 case aws.RetryModeAdaptive:
529 var adaptiveOptions []func(*retry.AdaptiveModeOptions)
530 if len(standardOptions) != 0 {
531 adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
532 ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
533 })
534 }
535 o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
536
537 default:
538 o.Retryer = retry.NewStandard(standardOptions...)
539 }
540 }
541
542 func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
543 if cfg.Retryer == nil {
544 return
545 }
546 o.Retryer = cfg.Retryer()
547 }
548
549 func resolveAWSRetryMode(cfg aws.Config, o *Options) {
550 if len(cfg.RetryMode) == 0 {
551 return
552 }
553 o.RetryMode = cfg.RetryMode
554 }
555 func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
556 if cfg.RetryMaxAttempts == 0 {
557 return
558 }
559 o.RetryMaxAttempts = cfg.RetryMaxAttempts
560 }
561
562 func finalizeRetryMaxAttempts(o *Options) {
563 if o.RetryMaxAttempts == 0 {
564 return
565 }
566
567 o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
568 }
569
570 func finalizeOperationRetryMaxAttempts(o *Options, client Client) {
571 if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
572 return
573 }
574
575 o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
576 }
577
578 func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
579 if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
580 return
581 }
582 o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions)
583 }
584
585 func resolveInterceptors(cfg aws.Config, o *Options) {
586 o.Interceptors = cfg.Interceptors.Copy()
587 }
588
589 func addClientUserAgent(stack *middleware.Stack, options Options) error {
590 ua, err := getOrAddRequestUserAgent(stack)
591 if err != nil {
592 return err
593 }
594
595 ua.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sts", goModuleVersion)
596 if len(options.AppID) > 0 {
597 ua.AddSDKAgentKey(awsmiddleware.ApplicationIdentifier, options.AppID)
598 }
599
600 return nil
601 }
602
603 func getOrAddRequestUserAgent(stack *middleware.Stack) (*awsmiddleware.RequestUserAgent, error) {
604 id := (*awsmiddleware.RequestUserAgent)(nil).ID()
605 mw, ok := stack.Build.Get(id)
606 if !ok {
607 mw = awsmiddleware.NewRequestUserAgent()
608 if err := stack.Build.Add(mw, middleware.After); err != nil {
609 return nil, err
610 }
611 }
612
613 ua, ok := mw.(*awsmiddleware.RequestUserAgent)
614 if !ok {
615 return nil, fmt.Errorf("%T for %s middleware did not match expected type", mw, id)
616 }
617
618 return ua, nil
619 }
620
621 type HTTPSignerV4 interface {
622 SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
623 }
624
625 func resolveHTTPSignerV4(o *Options) {
626 if o.HTTPSignerV4 != nil {
627 return
628 }
629 o.HTTPSignerV4 = newDefaultV4Signer(*o)
630 }
631
632 func newDefaultV4Signer(o Options) *v4.Signer {
633 return v4.NewSigner(func(so *v4.SignerOptions) {
634 so.Logger = o.Logger
635 so.LogSigning = o.ClientLogMode.IsSigning()
636 })
637 }
638
639 func addClientRequestID(stack *middleware.Stack) error {
640 return stack.Build.Add(&awsmiddleware.ClientRequestID{}, middleware.After)
641 }
642
643 func addComputeContentLength(stack *middleware.Stack) error {
644 return stack.Build.Add(&smithyhttp.ComputeContentLength{}, middleware.After)
645 }
646
647 func addRawResponseToMetadata(stack *middleware.Stack) error {
648 return stack.Deserialize.Add(&awsmiddleware.AddRawResponse{}, middleware.Before)
649 }
650
651 func addRecordResponseTiming(stack *middleware.Stack) error {
652 return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{}, middleware.After)
653 }
654
655 func addSpanRetryLoop(stack *middleware.Stack, options Options) error {
656 return stack.Finalize.Insert(&spanRetryLoop{options: options}, "Retry", middleware.Before)
657 }
658
659 type spanRetryLoop struct {
660 options Options
661 }
662
663 func (*spanRetryLoop) ID() string {
664 return "spanRetryLoop"
665 }
666
667 func (m *spanRetryLoop) HandleFinalize(
668 ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
669 ) (
670 middleware.FinalizeOutput, middleware.Metadata, error,
671 ) {
672 tracer := operationTracer(m.options.TracerProvider)
673 ctx, span := tracer.StartSpan(ctx, "RetryLoop")
674 defer span.End()
675
676 return next.HandleFinalize(ctx, in)
677 }
678 func addStreamingEventsPayload(stack *middleware.Stack) error {
679 return stack.Finalize.Add(&v4.StreamingEventsPayload{}, middleware.Before)
680 }
681
682 func addUnsignedPayload(stack *middleware.Stack) error {
683 return stack.Finalize.Insert(&v4.UnsignedPayload{}, "ResolveEndpointV2", middleware.After)
684 }
685
686 func addComputePayloadSHA256(stack *middleware.Stack) error {
687 return stack.Finalize.Insert(&v4.ComputePayloadSHA256{}, "ResolveEndpointV2", middleware.After)
688 }
689
690 func addContentSHA256Header(stack *middleware.Stack) error {
691 return stack.Finalize.Insert(&v4.ContentSHA256Header{}, (*v4.ComputePayloadSHA256)(nil).ID(), middleware.After)
692 }
693
694 func addIsWaiterUserAgent(o *Options) {
695 o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
696 ua, err := getOrAddRequestUserAgent(stack)
697 if err != nil {
698 return err
699 }
700
701 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureWaiter)
702 return nil
703 })
704 }
705
706 func addIsPaginatorUserAgent(o *Options) {
707 o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
708 ua, err := getOrAddRequestUserAgent(stack)
709 if err != nil {
710 return err
711 }
712
713 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeaturePaginator)
714 return nil
715 })
716 }
717
718 func addRetry(stack *middleware.Stack, o Options) error {
719 attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) {
720 m.LogAttempts = o.ClientLogMode.IsRetries()
721 m.OperationMeter = o.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
722 })
723 if err := stack.Finalize.Insert(attempt, "ResolveAuthScheme", middleware.Before); err != nil {
724 return err
725 }
726 if err := stack.Finalize.Insert(&retry.MetricsHeader{}, attempt.ID(), middleware.After); err != nil {
727 return err
728 }
729 return nil
730 }
731
732 // resolves dual-stack endpoint configuration
733 func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
734 if len(cfg.ConfigSources) == 0 {
735 return nil
736 }
737 value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
738 if err != nil {
739 return err
740 }
741 if found {
742 o.EndpointOptions.UseDualStackEndpoint = value
743 }
744 return nil
745 }
746
747 // resolves FIPS endpoint configuration
748 func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
749 if len(cfg.ConfigSources) == 0 {
750 return nil
751 }
752 value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
753 if err != nil {
754 return err
755 }
756 if found {
757 o.EndpointOptions.UseFIPSEndpoint = value
758 }
759 return nil
760 }
761
762 func resolveAccountID(identity smithyauth.Identity, mode aws.AccountIDEndpointMode) *string {
763 if mode == aws.AccountIDEndpointModeDisabled {
764 return nil
765 }
766
767 if ca, ok := identity.(*internalauthsmithy.CredentialsAdapter); ok && ca.Credentials.AccountID != "" {
768 return aws.String(ca.Credentials.AccountID)
769 }
770
771 return nil
772 }
773
774 func addTimeOffsetBuild(stack *middleware.Stack, c *Client) error {
775 mw := internalmiddleware.AddTimeOffsetMiddleware{Offset: c.timeOffset}
776 if err := stack.Build.Add(&mw, middleware.After); err != nil {
777 return err
778 }
779 return stack.Deserialize.Insert(&mw, "RecordResponseTiming", middleware.Before)
780 }
781 func initializeTimeOffsetResolver(c *Client) {
782 c.timeOffset = new(atomic.Int64)
783 }
784
785 func addUserAgentRetryMode(stack *middleware.Stack, options Options) error {
786 ua, err := getOrAddRequestUserAgent(stack)
787 if err != nil {
788 return err
789 }
790
791 switch options.Retryer.(type) {
792 case *retry.Standard:
793 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeStandard)
794 case *retry.AdaptiveMode:
795 ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeAdaptive)
796 }
797 return nil
798 }
799
800 type setCredentialSourceMiddleware struct {
801 ua *awsmiddleware.RequestUserAgent
802 options Options
803 }
804
805 func (m setCredentialSourceMiddleware) ID() string { return "SetCredentialSourceMiddleware" }
806
807 func (m setCredentialSourceMiddleware) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
808 out middleware.BuildOutput, metadata middleware.Metadata, err error,
809 ) {
810 asProviderSource, ok := m.options.Credentials.(aws.CredentialProviderSource)
811 if !ok {
812 return next.HandleBuild(ctx, in)
813 }
814 providerSources := asProviderSource.ProviderSources()
815 for _, source := range providerSources {
816 m.ua.AddCredentialsSource(source)
817 }
818 return next.HandleBuild(ctx, in)
819 }
820
821 func addCredentialSource(stack *middleware.Stack, options Options) error {
822 ua, err := getOrAddRequestUserAgent(stack)
823 if err != nil {
824 return err
825 }
826
827 mw := setCredentialSourceMiddleware{ua: ua, options: options}
828 return stack.Build.Insert(&mw, "UserAgent", middleware.Before)
829 }
830
831 func resolveTracerProvider(options *Options) {
832 if options.TracerProvider == nil {
833 options.TracerProvider = &tracing.NopTracerProvider{}
834 }
835 }
836
837 func resolveMeterProvider(options *Options) {
838 if options.MeterProvider == nil {
839 options.MeterProvider = metrics.NopMeterProvider{}
840 }
841 }
842
843 func addRecursionDetection(stack *middleware.Stack) error {
844 return stack.Build.Add(&awsmiddleware.RecursionDetection{}, middleware.After)
845 }
846
847 func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
848 return stack.Deserialize.Insert(&awsmiddleware.RequestIDRetriever{}, "OperationDeserializer", middleware.Before)
849
850 }
851
852 func addResponseErrorMiddleware(stack *middleware.Stack) error {
853 return stack.Deserialize.Insert(&awshttp.ResponseErrorWrapper{}, "RequestIDRetriever", middleware.Before)
854
855 }
856
857 // HTTPPresignerV4 represents presigner interface used by presign url client
858 type HTTPPresignerV4 interface {
859 PresignHTTP(
860 ctx context.Context, credentials aws.Credentials, r *http.Request,
861 payloadHash string, service string, region string, signingTime time.Time,
862 optFns ...func(*v4.SignerOptions),
863 ) (url string, signedHeader http.Header, err error)
864 }
865
866 // PresignOptions represents the presign client options
867 type PresignOptions struct {
868
869 // ClientOptions are list of functional options to mutate client options used by
870 // the presign client.
871 ClientOptions []func(*Options)
872
873 // Presigner is the presigner used by the presign url client
874 Presigner HTTPPresignerV4
875 }
876
877 func (o PresignOptions) copy() PresignOptions {
878 clientOptions := make([]func(*Options), len(o.ClientOptions))
879 copy(clientOptions, o.ClientOptions)
880 o.ClientOptions = clientOptions
881 return o
882 }
883
884 // WithPresignClientFromClientOptions is a helper utility to retrieve a function
885 // that takes PresignOption as input
886 func WithPresignClientFromClientOptions(optFns ...func(*Options)) func(*PresignOptions) {
887 return withPresignClientFromClientOptions(optFns).options
888 }
889
890 type withPresignClientFromClientOptions []func(*Options)
891
892 func (w withPresignClientFromClientOptions) options(o *PresignOptions) {
893 o.ClientOptions = append(o.ClientOptions, w...)
894 }
895
896 // PresignClient represents the presign url client
897 type PresignClient struct {
898 client *Client
899 options PresignOptions
900 }
901
902 // NewPresignClient generates a presign client using provided API Client and
903 // presign options
904 func NewPresignClient(c *Client, optFns ...func(*PresignOptions)) *PresignClient {
905 var options PresignOptions
906 for _, fn := range optFns {
907 fn(&options)
908 }
909 if len(options.ClientOptions) != 0 {
910 c = New(c.options, options.ClientOptions...)
911 }
912
913 if options.Presigner == nil {
914 options.Presigner = newDefaultV4Signer(c.options)
915 }
916
917 return &PresignClient{
918 client: c,
919 options: options,
920 }
921 }
922
923 func withNopHTTPClientAPIOption(o *Options) {
924 o.HTTPClient = smithyhttp.NopClient{}
925 }
926
927 type presignContextPolyfillMiddleware struct {
928 }
929
930 func (*presignContextPolyfillMiddleware) ID() string {
931 return "presignContextPolyfill"
932 }
933
934 func (m *presignContextPolyfillMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
935 out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
936 ) {
937 rscheme := getResolvedAuthScheme(ctx)
938 if rscheme == nil {
939 return out, metadata, fmt.Errorf("no resolved auth scheme")
940 }
941
942 schemeID := rscheme.Scheme.SchemeID()
943
944 if schemeID == "aws.auth#sigv4" || schemeID == "com.amazonaws.s3#sigv4express" {
945 if sn, ok := smithyhttp.GetSigV4SigningName(&rscheme.SignerProperties); ok {
946 ctx = awsmiddleware.SetSigningName(ctx, sn)
947 }
948 if sr, ok := smithyhttp.GetSigV4SigningRegion(&rscheme.SignerProperties); ok {
949 ctx = awsmiddleware.SetSigningRegion(ctx, sr)
950 }
951 } else if schemeID == "aws.auth#sigv4a" {
952 if sn, ok := smithyhttp.GetSigV4ASigningName(&rscheme.SignerProperties); ok {
953 ctx = awsmiddleware.SetSigningName(ctx, sn)
954 }
955 if sr, ok := smithyhttp.GetSigV4ASigningRegions(&rscheme.SignerProperties); ok {
956 ctx = awsmiddleware.SetSigningRegion(ctx, sr[0])
957 }
958 }
959
960 return next.HandleFinalize(ctx, in)
961 }
962
963 type presignConverter PresignOptions
964
965 func (c presignConverter) convertToPresignMiddleware(stack *middleware.Stack, options Options) (err error) {
966 if _, ok := stack.Finalize.Get((*acceptencodingcust.DisableGzip)(nil).ID()); ok {
967 stack.Finalize.Remove((*acceptencodingcust.DisableGzip)(nil).ID())
968 }
969 if _, ok := stack.Finalize.Get((*retry.Attempt)(nil).ID()); ok {
970 stack.Finalize.Remove((*retry.Attempt)(nil).ID())
971 }
972 if _, ok := stack.Finalize.Get((*retry.MetricsHeader)(nil).ID()); ok {
973 stack.Finalize.Remove((*retry.MetricsHeader)(nil).ID())
974 }
975 stack.Deserialize.Clear()
976 stack.Build.Remove((*awsmiddleware.ClientRequestID)(nil).ID())
977 stack.Build.Remove("UserAgent")
978 if err := stack.Finalize.Insert(&presignContextPolyfillMiddleware{}, "Signing", middleware.Before); err != nil {
979 return err
980 }
981
982 pmw := v4.NewPresignHTTPRequestMiddleware(v4.PresignHTTPRequestMiddlewareOptions{
983 CredentialsProvider: options.Credentials,
984 Presigner: c.Presigner,
985 LogSigning: options.ClientLogMode.IsSigning(),
986 })
987 if _, err := stack.Finalize.Swap("Signing", pmw); err != nil {
988 return err
989 }
990 if err = smithyhttp.AddNoPayloadDefaultContentTypeRemover(stack); err != nil {
991 return err
992 }
993 // convert request to a GET request
994 err = query.AddAsGetRequestMiddleware(stack)
995 if err != nil {
996 return err
997 }
998 err = presignedurlcust.AddAsIsPresigningMiddleware(stack)
999 if err != nil {
1000 return err
1001 }
1002 return nil
1003 }
1004
1005 func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
1006 return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
1007 LogRequest: o.ClientLogMode.IsRequest(),
1008 LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
1009 LogResponse: o.ClientLogMode.IsResponse(),
1010 LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
1011 }, middleware.After)
1012 }
1013
1014 type disableHTTPSMiddleware struct {
1015 DisableHTTPS bool
1016 }
1017
1018 func (*disableHTTPSMiddleware) ID() string {
1019 return "disableHTTPS"
1020 }
1021
1022 func (m *disableHTTPSMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
1023 out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
1024 ) {
1025 req, ok := in.Request.(*smithyhttp.Request)
1026 if !ok {
1027 return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
1028 }
1029
1030 if m.DisableHTTPS && !smithyhttp.GetHostnameImmutable(ctx) {
1031 req.URL.Scheme = "http"
1032 }
1033
1034 return next.HandleFinalize(ctx, in)
1035 }
1036
1037 func addDisableHTTPSMiddleware(stack *middleware.Stack, o Options) error {
1038 return stack.Finalize.Insert(&disableHTTPSMiddleware{
1039 DisableHTTPS: o.EndpointOptions.DisableHTTPS,
1040 }, "ResolveEndpointV2", middleware.After)
1041 }
1042
1043 func addInterceptBeforeRetryLoop(stack *middleware.Stack, opts Options) error {
1044 return stack.Finalize.Insert(&smithyhttp.InterceptBeforeRetryLoop{
1045 Interceptors: opts.Interceptors.BeforeRetryLoop,
1046 }, "Retry", middleware.Before)
1047 }
1048
1049 func addInterceptAttempt(stack *middleware.Stack, opts Options) error {
1050 return stack.Finalize.Insert(&smithyhttp.InterceptAttempt{
1051 BeforeAttempt: opts.Interceptors.BeforeAttempt,
1052 AfterAttempt: opts.Interceptors.AfterAttempt,
1053 }, "Retry", middleware.After)
1054 }
1055
1056 func addInterceptors(stack *middleware.Stack, opts Options) error {
1057 // middlewares are expensive, don't add all of these interceptor ones unless the caller
1058 // actually has at least one interceptor configured
1059 //
1060 // at the moment it's all-or-nothing because some of the middlewares here are responsible for
1061 // setting fields in the interceptor context for future ones
1062 if len(opts.Interceptors.BeforeExecution) == 0 &&
1063 len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 &&
1064 len(opts.Interceptors.BeforeRetryLoop) == 0 &&
1065 len(opts.Interceptors.BeforeAttempt) == 0 &&
1066 len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 &&
1067 len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 &&
1068 len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 &&
1069 len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 {
1070 return nil
1071 }
1072
1073 return errors.Join(
1074 stack.Initialize.Add(&smithyhttp.InterceptExecution{
1075 BeforeExecution: opts.Interceptors.BeforeExecution,
1076 AfterExecution: opts.Interceptors.AfterExecution,
1077 }, middleware.Before),
1078 stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
1079 Interceptors: opts.Interceptors.BeforeSerialization,
1080 }, "OperationSerializer", middleware.Before),
1081 stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
1082 Interceptors: opts.Interceptors.AfterSerialization,
1083 }, "OperationSerializer", middleware.After),
1084 stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
1085 Interceptors: opts.Interceptors.BeforeSigning,
1086 }, "Signing", middleware.Before),
1087 stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
1088 Interceptors: opts.Interceptors.AfterSigning,
1089 }, "Signing", middleware.After),
1090 stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
1091 BeforeTransmit: opts.Interceptors.BeforeTransmit,
1092 AfterTransmit: opts.Interceptors.AfterTransmit,
1093 }, middleware.After),
1094 stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
1095 Interceptors: opts.Interceptors.BeforeDeserialization,
1096 }, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse)
1097 stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
1098 Interceptors: opts.Interceptors.AfterDeserialization,
1099 }, "OperationDeserializer", middleware.Before),
1100 )
1101 }
1102