goji

func (HandlerFunc) ServeHTTP ¶

func (h HandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements net/http.Handler. It calls the underlying function with a context of context.TODO in order to ease the conversion of non-context-aware Handlers to context-aware ones using static analysis.

func (HandlerFunc) ServeHTTPC ¶

func (h HandlerFunc) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request)

ServeHTTPC implements Handler.

func (*Mux) Handle ¶

func (m *Mux) Handle(p Pattern, h http.Handler)

Handle adds a new route to the Mux. Requests that match the given Pattern will be dispatched to the given http.Handler. If the http.Handler also supports Handler, that interface will be used instead.

Routing is performed in the order in which routes are added: the first route with a matching Pattern will be used. In particular, Goji guarantees that routing is performed in a manner that is indistinguishable from the following algorithm:

// Assume routes is a slice that every call to Handle appends to
for route := range routes {
	// For performance, Patterns can opt out of this call to Match.
	// See the documentation for Pattern for more.
	if ctx2 := route.pattern.Match(ctx, r); ctx2 != nil {
		route.handler.ServeHTTPC(ctx2, w, r)
		break
	}
}

It is not safe to concurrently register routes from multiple goroutines.

func (*Mux) HandleC ¶

func (m *Mux) HandleC(p Pattern, h Handler)

HandleC adds a new context-aware route to the Mux. See the documentation for Handle for more information about the semantics of routing.

It is not safe to concurrently register routes from multiple goroutines.

func (*Mux) HandleFunc ¶

func (m *Mux) HandleFunc(p Pattern, h func(http.ResponseWriter, *http.Request))

HandleFunc adds a new route to the Mux. It is equivalent to calling Handle on a handler wrapped with http.HandlerFunc, and is provided only for convenience.

func (*Mux) HandleFuncC ¶

func (m *Mux) HandleFuncC(p Pattern, h func(context.Context, http.ResponseWriter, *http.Request))

HandleFuncC adds a new context-aware route to the Mux. It is equivalent to calling HandleC on a handler wrapped with HandlerFunc, and is provided for convenience.

func (*Mux) ServeHTTP ¶

func (m *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements net/http.Handler. It uses context.TODO as the root context in order to ease the conversion of non-context-aware Handlers to context-aware ones using static analysis.

Users who know that their mux sits at the top of the request hierarchy should consider creating a small helper http.Handler that calls this Mux's ServeHTTPC function with context.Background.

func (*Mux) ServeHTTPC ¶

func (m *Mux) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request)

ServeHTTPC implements Handler.

func (*Mux) Use ¶

func (m *Mux) Use(middleware func(http.Handler) http.Handler)

Use appends a middleware to the Mux's middleware stack.

Middleware are composable pieces of functionality that augment Handlers. Common examples of middleware include request loggers, authentication checkers, and metrics gatherers.

Middleware are evaluated in the reverse order in which they were added, but the resulting Handlers execute in "normal" order (i.e., the Handler returned by the first Middleware to be added gets called first).

For instance, given middleware A, B, and C, added in that order, Goji's behavior will look something like this:

augmentedHandler := A(B(C(yourHandler)))
augmentedHandler.ServeHTTPC(ctx, w, r)

Assuming each of A, B, and C look something like this:

func A(inner goji.Handler) goji.Handler {
	log.Print("A: called")
	mw := func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
		log.Print("A: before")
		inner.ServeHTTPC(ctx, w, r)
		log.Print("A: after")
	}
	return goji.HandlerFunc(mw)
}

we'd expect to see the following in the log:

C: called
B: called
A: called
---
A: before
B: before
C: before
yourHandler: called
C: after
B: after
A: after

Note that augmentedHandler may be called many times. Put another way, you will see many invocations of the portion of the log below the divider, and perhaps only see the portion above the divider a single time. Also note that as an implementation detail, net/http-style middleware will be called once per request, even though the Goji-style middleware around them might only ever be called a single time.

Middleware in Goji is called after routing has been performed. Therefore it is possible to examine any routing information placed into the context by Patterns, or to view or modify the Handler that will be routed to.

The http.Handler returned by the given middleware must be safe for concurrent use by multiple goroutines. It is not safe to concurrently register middleware from multiple goroutines.

func (*Mux) UseC ¶

func (m *Mux) UseC(middleware func(Handler) Handler)

UseC appends a context-aware middleware to the Mux's middleware stack. See the documentation for Use for more information about the semantics of middleware.

The Handler returned by the given middleware must be safe for concurrent use by multiple goroutines. It is not safe to concurrently register middleware from multiple goroutines.