func AddSetLoggerMiddleware(stack *Stack, logger logging.Logger) error
AddSetLoggerMiddleware adds a middleware that will add the provided logger to the middleware context.
func ClearStackValues(ctx context.Context) context.Context
ClearStackValues returns a context without any stack values.
func GetLogger(ctx context.Context) logging.Logger
GetLogger takes a context to retrieve a Logger from. If no logger is present on the context a logging.Nop logger is returned. If the logger retrieved from context supports the ContextLogger interface, the context will be passed to the WithContext method and the resulting logger will be returned. Otherwise the stored logger is returned as is.
func GetStackValue(ctx context.Context, key interface{}) interface{}
GetStackValues returns the value pointed to by the key within the stack values, if it is present.
func SetLogger(ctx context.Context, logger logging.Logger) context.Context
SetLogger sets the provided logger value on the provided ctx.
func WithStackValue(ctx context.Context, key, value interface{}) context.Context
WithStackValue adds a key value pair to the context that is intended to be scoped to a stack. Use ClearStackValues to get a new context with all stack values cleared.
BuildHandler provides the interface for the next handler the BuildMiddleware will call in the middleware chain.
type BuildHandler interface {
HandleBuild(ctx context.Context, in BuildInput) (
out BuildOutput, metadata Metadata, err error,
)
}
BuildHandlerFunc provides a wrapper around a function to be used as a build middleware handler.
type BuildHandlerFunc func(context.Context, BuildInput) (BuildOutput, Metadata, error)
func (b BuildHandlerFunc) HandleBuild(ctx context.Context, in BuildInput) (BuildOutput, Metadata, error)
HandleBuild invokes the wrapped function with the provided arguments.
BuildInput provides the input parameters for the BuildMiddleware to consume. BuildMiddleware may modify the Request value before forwarding the input along to the next BuildHandler.
type BuildInput struct {
Request interface{}
}
BuildMiddleware provides the interface for middleware specific to the serialize step. Delegates to the next BuildHandler for further processing.
type BuildMiddleware interface {
// Unique ID for the middleware in theBuildStep. The step does not allow
// duplicate IDs.
ID() string
// Invokes the middleware behavior which must delegate to the next handler
// for the middleware chain to continue. The method must return a result or
// error to its caller.
HandleBuild(ctx context.Context, in BuildInput, next BuildHandler) (
out BuildOutput, metadata Metadata, err error,
)
}
func BuildMiddlewareFunc(id string, fn func(context.Context, BuildInput, BuildHandler) (BuildOutput, Metadata, error)) BuildMiddleware
BuildMiddlewareFunc returns a BuildMiddleware with the unique ID provided, and the func to be invoked.
BuildOutput provides the result returned by the next BuildHandler.
type BuildOutput struct {
Result interface{}
}
BuildStep provides the ordered grouping of BuildMiddleware to be invoked on a handler.
type BuildStep struct {
// contains filtered or unexported fields
}
func NewBuildStep() *BuildStep
NewBuildStep returns a BuildStep ready to have middleware for initialization added to it.
func (s *BuildStep) Add(m BuildMiddleware, pos RelativePosition) error
Add injects the middleware to the relative position of the middleware group. Returns an error if the middleware already exists.
func (s *BuildStep) Clear()
Clear removes all middleware in the step.
func (s *BuildStep) Get(id string) (BuildMiddleware, bool)
Get retrieves the middleware identified by id. If the middleware is not present, returns false.
func (s *BuildStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) ( out interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware by decorating the next handler provided. Returns the result of the middleware and handler being invoked.
Implements Middleware interface.
func (s *BuildStep) ID() string
ID returns the unique name of the step as a middleware.
func (s *BuildStep) Insert(m BuildMiddleware, relativeTo string, pos RelativePosition) error
Insert injects the middleware relative to an existing middleware id. Returns an error if the original middleware does not exist, or the middleware being added already exists.
func (s *BuildStep) List() []string
List returns a list of the middleware in the step.
func (s *BuildStep) Remove(id string) (BuildMiddleware, error)
Remove removes the middleware by id. Returns error if the middleware doesn't exist.
func (s *BuildStep) Swap(id string, m BuildMiddleware) (BuildMiddleware, error)
Swap removes the middleware by id, replacing it with the new middleware. Returns the middleware removed, or an error if the middleware to be removed doesn't exist.
DeserializeHandler provides the interface for the next handler the DeserializeMiddleware will call in the middleware chain.
type DeserializeHandler interface {
HandleDeserialize(ctx context.Context, in DeserializeInput) (
out DeserializeOutput, metadata Metadata, err error,
)
}
DeserializeHandlerFunc provides a wrapper around a function to be used as a deserialize middleware handler.
type DeserializeHandlerFunc func(context.Context, DeserializeInput) (DeserializeOutput, Metadata, error)
func (d DeserializeHandlerFunc) HandleDeserialize(ctx context.Context, in DeserializeInput) (DeserializeOutput, Metadata, error)
HandleDeserialize invokes the wrapped function with the given arguments.
DeserializeInput provides the input parameters for the DeserializeInput to consume. DeserializeMiddleware should not modify the Request, and instead forward it along to the next DeserializeHandler.
type DeserializeInput struct {
Request interface{}
}
DeserializeMiddleware provides the interface for middleware specific to the serialize step. Delegates to the next DeserializeHandler for further processing.
type DeserializeMiddleware interface {
// ID returns a unique ID for the middleware in the DeserializeStep. The step does not
// allow duplicate IDs.
ID() string
// HandleDeserialize invokes the middleware behavior which must delegate to the next handler
// for the middleware chain to continue. The method must return a result or
// error to its caller.
HandleDeserialize(ctx context.Context, in DeserializeInput, next DeserializeHandler) (
out DeserializeOutput, metadata Metadata, err error,
)
}
func DeserializeMiddlewareFunc(id string, fn func(context.Context, DeserializeInput, DeserializeHandler) (DeserializeOutput, Metadata, error)) DeserializeMiddleware
DeserializeMiddlewareFunc returns a DeserializeMiddleware with the unique ID provided, and the func to be invoked.
DeserializeOutput provides the result returned by the next DeserializeHandler. The DeserializeMiddleware should deserialize the RawResponse into a Result that can be consumed by middleware higher up in the stack.
type DeserializeOutput struct {
RawResponse interface{}
Result interface{}
}
DeserializeStep provides the ordered grouping of DeserializeMiddleware to be invoked on a handler.
type DeserializeStep struct {
// contains filtered or unexported fields
}
func NewDeserializeStep() *DeserializeStep
NewDeserializeStep returns a DeserializeStep ready to have middleware for initialization added to it.
func (s *DeserializeStep) Add(m DeserializeMiddleware, pos RelativePosition) error
Add injects the middleware to the relative position of the middleware group. Returns an error if the middleware already exists.
func (s *DeserializeStep) Clear()
Clear removes all middleware in the step.
func (s *DeserializeStep) Get(id string) (DeserializeMiddleware, bool)
Get retrieves the middleware identified by id. If the middleware is not present, returns false.
func (s *DeserializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) ( out interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware by decorating the next handler provided. Returns the result of the middleware and handler being invoked.
Implements Middleware interface.
func (s *DeserializeStep) ID() string
ID returns the unique ID of the step as a middleware.
func (s *DeserializeStep) Insert(m DeserializeMiddleware, relativeTo string, pos RelativePosition) error
Insert injects the middleware relative to an existing middleware ID. Returns error if the original middleware does not exist, or the middleware being added already exists.
func (s *DeserializeStep) List() []string
List returns a list of the middleware in the step.
func (s *DeserializeStep) Remove(id string) (DeserializeMiddleware, error)
Remove removes the middleware by id. Returns error if the middleware doesn't exist.
func (s *DeserializeStep) Swap(id string, m DeserializeMiddleware) (DeserializeMiddleware, error)
Swap removes the middleware by id, replacing it with the new middleware. Returns the middleware removed, or error if the middleware to be removed doesn't exist.
FinalizeHandler provides the interface for the next handler the FinalizeMiddleware will call in the middleware chain.
type FinalizeHandler interface {
HandleFinalize(ctx context.Context, in FinalizeInput) (
out FinalizeOutput, metadata Metadata, err error,
)
}
FinalizeHandlerFunc provides a wrapper around a function to be used as a finalize middleware handler.
type FinalizeHandlerFunc func(context.Context, FinalizeInput) (FinalizeOutput, Metadata, error)
func (f FinalizeHandlerFunc) HandleFinalize(ctx context.Context, in FinalizeInput) (FinalizeOutput, Metadata, error)
HandleFinalize invokes the wrapped function with the given arguments.
FinalizeInput provides the input parameters for the FinalizeMiddleware to consume. FinalizeMiddleware may modify the Request value before forwarding the FinalizeInput along to the next next FinalizeHandler.
type FinalizeInput struct {
Request interface{}
}
FinalizeMiddleware provides the interface for middleware specific to the serialize step. Delegates to the next FinalizeHandler for further processing.
type FinalizeMiddleware interface {
// ID returns a unique ID for the middleware in the FinalizeStep. The step does not
// allow duplicate IDs.
ID() string
// HandleFinalize invokes the middleware behavior which must delegate to the next handler
// for the middleware chain to continue. The method must return a result or
// error to its caller.
HandleFinalize(ctx context.Context, in FinalizeInput, next FinalizeHandler) (
out FinalizeOutput, metadata Metadata, err error,
)
}
func FinalizeMiddlewareFunc(id string, fn func(context.Context, FinalizeInput, FinalizeHandler) (FinalizeOutput, Metadata, error)) FinalizeMiddleware
FinalizeMiddlewareFunc returns a FinalizeMiddleware with the unique ID provided, and the func to be invoked.
FinalizeOutput provides the result returned by the next FinalizeHandler.
type FinalizeOutput struct {
Result interface{}
}
FinalizeStep provides the ordered grouping of FinalizeMiddleware to be invoked on a handler.
type FinalizeStep struct {
// contains filtered or unexported fields
}
func NewFinalizeStep() *FinalizeStep
NewFinalizeStep returns a FinalizeStep ready to have middleware for initialization added to it.
func (s *FinalizeStep) Add(m FinalizeMiddleware, pos RelativePosition) error
Add injects the middleware to the relative position of the middleware group. Returns an error if the middleware already exists.
func (s *FinalizeStep) Clear()
Clear removes all middleware in the step.
func (s *FinalizeStep) Get(id string) (FinalizeMiddleware, bool)
Get retrieves the middleware identified by id. If the middleware is not present, returns false.
func (s *FinalizeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) ( out interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware by decorating the next handler provided. Returns the result of the middleware and handler being invoked.
Implements Middleware interface.
func (s *FinalizeStep) ID() string
ID returns the unique id of the step as a middleware.
func (s *FinalizeStep) Insert(m FinalizeMiddleware, relativeTo string, pos RelativePosition) error
Insert injects the middleware relative to an existing middleware ID. Returns error if the original middleware does not exist, or the middleware being added already exists.
func (s *FinalizeStep) List() []string
List returns a list of the middleware in the step.
func (s *FinalizeStep) Remove(id string) (FinalizeMiddleware, error)
Remove removes the middleware by id. Returns error if the middleware doesn't exist.
func (s *FinalizeStep) Swap(id string, m FinalizeMiddleware) (FinalizeMiddleware, error)
Swap removes the middleware by id, replacing it with the new middleware. Returns the middleware removed, or error if the middleware to be removed doesn't exist.
Handler provides the interface for performing the logic to obtain an output, or error for the given input.
type Handler interface {
// Handle performs logic to obtain an output for the given input. Handler
// should be decorated with middleware to perform input specific behavior.
Handle(ctx context.Context, input interface{}) (
output interface{}, metadata Metadata, err error,
)
}
func DecorateHandler(h Handler, with ...Middleware) Handler
DecorateHandler decorates a handler with a middleware. Wrapping the handler with the middleware.
HandlerFunc provides a wrapper around a function pointer to be used as a middleware handler.
type HandlerFunc func(ctx context.Context, input interface{}) ( output interface{}, metadata Metadata, err error, )
func (fn HandlerFunc) Handle(ctx context.Context, input interface{}) ( output interface{}, metadata Metadata, err error, )
Handle invokes the underlying function, returning the result.
InitializeHandler provides the interface for the next handler the InitializeMiddleware will call in the middleware chain.
type InitializeHandler interface {
HandleInitialize(ctx context.Context, in InitializeInput) (
out InitializeOutput, metadata Metadata, err error,
)
}
InitializeHandlerFunc provides a wrapper around a function to be used as an initialize middleware handler.
type InitializeHandlerFunc func(context.Context, InitializeInput) (InitializeOutput, Metadata, error)
func (i InitializeHandlerFunc) HandleInitialize(ctx context.Context, in InitializeInput) (InitializeOutput, Metadata, error)
HandleInitialize calls the wrapped function with the provided arguments.
InitializeInput wraps the input parameters for the InitializeMiddlewares to consume. InitializeMiddleware may modify the parameter value before forwarding it along to the next InitializeHandler.
type InitializeInput struct {
Parameters interface{}
}
InitializeMiddleware provides the interface for middleware specific to the initialize step. Delegates to the next InitializeHandler for further processing.
type InitializeMiddleware interface {
// ID returns a unique ID for the middleware in the InitializeStep. The step does not
// allow duplicate IDs.
ID() string
// HandleInitialize invokes the middleware behavior which must delegate to the next handler
// for the middleware chain to continue. The method must return a result or
// error to its caller.
HandleInitialize(ctx context.Context, in InitializeInput, next InitializeHandler) (
out InitializeOutput, metadata Metadata, err error,
)
}
func InitializeMiddlewareFunc(id string, fn func(context.Context, InitializeInput, InitializeHandler) (InitializeOutput, Metadata, error)) InitializeMiddleware
InitializeMiddlewareFunc returns a InitializeMiddleware with the unique ID provided, and the func to be invoked.
InitializeOutput provides the result returned by the next InitializeHandler.
type InitializeOutput struct {
Result interface{}
}
InitializeStep provides the ordered grouping of InitializeMiddleware to be invoked on a handler.
type InitializeStep struct {
// contains filtered or unexported fields
}
func NewInitializeStep() *InitializeStep
NewInitializeStep returns an InitializeStep ready to have middleware for initialization added to it.
func (s *InitializeStep) Add(m InitializeMiddleware, pos RelativePosition) error
Add injects the middleware to the relative position of the middleware group. Returns an error if the middleware already exists.
func (s *InitializeStep) Clear()
Clear removes all middleware in the step.
func (s *InitializeStep) Get(id string) (InitializeMiddleware, bool)
Get retrieves the middleware identified by id. If the middleware is not present, returns false.
func (s *InitializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) ( out interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware by decorating the next handler provided. Returns the result of the middleware and handler being invoked.
Implements Middleware interface.
func (s *InitializeStep) ID() string
ID returns the unique ID of the step as a middleware.
func (s *InitializeStep) Insert(m InitializeMiddleware, relativeTo string, pos RelativePosition) error
Insert injects the middleware relative to an existing middleware ID. Returns error if the original middleware does not exist, or the middleware being added already exists.
func (s *InitializeStep) List() []string
List returns a list of the middleware in the step.
func (s *InitializeStep) Remove(id string) (InitializeMiddleware, error)
Remove removes the middleware by id. Returns error if the middleware doesn't exist.
func (s *InitializeStep) Swap(id string, m InitializeMiddleware) (InitializeMiddleware, error)
Swap removes the middleware by id, replacing it with the new middleware. Returns the middleware removed, or error if the middleware to be removed doesn't exist.
Metadata provides storing and reading metadata values. Keys may be any comparable value type. Get and set will panic if key is not a comparable value type.
Metadata uses lazy initialization, and Set method must be called as an addressable value, or pointer. Not doing so may cause key/value pair to not be set.
type Metadata struct {
// contains filtered or unexported fields
}
func (m Metadata) Clone() Metadata
Clone creates a shallow copy of Metadata entries, returning a new Metadata value with the original entries copied into it.
func (m Metadata) Get(key interface{}) interface{}
Get attempts to retrieve the value the key points to. Returns nil if the key was not found.
Panics if key type is not comparable.
func (m Metadata) Has(key interface{}) bool
Has returns whether the key exists in the metadata.
Panics if the key type is not comparable.
func (m *Metadata) Set(key, value interface{})
Set stores the value pointed to by the key. If a value already exists at that key it will be replaced with the new value.
Set method must be called as an addressable value, or pointer. If Set is not called as an addressable value or pointer, the key value pair being set may be lost.
Panics if the key type is not comparable.
MetadataReader provides an interface for reading metadata from the underlying metadata container.
type MetadataReader interface {
Get(key interface{}) interface{}
}
Middleware provides the interface to call handlers in a chain.
type Middleware interface {
// ID provides a unique identifier for the middleware.
ID() string
// Performs the middleware's handling of the input, returning the output,
// or error. The middleware can invoke the next Handler if handling should
// continue.
HandleMiddleware(ctx context.Context, input interface{}, next Handler) (
output interface{}, metadata Metadata, err error,
)
}
RelativePosition provides specifying the relative position of a middleware in an ordered group.
type RelativePosition int
Relative position for middleware in steps.
const (
After RelativePosition = iota
Before
)
SerializeHandler provides the interface for the next handler the SerializeMiddleware will call in the middleware chain.
type SerializeHandler interface {
HandleSerialize(ctx context.Context, in SerializeInput) (
out SerializeOutput, metadata Metadata, err error,
)
}
SerializeHandlerFunc provides a wrapper around a function to be used as a serialize middleware handler.
type SerializeHandlerFunc func(context.Context, SerializeInput) (SerializeOutput, Metadata, error)
func (s SerializeHandlerFunc) HandleSerialize(ctx context.Context, in SerializeInput) (SerializeOutput, Metadata, error)
HandleSerialize calls the wrapped function with the provided arguments.
SerializeInput provides the input parameters for the SerializeMiddleware to consume. SerializeMiddleware may modify the Request value before forwarding SerializeInput along to the next SerializeHandler. The Parameters member should not be modified by SerializeMiddleware, InitializeMiddleware should be responsible for modifying the provided Parameter value.
type SerializeInput struct {
Parameters interface{}
Request interface{}
}
SerializeMiddleware provides the interface for middleware specific to the serialize step. Delegates to the next SerializeHandler for further processing.
type SerializeMiddleware interface {
// ID returns a unique ID for the middleware in the SerializeStep. The step does not
// allow duplicate IDs.
ID() string
// HandleSerialize invokes the middleware behavior which must delegate to the next handler
// for the middleware chain to continue. The method must return a result or
// error to its caller.
HandleSerialize(ctx context.Context, in SerializeInput, next SerializeHandler) (
out SerializeOutput, metadata Metadata, err error,
)
}
func SerializeMiddlewareFunc(id string, fn func(context.Context, SerializeInput, SerializeHandler) (SerializeOutput, Metadata, error)) SerializeMiddleware
SerializeMiddlewareFunc returns a SerializeMiddleware with the unique ID provided, and the func to be invoked.
SerializeOutput provides the result returned by the next SerializeHandler.
type SerializeOutput struct {
Result interface{}
}
SerializeStep provides the ordered grouping of SerializeMiddleware to be invoked on a handler.
type SerializeStep struct {
// contains filtered or unexported fields
}
func NewSerializeStep(newRequest func() interface{}) *SerializeStep
NewSerializeStep returns a SerializeStep ready to have middleware for initialization added to it. The newRequest func parameter is used to initialize the transport specific request for the stack SerializeStep to serialize the input parameters into.
func (s *SerializeStep) Add(m SerializeMiddleware, pos RelativePosition) error
Add injects the middleware to the relative position of the middleware group. Returns an error if the middleware already exists.
func (s *SerializeStep) Clear()
Clear removes all middleware in the step.
func (s *SerializeStep) Get(id string) (SerializeMiddleware, bool)
Get retrieves the middleware identified by id. If the middleware is not present, returns false.
func (s *SerializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) ( out interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware by decorating the next handler provided. Returns the result of the middleware and handler being invoked.
Implements Middleware interface.
func (s *SerializeStep) ID() string
ID returns the unique ID of the step as a middleware.
func (s *SerializeStep) Insert(m SerializeMiddleware, relativeTo string, pos RelativePosition) error
Insert injects the middleware relative to an existing middleware ID. Returns error if the original middleware does not exist, or the middleware being added already exists.
func (s *SerializeStep) List() []string
List returns a list of the middleware in the step.
func (s *SerializeStep) Remove(id string) (SerializeMiddleware, error)
Remove removes the middleware by id. Returns error if the middleware doesn't exist.
func (s *SerializeStep) Swap(id string, m SerializeMiddleware) (SerializeMiddleware, error)
Swap removes the middleware by id, replacing it with the new middleware. Returns the middleware removed, or error if the middleware to be removed doesn't exist.
Stack provides protocol and transport agnostic set of middleware split into distinct steps. Steps have specific transitions between them, that are managed by the individual step.
Steps are composed as middleware around the underlying handler in the following order:
Initialize -> Serialize -> Build -> Finalize -> Deserialize -> Handler
Any middleware within the chain may choose to stop and return an error or response. Since the middleware decorate the handler like a call stack, each middleware will receive the result of the next middleware in the chain. Middleware that does not need to react to an input, or result must forward along the input down the chain, or return the result back up the chain.
Initialize <- Serialize -> Build -> Finalize <- Deserialize <- Handler
type Stack struct {
// Initialize prepares the input, and sets any default parameters as
// needed, (e.g. idempotency token, and presigned URLs).
//
// Takes Input Parameters, and returns result or error.
//
// Receives result or error from Serialize step.
Initialize *InitializeStep
// Serialize serializes the prepared input into a data structure that can be consumed
// by the target transport's message, (e.g. REST-JSON serialization)
//
// Converts Input Parameters into a Request, and returns the result or error.
//
// Receives result or error from Build step.
Serialize *SerializeStep
// Build adds additional metadata to the serialized transport message
// (e.g. HTTP's Content-Length header, or body checksum). Decorations and
// modifications to the message should be copied to all message attempts.
//
// Takes Request, and returns result or error.
//
// Receives result or error from Finalize step.
Build *BuildStep
// Finalize performs final preparations needed before sending the message. The
// message should already be complete by this stage, and is only alternated
// to meet the expectations of the recipient (e.g. Retry and AWS SigV4
// request signing)
//
// Takes Request, and returns result or error.
//
// Receives result or error from Deserialize step.
Finalize *FinalizeStep
// Deserialize reacts to the handler's response returned by the recipient of the request
// message. Deserializes the response into a structured type or error above
// stacks can react to.
//
// Should only forward Request to underlying handler.
//
// Takes Request, and returns result or error.
//
// Receives raw response, or error from underlying handler.
Deserialize *DeserializeStep
// contains filtered or unexported fields
}
func NewStack(id string, newRequestFn func() interface{}) *Stack
NewStack returns an initialize empty stack.
func (s *Stack) HandleMiddleware(ctx context.Context, input interface{}, next Handler) ( output interface{}, metadata Metadata, err error, )
HandleMiddleware invokes the middleware stack decorating the next handler. Each step of stack will be invoked in order before calling the next step. With the next handler call last.
The input value must be the input parameters of the operation being performed.
Will return the result of the operation, or error.
func (s *Stack) ID() string
ID returns the unique ID for the stack as a middleware.
func (s *Stack) List() []string
List returns a list of all middleware in the stack by step.
func (s *Stack) String() string