src

interceptor_middleware.go (8583B)

---

 package http
 
 import (
 	"context"
 	"errors"
 
 	"github.com/aws/smithy-go/middleware"
 )
 
 type ictxKey struct{}
 
 func withIctx(ctx context.Context) context.Context {
 	return middleware.WithStackValue(ctx, ictxKey{}, &InterceptorContext{})
 }
 
 func getIctx(ctx context.Context) *InterceptorContext {
 	return middleware.GetStackValue(ctx, ictxKey{}).(*InterceptorContext)
 }
 
 // InterceptExecution runs Before/AfterExecutionInterceptors.
 type InterceptExecution struct {
 	BeforeExecution []BeforeExecutionInterceptor
 	AfterExecution  []AfterExecutionInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptExecution) ID() string {
 	return "InterceptExecution"
 }
 
 // HandleInitialize runs the interceptors.
 func (m *InterceptExecution) HandleInitialize(
 	ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
 ) (
 	out middleware.InitializeOutput, md middleware.Metadata, err error,
 ) {
 	ctx = withIctx(ctx)
 	getIctx(ctx).Input = in.Parameters
 
 	for _, i := range m.BeforeExecution {
 		if err := i.BeforeExecution(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	out, md, err = next.HandleInitialize(ctx, in)
 
 	for _, i := range m.AfterExecution {
 		if err := i.AfterExecution(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return out, md, err
 }
 
 // InterceptBeforeSerialization runs BeforeSerializationInterceptors.
 type InterceptBeforeSerialization struct {
 	Interceptors []BeforeSerializationInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptBeforeSerialization) ID() string {
 	return "InterceptBeforeSerialization"
 }
 
 // HandleSerialize runs the interceptors.
 func (m *InterceptBeforeSerialization) HandleSerialize(
 	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
 ) (
 	out middleware.SerializeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.Interceptors {
 		if err := i.BeforeSerialization(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return next.HandleSerialize(ctx, in)
 }
 
 // InterceptAfterSerialization runs AfterSerializationInterceptors.
 type InterceptAfterSerialization struct {
 	Interceptors []AfterSerializationInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptAfterSerialization) ID() string {
 	return "InterceptAfterSerialization"
 }
 
 // HandleSerialize runs the interceptors.
 func (m *InterceptAfterSerialization) HandleSerialize(
 	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
 ) (
 	out middleware.SerializeOutput, md middleware.Metadata, err error,
 ) {
 	getIctx(ctx).Request = in.Request.(*Request)
 
 	for _, i := range m.Interceptors {
 		if err := i.AfterSerialization(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return next.HandleSerialize(ctx, in)
 }
 
 // InterceptBeforeRetryLoop runs BeforeRetryLoopInterceptors.
 type InterceptBeforeRetryLoop struct {
 	Interceptors []BeforeRetryLoopInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptBeforeRetryLoop) ID() string {
 	return "InterceptBeforeRetryLoop"
 }
 
 // HandleFinalize runs the interceptors.
 func (m *InterceptBeforeRetryLoop) HandleFinalize(
 	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
 ) (
 	out middleware.FinalizeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.Interceptors {
 		if err := i.BeforeRetryLoop(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return next.HandleFinalize(ctx, in)
 }
 
 // InterceptBeforeSigning runs BeforeSigningInterceptors.
 type InterceptBeforeSigning struct {
 	Interceptors []BeforeSigningInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptBeforeSigning) ID() string {
 	return "InterceptBeforeSigning"
 }
 
 // HandleFinalize runs the interceptors.
 func (m *InterceptBeforeSigning) HandleFinalize(
 	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
 ) (
 	out middleware.FinalizeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.Interceptors {
 		if err := i.BeforeSigning(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return next.HandleFinalize(ctx, in)
 }
 
 // InterceptAfterSigning runs AfterSigningInterceptors.
 type InterceptAfterSigning struct {
 	Interceptors []AfterSigningInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptAfterSigning) ID() string {
 	return "InterceptAfterSigning"
 }
 
 // HandleFinalize runs the interceptors.
 func (m *InterceptAfterSigning) HandleFinalize(
 	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
 ) (
 	out middleware.FinalizeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.Interceptors {
 		if err := i.AfterSigning(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return next.HandleFinalize(ctx, in)
 }
 
 // InterceptTransmit runs BeforeTransmitInterceptors and AfterTransmitInterceptors.
 type InterceptTransmit struct {
 	BeforeTransmit []BeforeTransmitInterceptor
 	AfterTransmit  []AfterTransmitInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptTransmit) ID() string {
 	return "InterceptTransmit"
 }
 
 // HandleDeserialize runs the interceptors.
 func (m *InterceptTransmit) HandleDeserialize(
 	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
 ) (
 	out middleware.DeserializeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.BeforeTransmit {
 		if err := i.BeforeTransmit(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	out, md, err = next.HandleDeserialize(ctx, in)
 	if err != nil {
 		return out, md, err
 	}
 
 	// the root of the decorated middleware guarantees this will be here
 	// (client.go: ClientHandler.Handle)
 	getIctx(ctx).Response = out.RawResponse.(*Response)
 
 	for _, i := range m.AfterTransmit {
 		if err := i.AfterTransmit(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return out, md, err
 }
 
 // InterceptBeforeDeserialization runs BeforeDeserializationInterceptors.
 type InterceptBeforeDeserialization struct {
 	Interceptors []BeforeDeserializationInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptBeforeDeserialization) ID() string {
 	return "InterceptBeforeDeserialization"
 }
 
 // HandleDeserialize runs the interceptors.
 func (m *InterceptBeforeDeserialization) HandleDeserialize(
 	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
 ) (
 	out middleware.DeserializeOutput, md middleware.Metadata, err error,
 ) {
 	out, md, err = next.HandleDeserialize(ctx, in)
 	if err != nil {
 		var terr *RequestSendError
 		if errors.As(err, &terr) {
 			return out, md, err
 		}
 	}
 
 	for _, i := range m.Interceptors {
 		if err := i.BeforeDeserialization(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return out, md, err
 }
 
 // InterceptAfterDeserialization runs AfterDeserializationInterceptors.
 type InterceptAfterDeserialization struct {
 	Interceptors []AfterDeserializationInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptAfterDeserialization) ID() string {
 	return "InterceptAfterDeserialization"
 }
 
 // HandleDeserialize runs the interceptors.
 func (m *InterceptAfterDeserialization) HandleDeserialize(
 	ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler,
 ) (
 	out middleware.DeserializeOutput, md middleware.Metadata, err error,
 ) {
 	out, md, err = next.HandleDeserialize(ctx, in)
 	if err != nil {
 		var terr *RequestSendError
 		if errors.As(err, &terr) {
 			return out, md, err
 		}
 	}
 
 	getIctx(ctx).Output = out.Result
 
 	for _, i := range m.Interceptors {
 		if err := i.AfterDeserialization(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return out, md, err
 }
 
 // InterceptAttempt runs AfterAttemptInterceptors.
 type InterceptAttempt struct {
 	BeforeAttempt []BeforeAttemptInterceptor
 	AfterAttempt  []AfterAttemptInterceptor
 }
 
 // ID identifies the middleware.
 func (m *InterceptAttempt) ID() string {
 	return "InterceptAttempt"
 }
 
 // HandleFinalize runs the interceptors.
 func (m *InterceptAttempt) HandleFinalize(
 	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
 ) (
 	out middleware.FinalizeOutput, md middleware.Metadata, err error,
 ) {
 	for _, i := range m.BeforeAttempt {
 		if err := i.BeforeAttempt(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	out, md, err = next.HandleFinalize(ctx, in)
 
 	for _, i := range m.AfterAttempt {
 		if err := i.AfterAttempt(ctx, getIctx(ctx)); err != nil {
 			return out, md, err
 		}
 	}
 
 	return out, md, err
 }