http

type AfterAttemptInterceptor ¶ added in v1.22.5

type AfterAttemptInterceptor interface {
	AfterAttempt(ctx context.Context, in *InterceptorContext) error
}

AfterAttemptInterceptor runs right after the incoming HTTP response is deserialized. This hook is invoked regardless of whether the deserialized result was an error, or if another interceptor within the retry loop returned an error.

Available InterceptorContext fields:

• Input
• Output (IF the operation had a success-level response)
• Request (IF the operation did not return an error during serialization)
• Response (IF the operation was able to transmit the HTTP request)

type AfterDeserializationInterceptor ¶ added in v1.22.5

type AfterDeserializationInterceptor interface {
	AfterDeserialization(ctx context.Context, in *InterceptorContext) error
}

AfterDeserializationInterceptor runs right after the incoming HTTP response is deserialized. This hook is invoked regardless of whether the deserialized result was an error.

This interceptor IS NOT invoked if the HTTP round-trip was not successful.

Available InterceptorContext fields:

• Input
• Output (IF the operation had a success-level response)
• Request
• Response

type AfterExecutionInterceptor ¶ added in v1.22.5

type AfterExecutionInterceptor interface {
	AfterExecution(ctx context.Context, in *InterceptorContext) error
}

AfterExecutionInterceptor runs after everything else. It runs regardless of how far the operation progressed in its lifecycle, and regardless of whether the operation succeeded or failed.

Available InterceptorContext fields:

• Input
• Output (IF the operation had a success-level response)
• Request (IF the operation did not return an error during serialization)
• Response (IF the operation was able to transmit the HTTP request)

type AfterSerializationInterceptor ¶ added in v1.22.5

type AfterSerializationInterceptor interface {
	AfterSerialization(ctx context.Context, in *InterceptorContext) error
}

AfterSerializationInterceptor runs after the operation input is serialized into its transport request.

Available InterceptorContext fields:

• Input
• Request

type AfterSigningInterceptor ¶ added in v1.22.5

type AfterSigningInterceptor interface {
	AfterSigning(ctx context.Context, in *InterceptorContext) error
}

AfterSigningInterceptor runs right after the request is signed.

It is unsafe to modify the outgoing HTTP request at or past this hook, since doing so may invalidate the signature of the request.

Available InterceptorContext fields:

• Input
• Request

type AfterTransmitInterceptor ¶ added in v1.22.5

type AfterTransmitInterceptor interface {
	AfterTransmit(ctx context.Context, in *InterceptorContext) error
}

AfterTransmitInterceptor runs right after the HTTP response is received.

It will always be invoked when a response is received, regardless of its status code. Conversely, it WILL NOT be invoked if the HTTP round-trip was not successful, e.g. because of a DNS resolution error

Available InterceptorContext fields:

• Input
• Request
• Response

type AuthScheme ¶ added in v1.17.0

type AuthScheme interface {
	SchemeID() string
	IdentityResolver(auth.IdentityResolverOptions) auth.IdentityResolver
	Signer() Signer
}

AuthScheme defines an HTTP authentication scheme.

func NewAnonymousScheme() AuthScheme

type BeforeAttemptInterceptor ¶ added in v1.22.5

type BeforeAttemptInterceptor interface {
	BeforeAttempt(ctx context.Context, in *InterceptorContext) error
}

BeforeAttemptInterceptor runs right before every attempt in the retry loop.

If this interceptor returns an error, AfterAttempt interceptors WILL NOT be invoked.

Available InterceptorContext fields:

• Input
• Request

type BeforeDeserializationInterceptor ¶ added in v1.22.5

type BeforeDeserializationInterceptor interface {
	BeforeDeserialization(ctx context.Context, in *InterceptorContext) error
}

BeforeDeserializationInterceptor runs right before the incoming HTTP response is deserialized.

This interceptor IS NOT invoked if the HTTP round-trip was not successful.

Deserialization occurs within the operation's retry loop.

Available InterceptorContext fields:

• Input
• Request
• Response

type BeforeExecutionInterceptor ¶ added in v1.22.5

type BeforeExecutionInterceptor interface {
	BeforeExecution(ctx context.Context, in *InterceptorContext) error
}

BeforeExecutionInterceptor runs before anything else in the operation lifecycle.

Available InterceptorContext fields:

• Input

type BeforeRetryLoopInterceptor ¶ added in v1.22.5

type BeforeRetryLoopInterceptor interface {
	BeforeRetryLoop(ctx context.Context, in *InterceptorContext) error
}

BeforeRetryLoopInterceptor runs right before the operation enters the retry loop.

Available InterceptorContext fields:

• Input
• Request

type BeforeSerializationInterceptor ¶ added in v1.22.5

type BeforeSerializationInterceptor interface {
	BeforeSerialization(ctx context.Context, in *InterceptorContext) error
}

BeforeSerializationInterceptor runs before the operation input is serialized into its transport request.

Serialization occurs before the operation's retry loop.

Available InterceptorContext fields:

• Input

type BeforeSigningInterceptor ¶ added in v1.22.5

type BeforeSigningInterceptor interface {
	BeforeSigning(ctx context.Context, in *InterceptorContext) error
}

BeforeSigningInterceptor runs right before the request is signed.

Signing occurs within the operation's retry loop.

Available InterceptorContext fields:

• Input
• Request

type BeforeTransmitInterceptor ¶ added in v1.22.5

type BeforeTransmitInterceptor interface {
	BeforeTransmit(ctx context.Context, in *InterceptorContext) error
}

BeforeTransmitInterceptor runs right before the HTTP request is sent.

HTTP transmit occurs within the operation's retry loop.

Available InterceptorContext fields:

• Input
• Request

type ClientDo ¶

type ClientDo interface {
	Do(*http.Request) (*http.Response, error)
}

ClientDo provides the interface for custom HTTP client implementations.

type ClientDoFunc ¶

type ClientDoFunc func(*http.Request) (*http.Response, error)

ClientDoFunc provides a helper to wrap a function as an HTTP client for round tripping requests.

func (fn ClientDoFunc) Do(r *http.Request) (*http.Response, error)

type ClientHandler ¶

type ClientHandler struct {
	Meter metrics.Meter // For HTTP client metrics.
	// contains filtered or unexported fields
}

ClientHandler wraps a client that implements the HTTP Do method. Standard implementation is http.Client.

func NewClientHandler(client ClientDo) ClientHandler

func NewClientHandlerWithOptions(client ClientDo, opts ...func(*ClientHandler)) ClientHandler

func (c ClientHandler) Handle(ctx context.Context, input interface{}) (
	out interface{}, metadata middleware.Metadata, err error,
)

type ComputeContentLength ¶

type ComputeContentLength struct {
}

ComputeContentLength provides a middleware to set the content-length header for the length of a serialize request body.

func (m *ComputeContentLength) HandleBuild(
	ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
	out middleware.BuildOutput, metadata middleware.Metadata, err error,
)

func (m *ComputeContentLength) ID() string

type InterceptAfterDeserialization ¶ added in v1.22.5

type InterceptAfterDeserialization struct {
	Interceptors []AfterDeserializationInterceptor
}

InterceptAfterDeserialization runs AfterDeserializationInterceptors.

func (m *InterceptAfterDeserialization) HandleDeserialize(
	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
	out middleware.DeserializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptAfterDeserialization) ID() string

type InterceptAfterSerialization ¶ added in v1.22.5

type InterceptAfterSerialization struct {
	Interceptors []AfterSerializationInterceptor
}

InterceptAfterSerialization runs AfterSerializationInterceptors.

func (m *InterceptAfterSerialization) HandleSerialize(
	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
	out middleware.SerializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptAfterSerialization) ID() string

type InterceptAfterSigning ¶ added in v1.22.5

type InterceptAfterSigning struct {
	Interceptors []AfterSigningInterceptor
}

InterceptAfterSigning runs AfterSigningInterceptors.

func (m *InterceptAfterSigning) HandleFinalize(
	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	out middleware.FinalizeOutput, md middleware.Metadata, err error,
)

func (m *InterceptAfterSigning) ID() string

type InterceptAttempt ¶ added in v1.22.5

type InterceptAttempt struct {
	BeforeAttempt []BeforeAttemptInterceptor
	AfterAttempt  []AfterAttemptInterceptor
}

InterceptAttempt runs AfterAttemptInterceptors.

func (m *InterceptAttempt) HandleFinalize(
	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	out middleware.FinalizeOutput, md middleware.Metadata, err error,
)

func (m *InterceptAttempt) ID() string

type InterceptBeforeDeserialization ¶ added in v1.22.5

type InterceptBeforeDeserialization struct {
	Interceptors []BeforeDeserializationInterceptor
}

InterceptBeforeDeserialization runs BeforeDeserializationInterceptors.

func (m *InterceptBeforeDeserialization) HandleDeserialize(
	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
	out middleware.DeserializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptBeforeDeserialization) ID() string

type InterceptBeforeRetryLoop ¶ added in v1.22.5

type InterceptBeforeRetryLoop struct {
	Interceptors []BeforeRetryLoopInterceptor
}

InterceptBeforeRetryLoop runs BeforeRetryLoopInterceptors.

func (m *InterceptBeforeRetryLoop) HandleFinalize(
	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	out middleware.FinalizeOutput, md middleware.Metadata, err error,
)

func (m *InterceptBeforeRetryLoop) ID() string

type InterceptBeforeSerialization ¶ added in v1.22.5

type InterceptBeforeSerialization struct {
	Interceptors []BeforeSerializationInterceptor
}

InterceptBeforeSerialization runs BeforeSerializationInterceptors.

func (m *InterceptBeforeSerialization) HandleSerialize(
	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
	out middleware.SerializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptBeforeSerialization) ID() string

type InterceptBeforeSigning ¶ added in v1.22.5

type InterceptBeforeSigning struct {
	Interceptors []BeforeSigningInterceptor
}

InterceptBeforeSigning runs BeforeSigningInterceptors.

func (m *InterceptBeforeSigning) HandleFinalize(
	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	out middleware.FinalizeOutput, md middleware.Metadata, err error,
)

func (m *InterceptBeforeSigning) ID() string

type InterceptExecution ¶ added in v1.22.5

type InterceptExecution struct {
	BeforeExecution []BeforeExecutionInterceptor
	AfterExecution  []AfterExecutionInterceptor
}

InterceptExecution runs Before/AfterExecutionInterceptors.

func (m *InterceptExecution) HandleInitialize(
	ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
	out middleware.InitializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptExecution) ID() string

type InterceptTransmit ¶ added in v1.22.5

type InterceptTransmit struct {
	BeforeTransmit []BeforeTransmitInterceptor
	AfterTransmit  []AfterTransmitInterceptor
}

InterceptTransmit runs BeforeTransmitInterceptors and AfterTransmitInterceptors.

func (m *InterceptTransmit) HandleDeserialize(
	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
	out middleware.DeserializeOutput, md middleware.Metadata, err error,
)

func (m *InterceptTransmit) ID() string

type InterceptorContext ¶ added in v1.22.5

type InterceptorContext struct {
	Input   any
	Request *Request

	Output   any
	Response *Response
}

InterceptorContext is all the information available in different interceptors.

Not all information is available in each interceptor, see each interface definition for more details.

type InterceptorRegistry ¶ added in v1.22.5

type InterceptorRegistry struct {
	BeforeExecution       []BeforeExecutionInterceptor
	BeforeSerialization   []BeforeSerializationInterceptor
	AfterSerialization    []AfterSerializationInterceptor
	BeforeRetryLoop       []BeforeRetryLoopInterceptor
	BeforeAttempt         []BeforeAttemptInterceptor
	BeforeSigning         []BeforeSigningInterceptor
	AfterSigning          []AfterSigningInterceptor
	BeforeTransmit        []BeforeTransmitInterceptor
	AfterTransmit         []AfterTransmitInterceptor
	BeforeDeserialization []BeforeDeserializationInterceptor
	AfterDeserialization  []AfterDeserializationInterceptor
	AfterAttempt          []AfterAttemptInterceptor
	AfterExecution        []AfterExecutionInterceptor
}

InterceptorRegistry holds a list of operation interceptors.

Interceptors allow callers to insert custom behavior at well-defined points within a client's operation lifecycle.

Interceptor context ¶

All interceptors are invoked with a context object that contains input and output containers for the operation. The individual fields that are available will depend on what the interceptor is and, in certain interceptors, how far the operation was able to progress. See the documentation for each interface definition for more information about field availability.

Implementations MUST NOT directly mutate the values of the fields in the interceptor context. They are free to mutate the existing values _pointed to_ by those fields, however.

Returning errors ¶

All interceptors can return errors. If an interceptor returns an error _before_ the client's retry loop, the operation will fail immediately. If one returns an error _within_ the retry loop, the error WILL be considered according to the client's retry policy.

Adding interceptors ¶

Idiomatically you will simply use one of the Add() receiver methods to register interceptors as desired. However, the list for each interface is exported on the registry struct and the caller is free to manipulate it directly, for example, to register a number of interceptors all at once, or to remove one that was previously registered.

The base SDK client WILL NOT add any interceptors. SDK operations and customizations are implemented in terms of middleware.

Modifications to the registry will not persist across operation calls when using per-operation functional options. This means you can register interceptors on a per-operation basis without affecting other operations.

func (i *InterceptorRegistry) AddAfterAttempt(v AfterAttemptInterceptor)

func (i *InterceptorRegistry) AddAfterDeserialization(v AfterDeserializationInterceptor)

func (i *InterceptorRegistry) AddAfterExecution(v AfterExecutionInterceptor)

func (i *InterceptorRegistry) AddAfterSerialization(v AfterSerializationInterceptor)

func (i *InterceptorRegistry) AddAfterSigning(v AfterSigningInterceptor)

func (i *InterceptorRegistry) AddAfterTransmit(v AfterTransmitInterceptor)

func (i *InterceptorRegistry) AddBeforeAttempt(v BeforeAttemptInterceptor)

func (i *InterceptorRegistry) AddBeforeDeserialization(v BeforeDeserializationInterceptor)

func (i *InterceptorRegistry) AddBeforeExecution(v BeforeExecutionInterceptor)

func (i *InterceptorRegistry) AddBeforeRetryLoop(v BeforeRetryLoopInterceptor)

func (i *InterceptorRegistry) AddBeforeSerialization(v BeforeSerializationInterceptor)

func (i *InterceptorRegistry) AddBeforeSigning(v BeforeSigningInterceptor)

func (i *InterceptorRegistry) AddBeforeTransmit(v BeforeTransmitInterceptor)

func (i *InterceptorRegistry) Copy() InterceptorRegistry

type MinimumProtocolError ¶ added in v1.9.0

type MinimumProtocolError struct {
	// contains filtered or unexported fields
}

MinimumProtocolError is an error type indicating that the established connection did not meet the expected minimum HTTP protocol version.

func (m *MinimumProtocolError) Error() string

type NopClient ¶

type NopClient struct{}

NopClient provides a client that ignores the request, and returns an empty successful HTTP response value.

func (NopClient) Do(r *http.Request) (*http.Response, error)

type Request ¶

type Request struct {
	*http.Request
	// contains filtered or unexported fields
}

Request provides the HTTP specific request structure for HTTP specific middleware steps to use to serialize input, and send an operation's request.

// Create the stack and provide the function that will create a new Request
// when the SerializeStep is invoked.
stack := middleware.NewStack("serialize example", NewStackRequest)

type Input struct {
	FooName  string
	BarCount int
}

// Add the serialization middleware.
stack.Serialize.Add(middleware.SerializeMiddlewareFunc("example serialize",
	func(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
		middleware.SerializeOutput, middleware.Metadata, error,
	) {
		req := in.Request.(*Request)
		input := in.Parameters.(*Input)

		req.Header.Set("foo-name", input.FooName)
		req.Header.Set("bar-count", strconv.Itoa(input.BarCount))

		return next.HandleSerialize(ctx, in)
	}),
	middleware.After,
)

// Mock example handler taking the request input and returning a response
mockHandler := middleware.HandlerFunc(func(ctx context.Context, in interface{}) (
	output interface{}, metadata middleware.Metadata, err error,
) {
	// Returns the standard http Request for the handler to make request
	// using standard http compatible client.
	req := in.(*Request).Build(context.Background())

	fmt.Println("foo-name", req.Header.Get("foo-name"))
	fmt.Println("bar-count", req.Header.Get("bar-count"))

	return &Response{
		Response: &http.Response{
			StatusCode: 200,
			Header:     http.Header{},
		},
	}, metadata, nil
})

// Use the stack to decorate the handler then invoke the decorated handler
// with the inputs.
handler := middleware.DecorateHandler(mockHandler, stack)
_, _, err := handler.Handle(context.Background(), &Input{FooName: "abc", BarCount: 123})
if err != nil {
	fmt.Fprintf(os.Stderr, "failed to call operation, %v", err)
	return
}

Output:

foo-name abc
bar-count 123

func (r *Request) Build(ctx context.Context) *http.Request

func (r *Request) Clone() *Request

func (r *Request) GetStream() io.Reader

func (r *Request) IsHTTPS() bool

func (r *Request) IsStreamSeekable() bool

func (r *Request) RewindStream() error

func (r *Request) SetStream(reader io.Reader) (rc *Request, err error)

func (r *Request) StreamLength() (size int64, ok bool, err error)

type RequestResponseLogger ¶

type RequestResponseLogger struct {
	LogRequest         bool
	LogRequestWithBody bool

	LogResponse         bool
	LogResponseWithBody bool
}

RequestResponseLogger is a deserialize middleware that will log the request and response HTTP messages and optionally their respective bodies. Will not perform any logging if none of the options are set.

func (r *RequestResponseLogger) HandleDeserialize(
	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
)

func (r *RequestResponseLogger) ID() string

type RequestSendError ¶

type RequestSendError struct {
	Err error
}

RequestSendError provides a generic request transport error. This error should wrap errors making HTTP client requests.

The ClientHandler will wrap the HTTP client's error if the client request fails, and did not fail because of context canceled.

func (e *RequestSendError) ConnectionError() bool

func (e *RequestSendError) Error() string

func (e *RequestSendError) Unwrap() error

type RequireMinimumProtocol ¶ added in v1.9.0

type RequireMinimumProtocol struct {
	ProtoMajor int
	ProtoMinor int
}

RequireMinimumProtocol is a deserialization middleware that asserts that the established HTTP connection meets the minimum major ad minor version.

func (r *RequireMinimumProtocol) HandleDeserialize(
	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
)

func (r *RequireMinimumProtocol) ID() string

type Response ¶

type Response struct {
	*http.Response
}

Response provides the HTTP specific response structure for HTTP specific middleware steps to use to deserialize the response from an operation call.

// Create the stack and provide the function that will create a new Request
// when the SerializeStep is invoked.
stack := middleware.NewStack("deserialize example", NewStackRequest)

type Output struct {
	FooName  string
	BarCount int
}

// Add a Deserialize middleware that will extract the RawResponse and
// deserialize into the target output type.
stack.Deserialize.Add(middleware.DeserializeMiddlewareFunc("example deserialize",
	func(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 middleware.DeserializeOutput{}, metadata, err
		}

		metadata.Set("example-meta", "meta-value")

		rawResp := out.RawResponse.(*Response)
		out.Result = &Output{
			FooName: rawResp.Header.Get("foo-name"),
			BarCount: func() int {
				v, _ := strconv.Atoi(rawResp.Header.Get("bar-count"))
				return v
			}(),
		}

		return out, metadata, nil
	}),
	middleware.After,
)

// Mock example handler taking the request input and returning a response
mockHandler := middleware.HandlerFunc(func(ctx context.Context, in interface{}) (
	output interface{}, metadata middleware.Metadata, err error,
) {
	resp := &http.Response{
		StatusCode: 200,
		Header:     http.Header{},
	}
	resp.Header.Set("foo-name", "abc")
	resp.Header.Set("bar-count", "123")

	// The handler's returned response will be available as the
	// DeserializeOutput.RawResponse field.
	return &Response{
		Response: resp,
	}, metadata, nil
})

// Use the stack to decorate the handler then invoke the decorated handler
// with the inputs.
handler := middleware.DecorateHandler(mockHandler, stack)
result, metadata, err := handler.Handle(context.Background(), struct{}{})
if err != nil {
	fmt.Fprintf(os.Stderr, "failed to call operation, %v", err)
	return
}

// Cast the result returned by the handler to the expected Output type.
res := result.(*Output)
fmt.Println("FooName", res.FooName)
fmt.Println("BarCount", res.BarCount)
fmt.Println("Metadata:", "example-meta:", metadata.Get("example-meta"))

Output:

FooName abc
BarCount 123
Metadata: example-meta: meta-value

type ResponseError ¶

type ResponseError struct {
	Response *Response
	Err      error
}

ResponseError provides the HTTP centric error type wrapping the underlying error with the HTTP response value.

stack := middleware.NewStack("my cool stack", NewStackRequest)

stack.Deserialize.Add(middleware.DeserializeMiddlewareFunc("wrap http response error",
	func(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 {
			// Nothing to do when there is no error.
			return out, metadata, err
		}

		rawResp, ok := out.RawResponse.(*Response)
		if !ok {
			// No raw response to wrap with.
			return out, metadata, err
		}

		// Wrap the returned error with the response error containing the
		// returned response.
		err = &ResponseError{
			Response: rawResp,
			Err:      err,
		}

		return out, metadata, err
	}),
	middleware.After,
)

stack.Deserialize.Add(middleware.DeserializeMiddlewareFunc("deserialize error",
	func(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 middleware.DeserializeOutput{}, metadata, err
		}

		rawResp := out.RawResponse.(*Response)
		if rawResp.StatusCode == 200 {
			return out, metadata, nil
		}

		// Deserialize the response API error values.
		err = &smithy.GenericAPIError{
			Code:    rawResp.Header.Get("Error-Code"),
			Message: rawResp.Header.Get("Error-Message"),
		}

		return out, metadata, err
	}),
	middleware.After,
)

// Mock example handler taking the request input and returning a response
mockHandler := middleware.HandlerFunc(func(ctx context.Context, in interface{}) (
	output interface{}, metadata middleware.Metadata, err error,
) {
	// populate the mock response with an API error and additional data.
	resp := &http.Response{
		StatusCode: 404,
		Header: http.Header{
			"Extra-Header":  []string{"foo value"},
			"Error-Code":    []string{"FooException"},
			"Error-Message": []string{"some message about the error"},
		},
	}

	// The handler's returned response will be available as the
	// DeserializeOutput.RawResponse field.
	return &Response{
		Response: resp,
	}, metadata, nil
})

// Use the stack to decorate the handler then invoke the decorated handler
// with the inputs.
handler := middleware.DecorateHandler(mockHandler, stack)
_, _, err := handler.Handle(context.Background(), struct{}{})
if err == nil {
	fmt.Printf("expect error, got none")
	return
}

if err != nil {
	var apiErr smithy.APIError
	if errors.As(err, &apiErr) {
		fmt.Printf("request failed: %s, %s\n", apiErr.ErrorCode(), apiErr.ErrorMessage())
	}

	var respErr *ResponseError
	if errors.As(err, &respErr) {
		fmt.Printf("response status: %v\n", respErr.HTTPStatusCode())
		fmt.Printf("response header: %v\n", respErr.HTTPResponse().Header.Get("Extra-Header"))
	}
}

Output:

request failed: FooException, some message about the error
response status: 404
response header: foo value

func (e *ResponseError) Error() string

func (e *ResponseError) HTTPResponse() *Response

func (e *ResponseError) HTTPStatusCode() int

func (e *ResponseError) Unwrap() error

type Signer ¶ added in v1.17.0

type Signer interface {
	SignRequest(context.Context, *Request, auth.Identity, smithy.Properties) error
}

Signer defines the interface through which HTTP requests are supplemented with an Identity.

type UserAgentBuilder ¶

type UserAgentBuilder struct {
	// contains filtered or unexported fields
}

UserAgentBuilder is a builder for a HTTP User-Agent string.

func NewUserAgentBuilder() *UserAgentBuilder

func (u *UserAgentBuilder) AddKey(key string)

func (u *UserAgentBuilder) AddKeyValue(key, value string)

func (u *UserAgentBuilder) Build() string