api_client.go - src - Go monorepo.

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