layer

type Handler ¶

type Handler interface {
	HandleHTTP(http.ResponseWriter, *http.Request, http.Handler)
}

Handler represents the vinxi specific supported interface that can be implemented by middleware handlers.

type HandlerFunc ¶

type HandlerFunc func(http.ResponseWriter, *http.Request)

HandlerFunc represents the required function interface for simple middleware handlers.

type HandlerFuncNext ¶

type HandlerFuncNext func(http.ResponseWriter, *http.Request, http.Handler)

HandlerFuncNext represents a Negroni-like handler function notation.

type Layer ¶

type Layer struct {
	// RWMutex is used to provide thread-safe sync to the middleware store.
	sync.RWMutex

	// Pool stores the phase-specific middleware handlers stack.
	Pool Pool
	// contains filtered or unexported fields
}

Layer type represent an HTTP domain specific middleware layer with hieritance support.

func New() *Layer

func (s *Layer) Flush()

func (s *Layer) Run(phase string, w http.ResponseWriter, r *http.Request, h http.Handler)

func (s *Layer) SetParent(parent Middleware)

func (s *Layer) Use(phase string, handler ...interface{})

func (s *Layer) UseFinalHandler(fn http.Handler)

func (s *Layer) UsePriority(phase string, priority Priority, handler ...interface{})

type Middleware ¶

type Middleware interface {
	// Middleware is also a Runnable interface.
	Runnable
	// Middleware is also a Pluggable interface.
	Pluggable
	// Flush flushes the middleware handlers pool.
	Flush()
}

Middleware especifies the required interface that must be implemented by third-party middleware capable interfaces.

type MiddlewareFunc ¶

type MiddlewareFunc func(http.Handler) http.Handler

MiddlewareFunc represents the http.Handler -> http.Handler capable interface.

func AdaptFunc(h interface{}) MiddlewareFunc

type MiddlewareHandlerFunc ¶

type MiddlewareHandlerFunc func(http.Handler) func(http.ResponseWriter, *http.Request)

MiddlewareHandlerFunc represents the http.Handler -> http.HandlerFunc capable interface.

type PartialHandler ¶

type PartialHandler interface {
	HandleHTTP(http.Handler) func(http.ResponseWriter, *http.Request)
}

PartialHandler represents the vinxi specific supported interface that applies partial function application and can be implemented by middleware handlers.

type Pluggable ¶

type Pluggable interface {
	// Use method is used to register a new middleware handler in the stack.
	Use(phase string, handler ...interface{})
	// UsePriority method is used to register a new middleware handler in a specific phase.
	UsePriority(string, Priority, ...interface{})
	// UseFinalHandler defines the middleware handler terminator
	UseFinalHandler(handler http.Handler)
	// SetParent allows hierarchical middleware inheritance.
	SetParent(Middleware)
}

Pluggable represents a middleware pluggable interface implementing the required methods to plug in middleware handlers.

type Pool ¶

type Pool map[string]*Stack

Pool represents the phase-specific stack to store middleware functions.

type Priority ¶

type Priority int

Priority represents the middleware priority.

const (
	// TopHead priority defines the middleware handler
	// as first element of the stack head.
	TopHead Priority = iota

	// Head priority stores the middleware handler
	// in the head of the stack.
	Head

	// Normal priority defines the middleware handler
	// in the last stack available.
	Normal

	// TopTail priority defines the middleware handler
	// as fist element of the stack tail.
	TopTail

	// Tail priority defines the middleware handler
	// in the tail of the stack.
	Tail
)

type Registrable ¶

type Registrable interface {
	// Register is designed to allow the plugin developers
	// to attach multiple middleware layers passing the current middleware layer.
	Register(Middleware)
}

Registrable represents the required interface implemented by middleware capable handlers to register one or multiple middleware phases.

This is mostly used as inversion of control mecanish allowing to third-party middleware implementors the ability to register multiple middleware handlers transparently.

For instance, you can register request and error handlers:

func (s *MyStruct) Register(mw layer.Middleware) {
   mw.Use("request", s.requestHandler)
   mw.Use("error", s.errorHandler)
}

type Runnable ¶

type Runnable interface {
	Run(string, http.ResponseWriter, *http.Request, http.Handler)
}

Runnable represents the required interface for a runnable

type Stack ¶

type Stack struct {

	// Head stores the head priority handlers.
	Head []MiddlewareFunc

	// Stack stores the middleware normal priority handlers.
	Stack []MiddlewareFunc

	// Tail stores the middleware tail priority handlers.
	Tail []MiddlewareFunc
	// contains filtered or unexported fields
}

Stack stores the data to show.

func (s *Stack) Join() []MiddlewareFunc

func (s *Stack) Len() int

func (s *Stack) Push(order Priority, h MiddlewareFunc)