Package: customizations

import "../ibm-cos-sdk-go-v2/service/s3/internal/customizations"

Variables

var _ (smithyhttp.Signer) = writable

Value:

(*ExpressSigner)(nil)

Type Summary collapse

Interface Summary collapse

Function Summary collapse

Type Details

AddExpiresOnPresignedURL struct

AddExpiresOnPresignedURL represents a build middleware used to assign expiration on a presigned URL.

Structure Fields:

Expires time.Duration

Expires is time.Duration within which presigned url should be expired. This should be the duration in seconds the presigned URL should be considered valid for. By default the S3 presigned url expires in 15 minutes ie. 900 seconds.

ExpressIdentityResolver struct

ExpressIdentityResolver retrieves identity for the S3Express storage class.

Structure Fields:

Provider S3ExpressCredentialsProvider

PresignHTTPRequestMiddlewareOptions struct

PresignHTTPRequestMiddlewareOptions is the options for the PresignHTTPRequestMiddleware middleware.

Structure Fields:

CredentialsProvider aws.CredentialsProvider
ExpressCredentials S3ExpressCredentialsProvider
V4Presigner v4.HTTPPresigner
V4aPresigner v4a.HTTPPresigner
LogSigning bool

SignHTTPRequestMiddlewareOptions struct

SignHTTPRequestMiddlewareOptions is the configuration options for the SignHTTPRequestMiddleware middleware.

Structure Fields:

CredentialsProvider aws.CredentialsProvider

credential provider

LogSigning bool

log signing

V4Signer v4.HTTPSigner

v4 signer

V4aSigner v4a.HTTPSigner

v4a signer

UpdateEndpointOptions struct

UpdateEndpointOptions provides the options for the UpdateEndpoint middleware setup.

Structure Fields:

Accessor UpdateEndpointParameterAccessor

Accessor are parameter accessors used by the middleware

UsePathStyle bool

use path style

UseAccelerate bool

use transfer acceleration

SupportsAccelerate bool

indicates if an operation supports s3 transfer acceleration.

UseARNRegion bool

use ARN region

TargetS3ObjectLambda bool

Indicates that the operation should target the s3-object-lambda endpoint. Used to direct operations that do not route based on an input ARN.

EndpointResolver EndpointResolver

EndpointResolver used to resolve endpoints. This may be a custom endpoint resolver

EndpointResolverOptions EndpointResolverOptions

EndpointResolverOptions used by endpoint resolver

DisableMultiRegionAccessPoints bool

DisableMultiRegionAccessPoints indicates multi-region access point support is disabled

UpdateEndpointParameterAccessor struct

UpdateEndpointParameterAccessor represents accessor functions used by the middleware

Structure Fields:

(empty struct)

Function Details

func AddExpressDefaultChecksumMiddleware(s *middleware.Stack) error

AddExpressDefaultChecksumMiddleware appends a step to default to CRC32 for S3Express requests. This should only be applied to operations where a checksum is required (e.g. DeleteObject).



31
32
33
34
35
36
37
38
39
40
41
 
// File 'service/s3/internal/customizations/express_default_checksum.go', line 31


func AddExpressDefaultChecksumMiddleware(s *middleware.Stack) error {
	err := s.Finalize.Insert(
		&expressDefaultChecksumMiddleware{},
		"AWSChecksum:ComputeInputPayloadChecksum",
		middleware.Before,
	)
	if err != nil {
		return fmt.Errorf("add expressDefaultChecksum: %v", err)
	}
	return nil
}

func GetBucket(ctx context.Context) string

GetBucket retrieves a stored bucket name within a context.



17
18
19
20
 
// File 'service/s3/internal/customizations/context.go', line 17


func GetBucket(ctx context.Context) string {
	v, _ := middleware.GetStackValue(ctx, bucketKey{}).(string)
	return v
}

func GetIdentityPropertiesBucket(ip *smithy.Properties) (string, bool)

GetIdentityPropertiesBucket returns the S3 bucket from identity properties.



12
13
14
15
 
// File 'service/s3/internal/customizations/express_properties.go', line 12


func GetIdentityPropertiesBucket(ip *smithy.Properties) (string, bool) {
	v, ok := ip.Get(bucketKey{}).(string)
	return v, ok
}

func GetPropertiesBackend(p *smithy.Properties) string

GetPropertiesBackend returns a resolved endpoint backend from the property set.



6
7
8
9
 
// File 'service/s3/internal/customizations/express_properties.go', line 6


func GetPropertiesBackend(p *smithy.Properties) string {
	v, _ := p.Get("backend").(string)
	return v
}

func GetSignerVersion(ctx context.Context) (v string)

GetSignerVersion retrieves the signer version to use for signing

Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues to clear all stack values.



19
20
21
22
 
// File 'service/s3/internal/customizations/signer_wrapper.go', line 19


func GetSignerVersion(ctx context.Context) (v string) {
	v, _ = middleware.GetStackValue(ctx, signerVersionKey{}).(string)
	return v
}

func HandleResponseErrorWith200Status(stack *middleware.Stack) error

HandleResponseErrorWith200Status check for S3 200 error response. If an s3 200 error is found, status code for the response is modified temporarily to 5xx response status code.



20
21
22
 
// File 'service/s3/internal/customizations/handle_200_error.go', line 20


func HandleResponseErrorWith200Status(stack *middleware.Stack) error {
	return stack.Deserialize.Insert(&processResponseFor200ErrorMiddleware{}, "OperationDeserializer", middleware.After)
}

func RegisterPreSigningMiddleware(stack *middleware.Stack, signingMiddleware *PresignHTTPRequestMiddleware) (err error)

RegisterPreSigningMiddleware registers the wrapper pre-signing middleware to the stack. If a pre-signing middleware is already present, this provided middleware will be swapped. Otherwise the middleware will be added at the tail of the finalize step.



217
218
219
220
221
222
223
224
225
226
 
// File 'service/s3/internal/customizations/signer_wrapper.go', line 217


func RegisterPreSigningMiddleware(stack *middleware.Stack, signingMiddleware *PresignHTTPRequestMiddleware) (err error) {
	const signedID = "PresignHTTPRequest"
	_, present := stack.Finalize.Get(signedID)
	if present {
		_, err = stack.Finalize.Swap(signedID, signingMiddleware)
	} else {
		err = stack.Finalize.Add(signingMiddleware, middleware.After)
	}
	return err
}

func RegisterSigningMiddleware(stack *middleware.Stack, signingMiddleware *SignHTTPRequestMiddleware) (err error)

RegisterSigningMiddleware registers the wrapper signing middleware to the stack. If a signing middleware is already present, this provided middleware will be swapped. Otherwise the middleware will be added at the tail of the finalize step.



113
114
115
116
117
118
119
120
121
122
 
// File 'service/s3/internal/customizations/signer_wrapper.go', line 113


func RegisterSigningMiddleware(stack *middleware.Stack, signingMiddleware *SignHTTPRequestMiddleware) (err error) {
	const signedID = "Signing"
	_, present := stack.Finalize.Get(signedID)
	if present {
		_, err = stack.Finalize.Swap(signedID, signingMiddleware)
	} else {
		err = stack.Finalize.Add(signingMiddleware, middleware.After)
	}
	return err
}

func ResolveDisableExpressAuth(configs []interface{}) (value bool, exists bool)

ResolveDisableExpressAuth pulls S3DisableExpressAuth setting from config sources.



8
9
10
11
12
13
14
15
16
17
 
// File 'service/s3/internal/customizations/express_config.go', line 8


func ResolveDisableExpressAuth(configs []interface{}) (value bool, exists bool) {
	for _, cfg := range configs {
		if p, ok := cfg.(s3DisableExpressAuthProvider); ok {
			if value, exists = p.GetS3DisableExpressAuth(); exists {
				break
			}
		}
	}
	return
}

func SetBucket(ctx context.Context, bucket string) context.Context

SetBucket stores a bucket name within the request context, which is required for a variety of custom S3 behaviors.



12
13
14
 
// File 'service/s3/internal/customizations/context.go', line 12


func SetBucket(ctx context.Context, bucket string) context.Context {
	return middleware.WithStackValue(ctx, bucketKey{}, bucket)
}

func SetIdentityPropertiesBucket(ip *smithy.Properties, bucket string)

SetIdentityPropertiesBucket sets the S3 bucket to identity properties.



18
19
20
 
// File 'service/s3/internal/customizations/express_properties.go', line 18


func SetIdentityPropertiesBucket(ip *smithy.Properties, bucket string) {
	ip.Set(bucketKey{}, bucket)
}

func SetSignerVersion(ctx context.Context, version string) context.Context

SetSignerVersion sets the signer version to be used for signing the request

Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues to clear all stack values.



28
29
30
 
// File 'service/s3/internal/customizations/signer_wrapper.go', line 28


func SetSignerVersion(ctx context.Context, version string) context.Context {
	return middleware.WithStackValue(ctx, signerVersionKey{}, version)
}

func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err error)

UpdateEndpoint adds the middleware to the middleware stack based on the UpdateEndpointOptions.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
// File 'service/s3/internal/customizations/update_endpoint.go', line 67


func UpdateEndpoint(stack *middleware.Stack, options UpdateEndpointOptions) (err error) {
	const serializerID = "OperationSerializer"

	// initial arn look up middleware
	err = stack.Initialize.Insert(&s3shared.ARNLookup{
		GetARNValue: options.Accessor.GetBucketFromInput,
	}, "legacyEndpointContextSetter", middleware.After)
	if err != nil {
		return err
	}

	// process arn
	err = stack.Serialize.Insert(&processARNResource{
		UseARNRegion:                   options.UseARNRegion,
		UseAccelerate:                  options.UseAccelerate,
		EndpointResolver:               options.EndpointResolver,
		EndpointResolverOptions:        options.EndpointResolverOptions,
		DisableMultiRegionAccessPoints: options.DisableMultiRegionAccessPoints,
	}, serializerID, middleware.Before)
	if err != nil {
		return err
	}

	// process whether the operation requires the s3-object-lambda endpoint
	// Occurs before operation serializer so that hostPrefix mutations
	// can be handled correctly.
	err = stack.Serialize.Insert(&s3ObjectLambdaEndpoint{
		UseEndpoint:             options.TargetS3ObjectLambda,
		UseAccelerate:           options.UseAccelerate,
		EndpointResolver:        options.EndpointResolver,
		EndpointResolverOptions: options.EndpointResolverOptions,
	}, serializerID, middleware.Before)
	if err != nil {
		return err
	}

	// remove bucket arn middleware
	err = stack.Serialize.Insert(&removeBucketFromPathMiddleware{}, serializerID, middleware.After)
	if err != nil {
		return err
	}

	// update endpoint to use options for path style and accelerate
	err = stack.Serialize.Insert(&updateEndpoint{
		usePathStyle:       options.UsePathStyle,
		getBucketFromInput: options.Accessor.GetBucketFromInput,
		useAccelerate:      options.UseAccelerate,
		supportsAccelerate: options.SupportsAccelerate,
	}, serializerID, middleware.After)
	if err != nil {
		return err
	}

	return err
}