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