middleware

Documentation

Overview

Package middleware provides a convenient way to chain http handlers.

Index

• Variables
• func GetUserSession(r *http.Request) (*sessions.Session, *models.Session, error)
• func LoggingHandler(next http.Handler) http.Handler
• func XSRFHandler(next http.Handler) http.Handler
• type Chain
  • func New(constructors ...Constructor) Chain
  • func NewWithLogging(constructors ...Constructor) Chain
  • func (c Chain) Append(constructors ...Constructor) Chain
  • func (c Chain) Extend(chain Chain) Chain
  • func (c Chain) Then(h http.Handler) http.Handler
  • func (c Chain) ThenFunc(fn http.HandlerFunc) http.Handler
• type CheckFunction
• type Constructor

Variables

var (
	AuthHandler  = constructHandler(checkAPI)
	UserHandler  = constructHandler(checkLogin)
	AdminHandler = constructHandler(checkAdmin)
)

var (
	ScionSessionName = "scion-session" // key name in the session map

)

Functions

func GetUserSession

func GetUserSession(r *http.Request) (*sessions.Session, *models.Session, error)

if the returned session is nil, it means the session did not exist if the return session is not nil, then session existed before if the function returns an error, then we need to stop because the session could not be deserialized

func LoggingHandler

func LoggingHandler(next http.Handler) http.Handler

func XSRFHandler

func XSRFHandler(next http.Handler) http.Handler

Types

type Chain

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

Chain acts as a list of http.Handler constructors. Chain is effectively immutable: once created, it will always hold the same set of constructors in the same order.

func New

func New(constructors ...Constructor) Chain

New creates a new chain, memorizing the given list of middleware constructors. New serves no other function, constructors are only called upon a call to Then().

func NewWithLogging

func NewWithLogging(constructors ...Constructor) Chain

Creates a new chain including a LoggingHandler as first Handler

func (Chain) Append

func (c Chain) Append(constructors ...Constructor) Chain

Append extends a chain, adding the specified constructors as the last ones in the request flow.

Append returns a new chain, leaving the original one untouched.

stdChain := alice.New(m1, m2)
extChain := stdChain.Append(m3, m4)
// requests in stdChain go m1 -> m2
// requests in extChain go m1 -> m2 -> m3 -> m4

func (Chain) Extend

func (c Chain) Extend(chain Chain) Chain

Extend extends a chain by adding the specified chain as the last one in the request flow.

Extend returns a new chain, leaving the original one untouched.

stdChain := alice.New(m1, m2)
ext1Chain := alice.New(m3, m4)
ext2Chain := stdChain.Extend(ext1Chain)
// requests in stdChain go  m1 -> m2
// requests in ext1Chain go m3 -> m4
// requests in ext2Chain go m1 -> m2 -> m3 -> m4

Another example:

 aHtmlAfterNosurf := alice.New(m2)
	aHtml := alice.New(m1, func(h http.Handler) http.Handler {
		csrf := nosurf.New(h)
		csrf.SetFailureHandler(aHtmlAfterNosurf.ThenFunc(csrfFail))
		return csrf
	}).Extend(aHtmlAfterNosurf)
		// requests to aHtml hitting nosurfs success handler go m1 -> nosurf -> m2 -> target-handler
		// requests to aHtml hitting nosurfs failure handler go m1 -> nosurf -> m2 -> csrfFail

func (Chain) Then

func (c Chain) Then(h http.Handler) http.Handler

Then chains the middleware and returns the final http.Handler.

New(m1, m2, m3).Then(h)

is equivalent to:

m1(m2(m3(h)))

When the request comes in, it will be passed to m1, then m2, then m3 and finally, the given handler (assuming every middleware calls the following one).

A chain can be safely reused by calling Then() several times.

stdStack := alice.New(ratelimitHandler, csrfHandler)
indexPipe = stdStack.Then(indexHandler)
authPipe = stdStack.Then(authHandler)

Note that constructors are called on every call to Then() and thus several instances of the same middleware will be created when a chain is reused in this way. For proper middleware, this should cause no problems.

Then() treats nil as http.DefaultServeMux.

func (Chain) ThenFunc

func (c Chain) ThenFunc(fn http.HandlerFunc) http.Handler

ThenFunc works identically to Then, but takes a HandlerFunc instead of a Handler.

The following two statements are equivalent:

c.Then(http.HandlerFunc(fn))
c.ThenFunc(fn)

ThenFunc provides all the guarantees of Then.

type CheckFunction

type CheckFunction func(r *http.Request) bool

type Constructor

type Constructor func(http.Handler) http.Handler

A constructor for a piece of middleware. Some middleware use this constructor out of the box, so in most cases you can just pass `somepackage.New`