You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
213 lines
7.3 KiB
213 lines
7.3 KiB
package web
|
|
|
|
import (
|
|
"net/http"
|
|
)
|
|
|
|
/*
|
|
Mux is an HTTP multiplexer, much like net/http's ServeMux. It functions as both
|
|
a middleware stack and as an HTTP router.
|
|
|
|
Middleware provide a great abstraction for actions that must be performed on
|
|
every request, such as request logging and authentication. To append, insert,
|
|
and remove middleware, you can call the Use, Insert, and Abandon functions
|
|
respectively.
|
|
|
|
Routes may be added using any of the HTTP verb functions (Get, Post, etc.), or
|
|
through the generic Handle function. Goji's routing algorithm is very simple:
|
|
routes are processed in the order they are added, and the first matching route
|
|
will be executed. Routes match if their HTTP method and Pattern both match.
|
|
*/
|
|
type Mux struct {
|
|
ms mStack
|
|
rt router
|
|
}
|
|
|
|
// New creates a new Mux without any routes or middleware.
|
|
func New() *Mux {
|
|
mux := Mux{
|
|
ms: mStack{
|
|
stack: make([]mLayer, 0),
|
|
pool: makeCPool(),
|
|
},
|
|
rt: router{
|
|
routes: make([]route, 0),
|
|
notFound: parseHandler(http.NotFound),
|
|
},
|
|
}
|
|
mux.ms.router = &mux.rt
|
|
return &mux
|
|
}
|
|
|
|
// ServeHTTP processes HTTP requests. Satisfies net/http.Handler.
|
|
func (m *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
stack := m.ms.alloc()
|
|
stack.ServeHTTP(w, r)
|
|
m.ms.release(stack)
|
|
}
|
|
|
|
// ServeHTTPC creates a context dependent request with the given Mux. Satisfies
|
|
// the Handler interface.
|
|
func (m *Mux) ServeHTTPC(c C, w http.ResponseWriter, r *http.Request) {
|
|
stack := m.ms.alloc()
|
|
stack.ServeHTTPC(c, w, r)
|
|
m.ms.release(stack)
|
|
}
|
|
|
|
// Middleware Stack functions
|
|
|
|
// Use appends the given middleware to the middleware stack.
|
|
//
|
|
// No attempt is made to enforce the uniqueness of middlewares. It is illegal to
|
|
// call this function concurrently with active requests.
|
|
func (m *Mux) Use(middleware MiddlewareType) {
|
|
m.ms.Use(middleware)
|
|
}
|
|
|
|
// Insert inserts the given middleware immediately before a given existing
|
|
// middleware in the stack. Returns an error if "before" cannot be found in the
|
|
// current stack.
|
|
//
|
|
// No attempt is made to enforce the uniqueness of middlewares. If the insertion
|
|
// point is ambiguous, the first (outermost) one is chosen. It is illegal to
|
|
// call this function concurrently with active requests.
|
|
func (m *Mux) Insert(middleware, before MiddlewareType) error {
|
|
return m.ms.Insert(middleware, before)
|
|
}
|
|
|
|
// Abandon removes the given middleware from the middleware stack. Returns an
|
|
// error if no such middleware can be found.
|
|
//
|
|
// If the name of the middleware to delete is ambiguous, the first (outermost)
|
|
// one is chosen. It is illegal to call this function concurrently with active
|
|
// requests.
|
|
func (m *Mux) Abandon(middleware MiddlewareType) error {
|
|
return m.ms.Abandon(middleware)
|
|
}
|
|
|
|
// Router functions
|
|
|
|
type routerMiddleware struct {
|
|
m *Mux
|
|
c *C
|
|
h http.Handler
|
|
}
|
|
|
|
func (rm routerMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
if rm.c.Env == nil {
|
|
rm.c.Env = make(map[interface{}]interface{}, 1)
|
|
}
|
|
rm.c.Env[MatchKey] = rm.m.rt.getMatch(rm.c, w, r)
|
|
rm.h.ServeHTTP(w, r)
|
|
}
|
|
|
|
/*
|
|
Router is a middleware that performs routing and stores the resulting Match in
|
|
Goji's environment. If a routing Match is present at the end of the middleware
|
|
stack, that Match is used instead of re-routing.
|
|
|
|
This middleware is especially useful to create post-routing middleware, e.g. a
|
|
request logger which prints which pattern or handler was selected, or an
|
|
authentication middleware which only applies to certain routes.
|
|
|
|
If you use nested Muxes with explicit routing, you should be aware that the
|
|
explicit routing information set by an outer Mux can be picked up by an inner
|
|
Mux, inadvertently causing an infinite routing loop. If you use both explicit
|
|
routing and nested Muxes, you should be sure to unset MatchKey before the inner
|
|
Mux performs routing (or attach a Router to the inner Mux as well).
|
|
*/
|
|
func (m *Mux) Router(c *C, h http.Handler) http.Handler {
|
|
return routerMiddleware{m, c, h}
|
|
}
|
|
|
|
/*
|
|
Handle dispatches to the given handler when the pattern matches, regardless of
|
|
HTTP method.
|
|
|
|
This method is commonly used to implement sub-routing: an admin application, for
|
|
instance, can expose a single handler that is attached to the main Mux by
|
|
calling Handle("/admin/*", adminHandler) or similar. Note that this function
|
|
doesn't strip this prefix from the path before forwarding it on (e.g., the
|
|
handler will see the full path, including the "/admin/" part), but this
|
|
functionality can easily be performed by an extra middleware layer.
|
|
*/
|
|
func (m *Mux) Handle(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mALL, handler)
|
|
}
|
|
|
|
// Connect dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is CONNECT.
|
|
func (m *Mux) Connect(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mCONNECT, handler)
|
|
}
|
|
|
|
// Delete dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is DELETE.
|
|
func (m *Mux) Delete(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mDELETE, handler)
|
|
}
|
|
|
|
// Get dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is GET.
|
|
//
|
|
// All GET handlers also transparently serve HEAD requests, since net/http will
|
|
// take care of all the fiddly bits for you. If you wish to provide an alternate
|
|
// implementation of HEAD, you should add a handler explicitly and place it
|
|
// above your GET handler.
|
|
func (m *Mux) Get(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mGET|mHEAD, handler)
|
|
}
|
|
|
|
// Head dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is HEAD.
|
|
func (m *Mux) Head(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mHEAD, handler)
|
|
}
|
|
|
|
// Options dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is OPTIONS.
|
|
func (m *Mux) Options(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mOPTIONS, handler)
|
|
}
|
|
|
|
// Patch dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is PATCH.
|
|
func (m *Mux) Patch(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mPATCH, handler)
|
|
}
|
|
|
|
// Post dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is POST.
|
|
func (m *Mux) Post(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mPOST, handler)
|
|
}
|
|
|
|
// Put dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is PUT.
|
|
func (m *Mux) Put(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mPUT, handler)
|
|
}
|
|
|
|
// Trace dispatches to the given handler when the pattern matches and the HTTP
|
|
// method is TRACE.
|
|
func (m *Mux) Trace(pattern PatternType, handler HandlerType) {
|
|
m.rt.handleUntyped(pattern, mTRACE, handler)
|
|
}
|
|
|
|
// NotFound sets the fallback (i.e., 404) handler for this mux.
|
|
//
|
|
// As a convenience, the context environment variable "goji.web.validMethods"
|
|
// (also available as the constant ValidMethodsKey) will be set to the list of
|
|
// HTTP methods that could have been routed had they been provided on an
|
|
// otherwise identical request.
|
|
func (m *Mux) NotFound(handler HandlerType) {
|
|
m.rt.notFound = parseHandler(handler)
|
|
}
|
|
|
|
// Compile compiles the list of routes into bytecode. This only needs to be done
|
|
// once after all the routes have been added, and will be called automatically
|
|
// for you (at some performance cost on the first request) if you do not call it
|
|
// explicitly.
|
|
func (m *Mux) Compile() {
|
|
m.rt.compile()
|
|
}
|