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