dilim/moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2026-08-09 01:21:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

vendor: github.com/aws/aws-sdk-go-v2/credentials v1.18.24

Browse Source 
full diff: https://github.com/aws/aws-sdk-go-v2/compare/credentials/v1.18.19...credentials/v1.18.24

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn
2026-01-15 12:41:49 +01:00
parent 2a87c9af9d
commit 3ebfc369cb
50 changed files with 1058 additions and 1064 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
vendor/github.com/aws/aws-sdk-go-v2/credentials/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,24 @@
# v1.18.24 (2025-11-12)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.18.23 (2025-11-11)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.18.22 (2025-11-10)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.18.21 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.18.20 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.18.19 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

2
vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package credentials
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.18.19"
const goModuleVersion = "1.18.24"

9
vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,12 @@
# v1.18.13 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.18.12 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.18.11 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

2
vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package imds
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.18.11"
const goModuleVersion = "1.18.13"

9
vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,12 @@
# v1.4.13 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.4.12 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.4.11 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

2
vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package configsources
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.4.11"
const goModuleVersion = "1.4.13"

9
vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,12 @@
# v2.7.13 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v2.7.12 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v2.7.11 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

2
vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package endpoints
// goModuleVersion is the tagged release for this module
const goModuleVersion = "2.7.11"
const goModuleVersion = "2.7.13"

4
vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,7 @@
# v1.13.3 (2025-11-04)
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.13.2 (2025-10-16)
* **Dependency Update**: Bump minimum Go version to 1.23.

2
vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package acceptencoding
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.13.2"
const goModuleVersion = "1.13.3"

9
vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,12 @@
# v1.13.13 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.13.12 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.13.11 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

2
vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package presignedurl
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.13.11"
const goModuleVersion = "1.13.13"

20
vendor/github.com/aws/aws-sdk-go-v2/service/sso/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,23 @@
# v1.30.3 (2025-11-12)
* **Bug Fix**: Further reduce allocation overhead when the metrics system isn't in-use.
* **Bug Fix**: Reduce allocation overhead when the client doesn't have any HTTP interceptors configured.
* **Bug Fix**: Remove blank trace spans towards the beginning of the request that added no additional information. This conveys a slight reduction in overall allocations.
# v1.30.2 (2025-11-11)
* **Bug Fix**: Return validation error if input region is not a valid host label.
# v1.30.1 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.30.0 (2025-10-30)
* **Feature**: Update endpoint ruleset parameters casing
* **Dependency Update**: Updated to the latest SDK module versions
# v1.29.8 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

204
vendor/github.com/aws/aws-sdk-go-v2/service/sso/api_client.go generated vendored
View File

@@ -65,7 +65,12 @@ func timeOperationMetric[T any](
ctx context.Context, metric string, fn func() (T, error),
opts ...metrics.RecordMetricOption,
) (T, error) {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return fn()
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
start := time.Now()
@@ -78,7 +83,12 @@ func timeOperationMetric[T any](
}
func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return func() {}
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
var ended bool
@@ -106,6 +116,12 @@ func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption {
type operationMetricsKey struct{}
func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) {
if _, ok := mp.(metrics.NopMeterProvider); ok {
// not using the metrics system - setting up the metrics context is a memory-intensive operation
// so we should skip it in this case
return parent, nil
}
meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/sso")
om := &operationMetrics{}
@@ -153,7 +169,10 @@ func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Hi
}
func getOperationMetrics(ctx context.Context) *operationMetrics {
return ctx.Value(operationMetricsKey{}).(*operationMetrics)
if v := ctx.Value(operationMetricsKey{}); v != nil {
return v.(*operationMetrics)
}
return nil
}
func operationTracer(p tracing.TracerProvider) tracing.Tracer {
@@ -882,138 +901,49 @@ func addInterceptAttempt(stack *middleware.Stack, opts Options) error {
}, "Retry", middleware.After)
}
func addInterceptExecution(stack *middleware.Stack, opts Options) error {
return stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before)
}
func addInterceptBeforeSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before)
}
func addInterceptAfterSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After)
}
func addInterceptBeforeSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before)
}
func addInterceptAfterSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After)
}
func addInterceptTransmit(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After)
}
func addInterceptBeforeDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After) // (deserialize stack is called in reverse)
}
func addInterceptAfterDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before)
}
type spanInitializeStart struct {
}
func (*spanInitializeStart) ID() string {
return "spanInitializeStart"
}
func (m *spanInitializeStart) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "Initialize")
return next.HandleInitialize(ctx, in)
}
type spanInitializeEnd struct {
}
func (*spanInitializeEnd) ID() string {
return "spanInitializeEnd"
}
func (m *spanInitializeEnd) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleInitialize(ctx, in)
}
type spanBuildRequestStart struct {
}
func (*spanBuildRequestStart) ID() string {
return "spanBuildRequestStart"
}
func (m *spanBuildRequestStart) HandleSerialize(
ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
middleware.SerializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "BuildRequest")
return next.HandleSerialize(ctx, in)
}
type spanBuildRequestEnd struct {
}
func (*spanBuildRequestEnd) ID() string {
return "spanBuildRequestEnd"
}
func (m *spanBuildRequestEnd) HandleBuild(
ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
middleware.BuildOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleBuild(ctx, in)
}
func addSpanInitializeStart(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeStart{}, middleware.Before)
}
func addSpanInitializeEnd(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeEnd{}, middleware.After)
}
func addSpanBuildRequestStart(stack *middleware.Stack) error {
return stack.Serialize.Add(&spanBuildRequestStart{}, middleware.Before)
}
func addSpanBuildRequestEnd(stack *middleware.Stack) error {
return stack.Build.Add(&spanBuildRequestEnd{}, middleware.After)
func addInterceptors(stack *middleware.Stack, opts Options) error {
// middlewares are expensive, don't add all of these interceptor ones unless the caller
// actually has at least one interceptor configured
//
// at the moment it's all-or-nothing because some of the middlewares here are responsible for
// setting fields in the interceptor context for future ones
if len(opts.Interceptors.BeforeExecution) == 0 &&
len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 &&
len(opts.Interceptors.BeforeRetryLoop) == 0 &&
len(opts.Interceptors.BeforeAttempt) == 0 &&
len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 &&
len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 &&
len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 &&
len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 {
return nil
}
return errors.Join(
stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After),
stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before),
stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After),
stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After),
stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse)
stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before),
)
}

35
vendor/github.com/aws/aws-sdk-go-v2/service/sso/api_op_GetRoleCredentials.go generated vendored
View File

@@ -153,40 +153,7 @@ func (c *Client) addOperationGetRoleCredentialsMiddlewares(stack *middleware.Sta
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sso/api_op_ListAccountRoles.go generated vendored
View File

@@ -158,40 +158,7 @@ func (c *Client) addOperationListAccountRolesMiddlewares(stack *middleware.Stack
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sso/api_op_ListAccounts.go generated vendored
View File

@@ -157,40 +157,7 @@ func (c *Client) addOperationListAccountsMiddlewares(stack *middleware.Stack, op
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sso/api_op_Logout.go generated vendored
View File

@@ -152,40 +152,7 @@ func (c *Client) addOperationLogoutMiddlewares(stack *middleware.Stack, options
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

26
vendor/github.com/aws/aws-sdk-go-v2/service/sso/endpoints.go generated vendored
View File

@@ -217,11 +217,15 @@ func resolveBaseEndpoint(cfg aws.Config, o *Options) {
}
}
func bindRegion(region string) *string {
func bindRegion(region string) (*string, error) {
if region == "" {
return nil
return nil, nil
}
return aws.String(endpoints.MapFIPSRegion(region))
if !smithyhttp.ValidHostLabel(region) {
return nil, fmt.Errorf("invalid input region %s", region)
}
return aws.String(endpoints.MapFIPSRegion(region)), nil
}
// EndpointParameters provides the parameters that influence how endpoints are
@@ -479,10 +483,15 @@ type endpointParamsBinder interface {
bindEndpointParams(*EndpointParameters)
}
func bindEndpointParams(ctx context.Context, input interface{}, options Options) *EndpointParameters {
func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) {
params := &EndpointParameters{}
params.Region = bindRegion(options.Region)
region, err := bindRegion(options.Region)
if err != nil {
return nil, err
}
params.Region = region
params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled)
params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled)
params.Endpoint = options.BaseEndpoint
@@ -491,7 +500,7 @@ func bindEndpointParams(ctx context.Context, input interface{}, options Options)
b.bindEndpointParams(params)
}
return params
return params, nil
}
type resolveEndpointV2Middleware struct {
@@ -521,7 +530,10 @@ func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in mid
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
params := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
if err != nil {
return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err)
}
endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration",
func() (smithyendpoints.Endpoint, error) {
return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params)

2
vendor/github.com/aws/aws-sdk-go-v2/service/sso/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package sso
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.29.8"
const goModuleVersion = "1.30.3"

19
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,22 @@
# v1.35.7 (2025-11-12)
* **Bug Fix**: Further reduce allocation overhead when the metrics system isn't in-use.
* **Bug Fix**: Reduce allocation overhead when the client doesn't have any HTTP interceptors configured.
* **Bug Fix**: Remove blank trace spans towards the beginning of the request that added no additional information. This conveys a slight reduction in overall allocations.
# v1.35.6 (2025-11-11)
* **Bug Fix**: Return validation error if input region is not a valid host label.
# v1.35.5 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.35.4 (2025-10-30)
* **Dependency Update**: Updated to the latest SDK module versions
# v1.35.3 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

204
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/api_client.go generated vendored
View File

@@ -65,7 +65,12 @@ func timeOperationMetric[T any](
ctx context.Context, metric string, fn func() (T, error),
opts ...metrics.RecordMetricOption,
) (T, error) {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return fn()
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
start := time.Now()
@@ -78,7 +83,12 @@ func timeOperationMetric[T any](
}
func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return func() {}
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
var ended bool
@@ -106,6 +116,12 @@ func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption {
type operationMetricsKey struct{}
func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) {
if _, ok := mp.(metrics.NopMeterProvider); ok {
// not using the metrics system - setting up the metrics context is a memory-intensive operation
// so we should skip it in this case
return parent, nil
}
meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/ssooidc")
om := &operationMetrics{}
@@ -153,7 +169,10 @@ func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Hi
}
func getOperationMetrics(ctx context.Context) *operationMetrics {
return ctx.Value(operationMetricsKey{}).(*operationMetrics)
if v := ctx.Value(operationMetricsKey{}); v != nil {
return v.(*operationMetrics)
}
return nil
}
func operationTracer(p tracing.TracerProvider) tracing.Tracer {
@@ -882,138 +901,49 @@ func addInterceptAttempt(stack *middleware.Stack, opts Options) error {
}, "Retry", middleware.After)
}
func addInterceptExecution(stack *middleware.Stack, opts Options) error {
return stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before)
}
func addInterceptBeforeSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before)
}
func addInterceptAfterSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After)
}
func addInterceptBeforeSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before)
}
func addInterceptAfterSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After)
}
func addInterceptTransmit(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After)
}
func addInterceptBeforeDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After) // (deserialize stack is called in reverse)
}
func addInterceptAfterDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before)
}
type spanInitializeStart struct {
}
func (*spanInitializeStart) ID() string {
return "spanInitializeStart"
}
func (m *spanInitializeStart) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "Initialize")
return next.HandleInitialize(ctx, in)
}
type spanInitializeEnd struct {
}
func (*spanInitializeEnd) ID() string {
return "spanInitializeEnd"
}
func (m *spanInitializeEnd) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleInitialize(ctx, in)
}
type spanBuildRequestStart struct {
}
func (*spanBuildRequestStart) ID() string {
return "spanBuildRequestStart"
}
func (m *spanBuildRequestStart) HandleSerialize(
ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
middleware.SerializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "BuildRequest")
return next.HandleSerialize(ctx, in)
}
type spanBuildRequestEnd struct {
}
func (*spanBuildRequestEnd) ID() string {
return "spanBuildRequestEnd"
}
func (m *spanBuildRequestEnd) HandleBuild(
ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
middleware.BuildOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleBuild(ctx, in)
}
func addSpanInitializeStart(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeStart{}, middleware.Before)
}
func addSpanInitializeEnd(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeEnd{}, middleware.After)
}
func addSpanBuildRequestStart(stack *middleware.Stack) error {
return stack.Serialize.Add(&spanBuildRequestStart{}, middleware.Before)
}
func addSpanBuildRequestEnd(stack *middleware.Stack) error {
return stack.Build.Add(&spanBuildRequestEnd{}, middleware.After)
func addInterceptors(stack *middleware.Stack, opts Options) error {
// middlewares are expensive, don't add all of these interceptor ones unless the caller
// actually has at least one interceptor configured
//
// at the moment it's all-or-nothing because some of the middlewares here are responsible for
// setting fields in the interceptor context for future ones
if len(opts.Interceptors.BeforeExecution) == 0 &&
len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 &&
len(opts.Interceptors.BeforeRetryLoop) == 0 &&
len(opts.Interceptors.BeforeAttempt) == 0 &&
len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 &&
len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 &&
len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 &&
len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 {
return nil
}
return errors.Join(
stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After),
stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before),
stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After),
stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After),
stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse)
stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before),
)
}

35
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/api_op_CreateToken.go generated vendored
View File

@@ -223,40 +223,7 @@ func (c *Client) addOperationCreateTokenMiddlewares(stack *middleware.Stack, opt
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/api_op_CreateTokenWithIAM.go generated vendored
View File

@@ -270,40 +270,7 @@ func (c *Client) addOperationCreateTokenWithIAMMiddlewares(stack *middleware.Sta
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/api_op_RegisterClient.go generated vendored
View File

@@ -194,40 +194,7 @@ func (c *Client) addOperationRegisterClientMiddlewares(stack *middleware.Stack,
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/api_op_StartDeviceAuthorization.go generated vendored
View File

@@ -176,40 +176,7 @@ func (c *Client) addOperationStartDeviceAuthorizationMiddlewares(stack *middlewa
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

26
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/endpoints.go generated vendored
View File

@@ -217,11 +217,15 @@ func resolveBaseEndpoint(cfg aws.Config, o *Options) {
}
}
func bindRegion(region string) *string {
func bindRegion(region string) (*string, error) {
if region == "" {
return nil
return nil, nil
}
return aws.String(endpoints.MapFIPSRegion(region))
if !smithyhttp.ValidHostLabel(region) {
return nil, fmt.Errorf("invalid input region %s", region)
}
return aws.String(endpoints.MapFIPSRegion(region)), nil
}
// EndpointParameters provides the parameters that influence how endpoints are
@@ -479,10 +483,15 @@ type endpointParamsBinder interface {
bindEndpointParams(*EndpointParameters)
}
func bindEndpointParams(ctx context.Context, input interface{}, options Options) *EndpointParameters {
func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) {
params := &EndpointParameters{}
params.Region = bindRegion(options.Region)
region, err := bindRegion(options.Region)
if err != nil {
return nil, err
}
params.Region = region
params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled)
params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled)
params.Endpoint = options.BaseEndpoint
@@ -491,7 +500,7 @@ func bindEndpointParams(ctx context.Context, input interface{}, options Options)
b.bindEndpointParams(params)
}
return params
return params, nil
}
type resolveEndpointV2Middleware struct {
@@ -521,7 +530,10 @@ func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in mid
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
params := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
if err != nil {
return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err)
}
endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration",
func() (smithyendpoints.Endpoint, error) {
return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params)

2
vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package ssooidc
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.35.3"
const goModuleVersion = "1.35.7"

24
vendor/github.com/aws/aws-sdk-go-v2/service/sts/CHANGELOG.md generated vendored
View File

@@ -1,3 +1,27 @@
# v1.40.2 (2025-11-12)
* **Bug Fix**: Further reduce allocation overhead when the metrics system isn't in-use.
* **Bug Fix**: Reduce allocation overhead when the client doesn't have any HTTP interceptors configured.
* **Bug Fix**: Remove blank trace spans towards the beginning of the request that added no additional information. This conveys a slight reduction in overall allocations.
# v1.40.1 (2025-11-11)
* **Bug Fix**: Return validation error if input region is not a valid host label.
# v1.40.0 (2025-11-10)
* **Feature**: Added GetDelegatedAccessToken API, which is not available for general use at this time.
# v1.39.1 (2025-11-04)
* **Dependency Update**: Updated to the latest SDK module versions
* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system.
# v1.39.0 (2025-10-30)
* **Feature**: Update endpoint ruleset parameters casing
* **Dependency Update**: Updated to the latest SDK module versions
# v1.38.9 (2025-10-23)
* **Dependency Update**: Updated to the latest SDK module versions

204
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_client.go generated vendored
View File

@@ -68,7 +68,12 @@ func timeOperationMetric[T any](
ctx context.Context, metric string, fn func() (T, error),
opts ...metrics.RecordMetricOption,
) (T, error) {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return fn()
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
start := time.Now()
@@ -81,7 +86,12 @@ func timeOperationMetric[T any](
}
func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() {
instr := getOperationMetrics(ctx).histogramFor(metric)
mm := getOperationMetrics(ctx)
if mm == nil { // not using the metrics system
return func() {}
}
instr := mm.histogramFor(metric)
opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
var ended bool
@@ -109,6 +119,12 @@ func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption {
type operationMetricsKey struct{}
func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) {
if _, ok := mp.(metrics.NopMeterProvider); ok {
// not using the metrics system - setting up the metrics context is a memory-intensive operation
// so we should skip it in this case
return parent, nil
}
meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
om := &operationMetrics{}
@@ -156,7 +172,10 @@ func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Hi
}
func getOperationMetrics(ctx context.Context) *operationMetrics {
return ctx.Value(operationMetricsKey{}).(*operationMetrics)
if v := ctx.Value(operationMetricsKey{}); v != nil {
return v.(*operationMetrics)
}
return nil
}
func operationTracer(p tracing.TracerProvider) tracing.Tracer {
@@ -1034,138 +1053,49 @@ func addInterceptAttempt(stack *middleware.Stack, opts Options) error {
}, "Retry", middleware.After)
}
func addInterceptExecution(stack *middleware.Stack, opts Options) error {
return stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before)
}
func addInterceptBeforeSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before)
}
func addInterceptAfterSerialization(stack *middleware.Stack, opts Options) error {
return stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After)
}
func addInterceptBeforeSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before)
}
func addInterceptAfterSigning(stack *middleware.Stack, opts Options) error {
return stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After)
}
func addInterceptTransmit(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After)
}
func addInterceptBeforeDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After) // (deserialize stack is called in reverse)
}
func addInterceptAfterDeserialization(stack *middleware.Stack, opts Options) error {
return stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before)
}
type spanInitializeStart struct {
}
func (*spanInitializeStart) ID() string {
return "spanInitializeStart"
}
func (m *spanInitializeStart) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "Initialize")
return next.HandleInitialize(ctx, in)
}
type spanInitializeEnd struct {
}
func (*spanInitializeEnd) ID() string {
return "spanInitializeEnd"
}
func (m *spanInitializeEnd) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
middleware.InitializeOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleInitialize(ctx, in)
}
type spanBuildRequestStart struct {
}
func (*spanBuildRequestStart) ID() string {
return "spanBuildRequestStart"
}
func (m *spanBuildRequestStart) HandleSerialize(
ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
middleware.SerializeOutput, middleware.Metadata, error,
) {
ctx, _ = tracing.StartSpan(ctx, "BuildRequest")
return next.HandleSerialize(ctx, in)
}
type spanBuildRequestEnd struct {
}
func (*spanBuildRequestEnd) ID() string {
return "spanBuildRequestEnd"
}
func (m *spanBuildRequestEnd) HandleBuild(
ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
middleware.BuildOutput, middleware.Metadata, error,
) {
ctx, span := tracing.PopSpan(ctx)
span.End()
return next.HandleBuild(ctx, in)
}
func addSpanInitializeStart(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeStart{}, middleware.Before)
}
func addSpanInitializeEnd(stack *middleware.Stack) error {
return stack.Initialize.Add(&spanInitializeEnd{}, middleware.After)
}
func addSpanBuildRequestStart(stack *middleware.Stack) error {
return stack.Serialize.Add(&spanBuildRequestStart{}, middleware.Before)
}
func addSpanBuildRequestEnd(stack *middleware.Stack) error {
return stack.Build.Add(&spanBuildRequestEnd{}, middleware.After)
func addInterceptors(stack *middleware.Stack, opts Options) error {
// middlewares are expensive, don't add all of these interceptor ones unless the caller
// actually has at least one interceptor configured
//
// at the moment it's all-or-nothing because some of the middlewares here are responsible for
// setting fields in the interceptor context for future ones
if len(opts.Interceptors.BeforeExecution) == 0 &&
len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 &&
len(opts.Interceptors.BeforeRetryLoop) == 0 &&
len(opts.Interceptors.BeforeAttempt) == 0 &&
len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 &&
len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 &&
len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 &&
len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 {
return nil
}
return errors.Join(
stack.Initialize.Add(&smithyhttp.InterceptExecution{
BeforeExecution: opts.Interceptors.BeforeExecution,
AfterExecution: opts.Interceptors.AfterExecution,
}, middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
Interceptors: opts.Interceptors.BeforeSerialization,
}, "OperationSerializer", middleware.Before),
stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
Interceptors: opts.Interceptors.AfterSerialization,
}, "OperationSerializer", middleware.After),
stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
Interceptors: opts.Interceptors.BeforeSigning,
}, "Signing", middleware.Before),
stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
Interceptors: opts.Interceptors.AfterSigning,
}, "Signing", middleware.After),
stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
BeforeTransmit: opts.Interceptors.BeforeTransmit,
AfterTransmit: opts.Interceptors.AfterTransmit,
}, middleware.After),
stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
Interceptors: opts.Interceptors.BeforeDeserialization,
}, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse)
stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
Interceptors: opts.Interceptors.AfterDeserialization,
}, "OperationDeserializer", middleware.Before),
)
}

41
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_AssumeRole.go generated vendored
View File

@@ -147,7 +147,7 @@ type AssumeRoleInput struct {
//
// The regex used to validate this parameter is a string of characters consisting
// of upper- and lower-case alphanumeric characters with no spaces. You can also
// include underscores or any of the following characters: =,.@-
// include underscores or any of the following characters: +=,.@-
//
// [CloudTrail logs]: https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html#cloudtrail-integration_signin-tempcreds
// [sts:RoleSessionName]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#ck_rolesessionname
@@ -196,7 +196,7 @@ type AssumeRoleInput struct {
//
// The regex used to validate this parameter is a string of characters consisting
// of upper- and lower-case alphanumeric characters with no spaces. You can also
// include underscores or any of the following characters: =,.@:/-
// include underscores or any of the following characters: +=,.@:\/-
//
// [How to Use an External ID When Granting Access to Your Amazon Web Services Resources to a Third Party]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html
ExternalId *string
@@ -279,7 +279,7 @@ type AssumeRoleInput struct {
//
// The regex used to validate this parameter is a string of characters consisting
// of upper- and lower-case alphanumeric characters with no spaces. You can also
// include underscores or any of the following characters: =,.@-
// include underscores or any of the following characters: +=/:,.@-
SerialNumber *string
// The source identity specified by the principal that is calling the AssumeRole
@@ -508,40 +508,7 @@ func (c *Client) addOperationAssumeRoleMiddlewares(stack *middleware.Stack, opti
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

38
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_AssumeRoleWithSAML.go generated vendored
View File

@@ -23,6 +23,9 @@ import (
// these temporary security credentials to sign calls to Amazon Web Services
// services.
//
// AssumeRoleWithSAML will not work on IAM Identity Center managed roles. These
// roles' names start with AWSReservedSSO_ .
//
// # Session Duration
//
// By default, the temporary security credentials created by AssumeRoleWithSAML
@@ -440,40 +443,7 @@ func (c *Client) addOperationAssumeRoleWithSAMLMiddlewares(stack *middleware.Sta
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

39
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_AssumeRoleWithWebIdentity.go generated vendored
View File

@@ -75,7 +75,7 @@ import (
//
// (Optional) You can configure your IdP to pass attributes into your web identity
// token as session tags. Each session tag consists of a key name and an associated
// value. For more information about session tags, see [Passing Session Tags in STS]in the IAM User Guide.
// value. For more information about session tags, see [Passing session tags using AssumeRoleWithWebIdentity]in the IAM User Guide.
//
// You can pass up to 50 session tags. The plaintext session tag keys can’t exceed
// 128 characters and the values can’t exceed 256 characters. For these and
@@ -123,6 +123,7 @@ import (
// providers to get and use temporary security credentials.
//
// [Amazon Web Services SDK for iOS Developer Guide]: http://aws.amazon.com/sdkforios/
// [Passing session tags using AssumeRoleWithWebIdentity]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_adding-assume-role-idp
// [Amazon Web Services SDK for Android Developer Guide]: http://aws.amazon.com/sdkforandroid/
// [IAM and STS Character Limits]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html#reference_iam-limits-entity-length
// [session policies]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session
@@ -135,7 +136,6 @@ import (
// [Using IAM Roles]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html
// [Session Policies]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session
// [Amazon Cognito federated identities]: https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html
// [Passing Session Tags in STS]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html
// [Chaining Roles with Session Tags]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_role-chaining
// [Update the maximum session duration for a role]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-settings.html#id_roles_update-session-duration
// [Using Web Identity Federation API Operations for Mobile Apps]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual.html
@@ -460,40 +460,7 @@ func (c *Client) addOperationAssumeRoleWithWebIdentityMiddlewares(stack *middlew
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

53
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_AssumeRoot.go generated vendored
View File

@@ -12,7 +12,9 @@ import (
)
// Returns a set of short term credentials you can use to perform privileged tasks
// on a member account in your organization.
// on a member account in your organization. You must use credentials from an
// Organizations management account or a delegated administrator account for IAM to
// call AssumeRoot . You cannot use root user credentials to make this call.
//
// Before you can launch a privileged session, you must have centralized root
// access in your organization. For steps to enable this feature, see [Centralize root access for member accounts]in the IAM
@@ -24,8 +26,16 @@ import (
// You can track AssumeRoot in CloudTrail logs to determine what actions were
// performed in a session. For more information, see [Track privileged tasks in CloudTrail]in the IAM User Guide.
//
// When granting access to privileged tasks you should only grant the necessary
// permissions required to perform that task. For more information, see [Security best practices in IAM]. In
// addition, you can use [service control policies](SCPs) to manage and limit permissions in your
// organization. See [General examples]in the Organizations User Guide for more information on SCPs.
//
// [Endpoints]: https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html#sts-endpoints
// [Security best practices in IAM]: https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html
// [Track privileged tasks in CloudTrail]: https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-track-privileged-tasks.html
// [General examples]: https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples_general.html
// [service control policies]: https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html
// [Centralize root access for member accounts]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-enable-root-access.html
func (c *Client) AssumeRoot(ctx context.Context, params *AssumeRootInput, optFns ...func(*Options)) (*AssumeRootOutput, error) {
if params == nil {
@@ -50,8 +60,10 @@ type AssumeRootInput struct {
TargetPrincipal *string
// The identity based policy that scopes the session to the privileged tasks that
// can be performed. You can use one of following Amazon Web Services managed
// policies to scope root session actions.
// can be performed. You must
//
// use one of following Amazon Web Services managed policies to scope root session
// actions:
//
// [IAMAuditRootUserCredentials]
//
@@ -205,40 +217,7 @@ func (c *Client) addOperationAssumeRootMiddlewares(stack *middleware.Stack, opti
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_DecodeAuthorizationMessage.go generated vendored
View File

@@ -177,40 +177,7 @@ func (c *Client) addOperationDecodeAuthorizationMessageMiddlewares(stack *middle
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_GetAccessKeyInfo.go generated vendored
View File

@@ -168,40 +168,7 @@ func (c *Client) addOperationGetAccessKeyInfoMiddlewares(stack *middleware.Stack
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_GetCallerIdentity.go generated vendored
View File

@@ -156,40 +156,7 @@ func (c *Client) addOperationGetCallerIdentityMiddlewares(stack *middleware.Stac
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

163
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_GetDelegatedAccessToken.go generated vendored Normal file
View File

@@ -0,0 +1,163 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sts
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/sts/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This API is currently unavailable for general use.
func (c *Client) GetDelegatedAccessToken(ctx context.Context, params *GetDelegatedAccessTokenInput, optFns ...func(*Options)) (*GetDelegatedAccessTokenOutput, error) {
if params == nil {
params = &GetDelegatedAccessTokenInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDelegatedAccessToken", params, optFns, c.addOperationGetDelegatedAccessTokenMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDelegatedAccessTokenOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDelegatedAccessTokenInput struct {
//
//
// This member is required.
TradeInToken *string
noSmithyDocumentSerde
}
type GetDelegatedAccessTokenOutput struct {
//
AssumedPrincipal *string
// Amazon Web Services credentials for API authentication.
Credentials *types.Credentials
//
PackedPolicySize *int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDelegatedAccessTokenMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsquery_serializeOpGetDelegatedAccessToken{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsquery_deserializeOpGetDelegatedAccessToken{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "GetDelegatedAccessToken"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addSpanRetryLoop(stack, options); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addTimeOffsetBuild(stack, c); err != nil {
return err
}
if err = addUserAgentRetryMode(stack, options); err != nil {
return err
}
if err = addCredentialSource(stack, options); err != nil {
return err
}
if err = addOpGetDelegatedAccessTokenValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDelegatedAccessToken(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
if err = addInterceptBeforeRetryLoop(stack, options); err != nil {
return err
}
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetDelegatedAccessToken(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "GetDelegatedAccessToken",
}
}

35
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_GetFederationToken.go generated vendored
View File

@@ -381,40 +381,7 @@ func (c *Client) addOperationGetFederationTokenMiddlewares(stack *middleware.Sta
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

35
vendor/github.com/aws/aws-sdk-go-v2/service/sts/api_op_GetSessionToken.go generated vendored
View File

@@ -227,40 +227,7 @@ func (c *Client) addOperationGetSessionTokenMiddlewares(stack *middleware.Stack,
if err = addInterceptAttempt(stack, options); err != nil {
return err
}
if err = addInterceptExecution(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSerialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterSerialization(stack, options); err != nil {
return err
}
if err = addInterceptBeforeSigning(stack, options); err != nil {
return err
}
if err = addInterceptAfterSigning(stack, options); err != nil {
return err
}
if err = addInterceptTransmit(stack, options); err != nil {
return err
}
if err = addInterceptBeforeDeserialization(stack, options); err != nil {
return err
}
if err = addInterceptAfterDeserialization(stack, options); err != nil {
return err
}
if err = addSpanInitializeStart(stack); err != nil {
return err
}
if err = addSpanInitializeEnd(stack); err != nil {
return err
}
if err = addSpanBuildRequestStart(stack); err != nil {
return err
}
if err = addSpanBuildRequestEnd(stack); err != nil {
if err = addInterceptors(stack, options); err != nil {
return err
}
return nil

280
vendor/github.com/aws/aws-sdk-go-v2/service/sts/deserializers.go generated vendored
View File

@@ -846,6 +846,121 @@ func awsAwsquery_deserializeOpErrorGetCallerIdentity(response *smithyhttp.Respon
}
}
type awsAwsquery_deserializeOpGetDelegatedAccessToken struct {
}
func (*awsAwsquery_deserializeOpGetDelegatedAccessToken) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsquery_deserializeOpGetDelegatedAccessToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
_, span := tracing.StartSpan(ctx, "OperationDeserializer")
endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
defer endTimer()
defer span.End()
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsquery_deserializeOpErrorGetDelegatedAccessToken(response, &metadata)
}
output := &GetDelegatedAccessTokenOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
rootDecoder := xml.NewDecoder(body)
t, err := smithyxml.FetchRootElement(rootDecoder)
if err == io.EOF {
return out, metadata, nil
}
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
t, err = decoder.GetElement("GetDelegatedAccessTokenResult")
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
err = awsAwsquery_deserializeOpDocumentGetDelegatedAccessTokenOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsquery_deserializeOpErrorGetDelegatedAccessToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
if err != nil {
return err
}
if reqID := errorComponents.RequestID; len(reqID) != 0 {
awsmiddleware.SetRequestIDMetadata(metadata, reqID)
}
if len(errorComponents.Code) != 0 {
errorCode = errorComponents.Code
}
if len(errorComponents.Message) != 0 {
errorMessage = errorComponents.Message
}
errorBody.Seek(0, io.SeekStart)
switch {
case strings.EqualFold("ExpiredTradeInTokenException", errorCode):
return awsAwsquery_deserializeErrorExpiredTradeInTokenException(response, errorBody)
case strings.EqualFold("RegionDisabledException", errorCode):
return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsquery_deserializeOpGetFederationToken struct {
}
@@ -1120,6 +1235,50 @@ func awsAwsquery_deserializeErrorExpiredTokenException(response *smithyhttp.Resp
return output
}
func awsAwsquery_deserializeErrorExpiredTradeInTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ExpiredTradeInTokenException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
rootDecoder := xml.NewDecoder(body)
t, err := smithyxml.FetchRootElement(rootDecoder)
if err == io.EOF {
return output
}
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
t, err = decoder.GetElement("Error")
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
}
decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
err = awsAwsquery_deserializeDocumentExpiredTradeInTokenException(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return output
}
func awsAwsquery_deserializeErrorIDPCommunicationErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.IDPCommunicationErrorException{}
var buff [1024]byte
@@ -1631,6 +1790,55 @@ func awsAwsquery_deserializeDocumentExpiredTokenException(v **types.ExpiredToken
return nil
}
func awsAwsquery_deserializeDocumentExpiredTradeInTokenException(v **types.ExpiredTradeInTokenException, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
var sv *types.ExpiredTradeInTokenException
if *v == nil {
sv = &types.ExpiredTradeInTokenException{}
} else {
sv = *v
}
for {
t, done, err := decoder.Token()
if err != nil {
return err
}
if done {
break
}
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
case strings.EqualFold("message", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
}
if val == nil {
break
}
{
xtv := string(val)
sv.Message = ptr.String(xtv)
}
default:
// Do nothing and ignore the unexpected tag element
err = decoder.Decoder.Skip()
if err != nil {
return err
}
}
decoder = originalDecoder
}
*v = sv
return nil
}
func awsAwsquery_deserializeDocumentFederatedUser(v **types.FederatedUser, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -2602,6 +2810,78 @@ func awsAwsquery_deserializeOpDocumentGetCallerIdentityOutput(v **GetCallerIdent
return nil
}
func awsAwsquery_deserializeOpDocumentGetDelegatedAccessTokenOutput(v **GetDelegatedAccessTokenOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
var sv *GetDelegatedAccessTokenOutput
if *v == nil {
sv = &GetDelegatedAccessTokenOutput{}
} else {
sv = *v
}
for {
t, done, err := decoder.Token()
if err != nil {
return err
}
if done {
break
}
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
case strings.EqualFold("AssumedPrincipal", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
}
if val == nil {
break
}
{
xtv := string(val)
sv.AssumedPrincipal = ptr.String(xtv)
}
case strings.EqualFold("Credentials", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
return err
}
case strings.EqualFold("PackedPolicySize", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
}
if val == nil {
break
}
{
xtv := string(val)
i64, err := strconv.ParseInt(xtv, 10, 64)
if err != nil {
return err
}
sv.PackedPolicySize = ptr.Int32(int32(i64))
}
default:
// Do nothing and ignore the unexpected tag element
err = decoder.Decoder.Skip()
if err != nil {
return err
}
}
decoder = originalDecoder
}
*v = sv
return nil
}
func awsAwsquery_deserializeOpDocumentGetFederationTokenOutput(v **GetFederationTokenOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)

26
vendor/github.com/aws/aws-sdk-go-v2/service/sts/endpoints.go generated vendored
View File

@@ -218,11 +218,15 @@ func resolveBaseEndpoint(cfg aws.Config, o *Options) {
}
}
func bindRegion(region string) *string {
func bindRegion(region string) (*string, error) {
if region == "" {
return nil
return nil, nil
}
return aws.String(endpoints.MapFIPSRegion(region))
if !smithyhttp.ValidHostLabel(region) {
return nil, fmt.Errorf("invalid input region %s", region)
}
return aws.String(endpoints.MapFIPSRegion(region)), nil
}
// EndpointParameters provides the parameters that influence how endpoints are
@@ -1060,10 +1064,15 @@ type endpointParamsBinder interface {
bindEndpointParams(*EndpointParameters)
}
func bindEndpointParams(ctx context.Context, input interface{}, options Options) *EndpointParameters {
func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) {
params := &EndpointParameters{}
params.Region = bindRegion(options.Region)
region, err := bindRegion(options.Region)
if err != nil {
return nil, err
}
params.Region = region
params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled)
params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled)
params.Endpoint = options.BaseEndpoint
@@ -1072,7 +1081,7 @@ func bindEndpointParams(ctx context.Context, input interface{}, options Options)
b.bindEndpointParams(params)
}
return params
return params, nil
}
type resolveEndpointV2Middleware struct {
@@ -1102,7 +1111,10 @@ func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in mid
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
params := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
if err != nil {
return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err)
}
endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration",
func() (smithyendpoints.Endpoint, error) {
return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params)

1
vendor/github.com/aws/aws-sdk-go-v2/service/sts/generated.json generated vendored
View File

@@ -17,6 +17,7 @@
"api_op_DecodeAuthorizationMessage.go",
"api_op_GetAccessKeyInfo.go",
"api_op_GetCallerIdentity.go",
"api_op_GetDelegatedAccessToken.go",
"api_op_GetFederationToken.go",
"api_op_GetSessionToken.go",
"auth.go",

2
vendor/github.com/aws/aws-sdk-go-v2/service/sts/go_module_metadata.go generated vendored
View File

@@ -3,4 +3,4 @@
package sts
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.38.9"
const goModuleVersion = "1.40.2"

82
vendor/github.com/aws/aws-sdk-go-v2/service/sts/serializers.go generated vendored
View File

@@ -502,6 +502,76 @@ func (m *awsAwsquery_serializeOpGetCallerIdentity) HandleSerialize(ctx context.C
return next.HandleSerialize(ctx, in)
}
type awsAwsquery_serializeOpGetDelegatedAccessToken struct {
}
func (*awsAwsquery_serializeOpGetDelegatedAccessToken) ID() string {
return "OperationSerializer"
}
func (m *awsAwsquery_serializeOpGetDelegatedAccessToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
defer endTimer()
defer span.End()
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetDelegatedAccessTokenInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
body.Key("Action").String("GetDelegatedAccessToken")
body.Key("Version").String("2011-06-15")
if err := awsAwsquery_serializeOpDocumentGetDelegatedAccessTokenInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
err = bodyEncoder.Encode()
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
endTimer()
span.End()
return next.HandleSerialize(ctx, in)
}
type awsAwsquery_serializeOpGetFederationToken struct {
}
@@ -946,6 +1016,18 @@ func awsAwsquery_serializeOpDocumentGetCallerIdentityInput(v *GetCallerIdentityI
return nil
}
func awsAwsquery_serializeOpDocumentGetDelegatedAccessTokenInput(v *GetDelegatedAccessTokenInput, value query.Value) error {
object := value.Object()
_ = object
if v.TradeInToken != nil {
objectKey := object.Key("TradeInToken")
objectKey.String(*v.TradeInToken)
}
return nil
}
func awsAwsquery_serializeOpDocumentGetFederationTokenInput(v *GetFederationTokenInput, value query.Value) error {
object := value.Object()
_ = object

27
vendor/github.com/aws/aws-sdk-go-v2/service/sts/types/errors.go generated vendored
View File

@@ -34,6 +34,31 @@ func (e *ExpiredTokenException) ErrorCode() string {
}
func (e *ExpiredTokenException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ExpiredTradeInTokenException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ExpiredTradeInTokenException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ExpiredTradeInTokenException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ExpiredTradeInTokenException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ExpiredTradeInTokenException"
}
return *e.ErrorCodeOverride
}
func (e *ExpiredTradeInTokenException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request could not be fulfilled because the identity provider (IDP) that was
// asked to verify the incoming identity token could not be reached. This is often
// a transient error caused by network conditions. Retry the request a limited
@@ -221,7 +246,7 @@ func (e *PackedPolicyTooLargeException) ErrorFault() smithy.ErrorFault { return
// console to activate STS in that region. For more information, see [Activating and Deactivating STS in an Amazon Web Services Region]in the IAM
// User Guide.
//
// [Activating and Deactivating STS in an Amazon Web Services Region]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html
// [Activating and Deactivating STS in an Amazon Web Services Region]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#sts-regions-activate-deactivate
type RegionDisabledException struct {
Message *string

39
vendor/github.com/aws/aws-sdk-go-v2/service/sts/validators.go generated vendored
View File

@@ -130,6 +130,26 @@ func (m *validateOpGetAccessKeyInfo) HandleInitialize(ctx context.Context, in mi
return next.HandleInitialize(ctx, in)
}
type validateOpGetDelegatedAccessToken struct {
}
func (*validateOpGetDelegatedAccessToken) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDelegatedAccessToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDelegatedAccessTokenInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDelegatedAccessTokenInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetFederationToken struct {
}
@@ -174,6 +194,10 @@ func addOpGetAccessKeyInfoValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAccessKeyInfo{}, middleware.After)
}
func addOpGetDelegatedAccessTokenValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDelegatedAccessToken{}, middleware.After)
}
func addOpGetFederationTokenValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetFederationToken{}, middleware.After)
}
@@ -326,6 +350,21 @@ func validateOpGetAccessKeyInfoInput(v *GetAccessKeyInfoInput) error {
}
}
func validateOpGetDelegatedAccessTokenInput(v *GetDelegatedAccessTokenInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDelegatedAccessTokenInput"}
if v.TradeInToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("TradeInToken"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetFederationTokenInput(v *GetFederationTokenInput) error {
if v == nil {
return nil