robocars/robocar-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(aws): upgrade aws dependencies

Browse Source
This commit is contained in:
Cyrille Nofficial
2021-11-24 19:10:52 +01:00
parent 165108d1c3
commit b13ff06b36
229 changed files with 13263 additions and 1613 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
vendor/github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations/doc.go generated vendored
View File

@ -20,7 +20,7 @@ false. This flag will be ignored if `UseAccelerate` option is set to true.
If UseAccelerate is not enabled, and the bucket name is not a valid hostname
label, they SDK will fallback to forcing the request to be made as if
UsePathStyle was enabled. This behavior is also used if UseDualStack is enabled.
UsePathStyle was enabled. This behavior is also used if UseDualStackEndpoint is enabled.
https://docs.aws.amazon.com/AmazonS3/latest/dev/dual-stack-endpoints.html#dual-stack-endpoints-description

80
vendor/github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations/process_arn_resource.go generated vendored
View File

@ -32,9 +32,6 @@ type processARNResource struct {
// UseAccelerate indicates if s3 transfer acceleration is enabled
UseAccelerate bool
// UseDualstack instructs if s3 dualstack endpoint config is enabled
UseDualstack bool
// EndpointResolver used to resolve endpoints. This may be a custom endpoint resolver
EndpointResolver EndpointResolver
@ -74,6 +71,7 @@ func (m *processARNResource) HandleSerialize(
resourceRequest := s3shared.ResourceRequest{
Resource: resource,
UseARNRegion: m.UseARNRegion,
UseFIPS: m.EndpointResolverOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled,
RequestRegion: awsmiddleware.GetRegion(ctx),
SigningRegion: awsmiddleware.GetSigningRegion(ctx),
PartitionID: awsmiddleware.GetPartitionID(ctx),
@ -98,7 +96,7 @@ func (m *processARNResource) HandleSerialize(
}
// Do not allow dual-stack configuration with multi-region arns.
if m.UseDualstack {
if m.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
return out, metadata, s3shared.NewClientConfiguredForDualStackError(tv,
resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
}
@ -113,28 +111,10 @@ func (m *processARNResource) HandleSerialize(
// fetch arn region to resolve request
resolveRegion := tv.Region
// check if request region is FIPS
if resourceRequest.UseFips() {
if resourceRequest.UseFIPS && len(resolveRegion) == 0 {
// Do not allow Fips support within multi-region arns.
if len(resolveRegion) == 0 {
return out, metadata, s3shared.NewClientConfiguredForFIPSError(
tv, resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
}
// if use arn region is enabled and request signing region is not same as arn region
if m.UseARNRegion && resourceRequest.IsCrossRegion() {
// FIPS with cross region is not supported, the SDK must fail
// because there is no well defined method for SDK to construct a
// correct FIPS endpoint.
return out, metadata,
s3shared.NewClientConfiguredForCrossRegionFIPSError(
tv,
resourceRequest.PartitionID,
resourceRequest.RequestRegion,
nil,
)
}
// if use arn region is NOT set, we should use the request region
resolveRegion = resourceRequest.RequestRegion
return out, metadata, s3shared.NewClientConfiguredForFIPSError(
tv, resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
}
var requestBuilder func(context.Context, accesspointOptions) (context.Context, error)
@ -170,7 +150,7 @@ func (m *processARNResource) HandleSerialize(
}
// check if dualstack
if m.UseDualstack {
if m.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
return out, metadata, s3shared.NewClientConfiguredForDualStackError(tv,
resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
}
@ -178,25 +158,6 @@ func (m *processARNResource) HandleSerialize(
// fetch arn region to resolve request
resolveRegion := tv.Region
if resourceRequest.UseFips() {
// if use arn region is enabled and request signing region is not same as arn region
if m.UseARNRegion && resourceRequest.IsCrossRegion() {
// FIPS with cross region is not supported, the SDK must fail
// because there is no well defined method for SDK to construct a
// correct FIPS endpoint.
return out, metadata,
s3shared.NewClientConfiguredForCrossRegionFIPSError(
tv,
resourceRequest.PartitionID,
resourceRequest.RequestRegion,
nil,
)
}
// if use arn region is NOT set, we should use the request region
resolveRegion = resourceRequest.RequestRegion
}
// build access point request
ctx, err = buildS3ObjectLambdaAccessPointRequest(ctx, accesspointOptions{
processARNResource: *m,
@ -224,13 +185,13 @@ func (m *processARNResource) HandleSerialize(
}
// check if dual stack
if m.UseDualstack {
if m.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
return out, metadata, s3shared.NewClientConfiguredForDualStackError(tv,
resourceRequest.PartitionID, resourceRequest.RequestRegion, nil)
}
// check if request region is FIPS
if resourceRequest.UseFips() {
if resourceRequest.UseFIPS {
return out, metadata, s3shared.NewFIPSConfigurationError(tv, resourceRequest.PartitionID,
resourceRequest.RequestRegion, nil)
}
@ -295,8 +256,12 @@ func buildAccessPointRequest(ctx context.Context, options accesspointOptions) (c
resolveService := tv.Service
ero := options.EndpointResolverOptions
ero.Logger = middleware.GetLogger(ctx)
ero.ResolvedRegion = "" // clear endpoint option's resolved region so that we resolve using the passed in region
// resolve endpoint
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, options.EndpointResolverOptions)
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, ero)
if err != nil {
return ctx, s3shared.NewFailedToResolveEndpointError(
tv,
@ -356,8 +321,12 @@ func buildS3ObjectLambdaAccessPointRequest(ctx context.Context, options accesspo
resolveService := tv.Service
ero := options.EndpointResolverOptions
ero.Logger = middleware.GetLogger(ctx)
ero.ResolvedRegion = "" // clear endpoint options resolved region so we resolve the passed in region
// resolve endpoint
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, options.EndpointResolverOptions)
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, ero)
if err != nil {
return ctx, s3shared.NewFailedToResolveEndpointError(
tv,
@ -423,7 +392,10 @@ func buildMultiRegionAccessPointsRequest(ctx context.Context, options accesspoin
arnPartition := tv.Partition
// resolve endpoint
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, options.EndpointResolverOptions)
ero := options.EndpointResolverOptions
ero.Logger = middleware.GetLogger(ctx)
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, ero)
if err != nil {
return ctx, s3shared.NewFailedToResolveEndpointError(
tv,
@ -451,7 +423,7 @@ func buildMultiRegionAccessPointsRequest(ctx context.Context, options accesspoin
// modify endpoint host to use s3-global host prefix
scheme := strings.SplitN(endpoint.URL, "://", 2)
dnsSuffix, err := endpoints.GetDNSSuffix(arnPartition)
dnsSuffix, err := endpoints.GetDNSSuffix(arnPartition, ero)
if err != nil {
return ctx, fmt.Errorf("Error determining dns suffix from arn partition, %w", err)
}
@ -525,8 +497,12 @@ func buildOutpostAccessPointRequest(ctx context.Context, options outpostAccessPo
endpointsID = "s3"
}
ero := options.EndpointResolverOptions
ero.Logger = middleware.GetLogger(ctx)
ero.ResolvedRegion = ""
// resolve regional endpoint for resolved region.
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, options.EndpointResolverOptions)
endpoint, err := options.EndpointResolver.ResolveEndpoint(resolveRegion, ero)
if err != nil {
return ctx, s3shared.NewFailedToResolveEndpointError(
tv,

9
vendor/github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations/s3_object_lambda.go generated vendored
View File

@ -14,9 +14,6 @@ type s3ObjectLambdaEndpoint struct {
// whether the operation should use the s3-object-lambda endpoint
UseEndpoint bool
// use dualstack
UseDualstack bool
// use transfer acceleration
UseAccelerate bool
@ -42,7 +39,7 @@ func (t *s3ObjectLambdaEndpoint) HandleSerialize(
return out, metadata, fmt.Errorf("unknown transport type: %T", in.Request)
}
if t.UseDualstack {
if t.EndpointResolverOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled {
return out, metadata, fmt.Errorf("client configured for dualstack but not supported for operation")
}
@ -52,7 +49,9 @@ func (t *s3ObjectLambdaEndpoint) HandleSerialize(
region := awsmiddleware.GetRegion(ctx)
endpoint, err := t.EndpointResolver.ResolveEndpoint(region, t.EndpointResolverOptions)
ero := t.EndpointResolverOptions
endpoint, err := t.EndpointResolver.ResolveEndpoint(region, ero)
if err != nil {
return out, metadata, err
}

32
vendor/github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations/update_endpoint.go generated vendored
View File

@ -3,19 +3,17 @@ package customizations
import (
"context"
"fmt"
"github.com/aws/smithy-go/encoding/httpbinding"
"log"
"net/url"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/internal/s3shared"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/s3/internal/endpoints"
"github.com/aws/smithy-go/encoding/httpbinding"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// EndpointResolver interface for resolving service endpoints.
@ -50,9 +48,6 @@ type UpdateEndpointOptions struct {
// indicates if an operation supports s3 transfer acceleration.
SupportsAccelerate bool
// use dualstack
UseDualstack bool
// use ARN region
UseARNRegion bool
@ -72,6 +67,8 @@ type UpdateEndpointOptions struct {
// UpdateEndpoint adds the middleware to the middleware stack based on the UpdateEndpointOptions.
func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err error) {
const serializerID = "OperationSerializer"
// initial arn look up middleware
err = stack.Initialize.Add(&s3shared.ARNLookup{
GetARNValue: options.Accessor.GetBucketFromInput,
@ -84,11 +81,10 @@ func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err
err = stack.Serialize.Insert(&processARNResource{
UseARNRegion: options.UseARNRegion,
UseAccelerate: options.UseAccelerate,
UseDualstack: options.UseDualstack,
EndpointResolver: options.EndpointResolver,
EndpointResolverOptions: options.EndpointResolverOptions,
DisableMultiRegionAccessPoints: options.DisableMultiRegionAccessPoints,
}, "OperationSerializer", middleware.Before)
}, serializerID, middleware.Before)
if err != nil {
return err
}
@ -99,25 +95,15 @@ func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err
err = stack.Serialize.Insert(&s3ObjectLambdaEndpoint{
UseEndpoint: options.TargetS3ObjectLambda,
UseAccelerate: options.UseAccelerate,
UseDualstack: options.UseDualstack,
EndpointResolver: options.EndpointResolver,
EndpointResolverOptions: options.EndpointResolverOptions,
}, "OperationSerializer", middleware.Before)
}, serializerID, middleware.Before)
if err != nil {
return err
}
// remove bucket arn middleware
err = stack.Serialize.Insert(&removeBucketFromPathMiddleware{}, "OperationSerializer", middleware.After)
if err != nil {
return err
}
// enable dual stack support
err = stack.Serialize.Insert(&s3shared.EnableDualstack{
UseDualstack: options.UseDualstack,
DefaultServiceID: "s3",
}, "OperationSerializer", middleware.After)
err = stack.Serialize.Insert(&removeBucketFromPathMiddleware{}, serializerID, middleware.After)
if err != nil {
return err
}
@ -128,7 +114,7 @@ func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err
getBucketFromInput: options.Accessor.GetBucketFromInput,
useAccelerate: options.UseAccelerate,
supportsAccelerate: options.SupportsAccelerate,
}, (*s3shared.EnableDualstack)(nil).ID(), middleware.After)
}, serializerID, middleware.After)
if err != nil {
return err
}