httptreemux: github.com/dimfeld/httptreemux Index | Files

package httptreemux

import "github.com/dimfeld/httptreemux"

This is inspired by Julien Schmidt's httprouter, in that it uses a patricia tree, but the implementation is rather different. Specifically, the routing rules are relaxed so that a single path segment may be a wildcard in one route and a static token in another. This gives a nice combination of high performance with a lot of convenience in designing the routing patterns.

Index

Package Files

context.go group.go panichandler.go path.go router.go tree.go treemux_17.go unescape_18.go

Constants

const (
    Redirect301 RedirectBehavior = iota // Return 301 Moved Permanently
    Redirect307                         // Return 307 HTTP/1.1 Temporary Redirect
    Redirect308                         // Return a 308 RFC7538 Permanent Redirect
    UseHandler                          // Just call the handler function

    RequestURI PathSource = iota // Use r.RequestURI
    URLPath                      // Use r.URL.Path
)

func AddParamsToContext Uses

func AddParamsToContext(ctx context.Context, params map[string]string) context.Context

AddParamsToContext inserts a parameters map into a context using the package's internal context key. Clients of this package should really only use this for unit tests.

func Clean Uses

func Clean(p string) string

Clean is the URL version of path.Clean, it returns a canonical URL path for p, eliminating . and .. elements.

The following rules are applied iteratively until no further processing can be done:

1. Replace multiple slashes with a single slash.
2. Eliminate each . path name element (the current directory).
3. Eliminate each inner .. path name element (the parent directory)
   along with the non-.. element that precedes it.
4. Eliminate .. elements that begin a rooted path:
   that is, replace "/.." by "/" at the beginning of a path.

If the result of this process is an empty string, "/" is returned

func ContextParams Uses

func ContextParams(ctx context.Context) map[string]string

ContextParams returns the params map associated with the given context if one exists. Otherwise, an empty map is returned.

func MethodNotAllowedHandler Uses

func MethodNotAllowedHandler(w http.ResponseWriter, r *http.Request,
    methods map[string]HandlerFunc)

MethodNotAllowedHandler is the default handler for TreeMux.MethodNotAllowedHandler, which is called for patterns that match, but do not have a handler installed for the requested method. It simply writes the status code http.StatusMethodNotAllowed and fills in the `Allow` header value appropriately.

func ShowErrorsJsonPanicHandler Uses

func ShowErrorsJsonPanicHandler(w http.ResponseWriter, r *http.Request, err interface{})

func ShowErrorsPanicHandler Uses

func ShowErrorsPanicHandler(w http.ResponseWriter, r *http.Request, err interface{})

ShowErrorsPanicHandler prints a nice representation of an error to the browser. This was taken from github.com/gocraft/web, which adapted it from the Traffic project.

func SimplePanicHandler Uses

func SimplePanicHandler(w http.ResponseWriter, r *http.Request, err interface{})

SimplePanicHandler just returns error 500.

type ContextGroup Uses

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

ContextGroup is a wrapper around Group, with the purpose of mimicking its API, but with the use of http.HandlerFunc-based handlers. Instead of passing a parameter map via the handler (i.e. httptreemux.HandlerFunc), the path parameters are accessed via the request object's context.

func (*ContextGroup) DELETE Uses

func (cg *ContextGroup) DELETE(path string, handler http.HandlerFunc)

DELETE is convenience method for handling DELETE requests on a context group.

func (*ContextGroup) GET Uses

func (cg *ContextGroup) GET(path string, handler http.HandlerFunc)

GET is convenience method for handling GET requests on a context group.

func (*ContextGroup) HEAD Uses

func (cg *ContextGroup) HEAD(path string, handler http.HandlerFunc)

HEAD is convenience method for handling HEAD requests on a context group.

func (*ContextGroup) Handle Uses

func (cg *ContextGroup) Handle(method, path string, handler http.HandlerFunc)

Handle allows handling HTTP requests via an http.HandlerFunc, as opposed to an httptreemux.HandlerFunc. Any parameters from the request URL are stored in a map[string]string in the request's context.

func (*ContextGroup) Handler Uses

func (cg *ContextGroup) Handler(method, path string, handler http.Handler)

Handler allows handling HTTP requests via an http.Handler interface, as opposed to an httptreemux.HandlerFunc. Any parameters from the request URL are stored in a map[string]string in the request's context.

func (*ContextGroup) NewContextGroup Uses

func (cg *ContextGroup) NewContextGroup(path string) *ContextGroup

NewContextGroup adds a child context group to its path.

func (*ContextGroup) NewGroup Uses

func (cg *ContextGroup) NewGroup(path string) *ContextGroup

func (*ContextGroup) OPTIONS Uses

func (cg *ContextGroup) OPTIONS(path string, handler http.HandlerFunc)

OPTIONS is convenience method for handling OPTIONS requests on a context group.

func (*ContextGroup) PATCH Uses

func (cg *ContextGroup) PATCH(path string, handler http.HandlerFunc)

PATCH is convenience method for handling PATCH requests on a context group.

func (*ContextGroup) POST Uses

func (cg *ContextGroup) POST(path string, handler http.HandlerFunc)

POST is convenience method for handling POST requests on a context group.

func (*ContextGroup) PUT Uses

func (cg *ContextGroup) PUT(path string, handler http.HandlerFunc)

PUT is convenience method for handling PUT requests on a context group.

type ContextMux Uses

type ContextMux struct {
    *TreeMux
    *ContextGroup
}

func NewContextMux Uses

func NewContextMux() *ContextMux

NewContextMux returns a TreeMux preconfigured to work with standard http Handler functions and context objects.

func (*ContextMux) DELETE Uses

func (cm *ContextMux) DELETE(path string, handler http.HandlerFunc)

DELETE is convenience method for handling DELETE requests on a context group.

func (*ContextMux) GET Uses

func (cm *ContextMux) GET(path string, handler http.HandlerFunc)

GET is convenience method for handling GET requests on a context group.

func (*ContextMux) HEAD Uses

func (cm *ContextMux) HEAD(path string, handler http.HandlerFunc)

HEAD is convenience method for handling HEAD requests on a context group.

func (*ContextMux) NewGroup Uses

func (cm *ContextMux) NewGroup(path string) *ContextGroup

func (*ContextMux) OPTIONS Uses

func (cm *ContextMux) OPTIONS(path string, handler http.HandlerFunc)

OPTIONS is convenience method for handling OPTIONS requests on a context group.

func (*ContextMux) PATCH Uses

func (cm *ContextMux) PATCH(path string, handler http.HandlerFunc)

PATCH is convenience method for handling PATCH requests on a context group.

func (*ContextMux) POST Uses

func (cm *ContextMux) POST(path string, handler http.HandlerFunc)

POST is convenience method for handling POST requests on a context group.

func (*ContextMux) PUT Uses

func (cm *ContextMux) PUT(path string, handler http.HandlerFunc)

PUT is convenience method for handling PUT requests on a context group.

type Group Uses

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

func (*Group) DELETE Uses

func (g *Group) DELETE(path string, handler HandlerFunc)

Syntactic sugar for Handle("DELETE", path, handler)

func (*Group) GET Uses

func (g *Group) GET(path string, handler HandlerFunc)

Syntactic sugar for Handle("GET", path, handler)

func (*Group) HEAD Uses

func (g *Group) HEAD(path string, handler HandlerFunc)

Syntactic sugar for Handle("HEAD", path, handler)

func (*Group) Handle Uses

func (g *Group) Handle(method string, path string, handler HandlerFunc)

Path elements starting with : indicate a wildcard in the path. A wildcard will only match on a single path segment. That is, the pattern `/post/:postid` will match on `/post/1` or `/post/1/`, but not `/post/1/2`.

A path element starting with * is a catch-all, whose value will be a string containing all text in the URL matched by the wildcards. For example, with a pattern of `/images/*path` and a requested URL `images/abc/def`, path would contain `abc/def`.

# Routing Rule Priority

The priority rules in the router are simple.

1. Static path segments take the highest priority. If a segment and its subtree are able to match the URL, that match is returned.

2. Wildcards take second priority. For a particular wildcard to match, that wildcard and its subtree must match the URL.

3. Finally, a catch-all rule will match when the earlier path segments have matched, and none of the static or wildcard conditions have matched. Catch-all rules must be at the end of a pattern.

So with the following patterns, we'll see certain matches:

router = httptreemux.New()
router.GET("/:page", pageHandler)
router.GET("/:year/:month/:post", postHandler)
router.GET("/:year/:month", archiveHandler)
router.GET("/images/*path", staticHandler)
router.GET("/favicon.ico", staticHandler)

/abc will match /:page
/2014/05 will match /:year/:month
/2014/05/really-great-blog-post will match /:year/:month/:post
/images/CoolImage.gif will match /images/*path
/images/2014/05/MayImage.jpg will also match /images/*path, with all the text after /images stored in the variable path.
/favicon.ico will match /favicon.ico

# Trailing Slashes

The router has special handling for paths with trailing slashes. If a pattern is added to the router with a trailing slash, any matches on that pattern without a trailing slash will be redirected to the version with the slash. If a pattern does not have a trailing slash, matches on that pattern with a trailing slash will be redirected to the version without.

The trailing slash flag is only stored once for a pattern. That is, if a pattern is added for a method with a trailing slash, all other methods for that pattern will also be considered to have a trailing slash, regardless of whether or not it is specified for those methods too.

This behavior can be turned off by setting TreeMux.RedirectTrailingSlash to false. By default it is set to true. The specifics of the redirect depend on RedirectBehavior.

One exception to this rule is catch-all patterns. By default, trailing slash redirection is disabled on catch-all patterns, since the structure of the entire URL and the desired patterns can not be predicted. If trailing slash removal is desired on catch-all patterns, set TreeMux.RemoveCatchAllTrailingSlash to true.

router = httptreemux.New()
router.GET("/about", pageHandler)
router.GET("/posts/", postIndexHandler)
router.POST("/posts", postFormHandler)

GET /about will match normally.
GET /about/ will redirect to /about.
GET /posts will redirect to /posts/.
GET /posts/ will match normally.
POST /posts will redirect to /posts/, because the GET method used a trailing slash.

func (*Group) NewGroup Uses

func (g *Group) NewGroup(path string) *Group

Add a sub-group to this group

func (*Group) OPTIONS Uses

func (g *Group) OPTIONS(path string, handler HandlerFunc)

Syntactic sugar for Handle("OPTIONS", path, handler)

func (*Group) PATCH Uses

func (g *Group) PATCH(path string, handler HandlerFunc)

Syntactic sugar for Handle("PATCH", path, handler)

func (*Group) POST Uses

func (g *Group) POST(path string, handler HandlerFunc)

Syntactic sugar for Handle("POST", path, handler)

func (*Group) PUT Uses

func (g *Group) PUT(path string, handler HandlerFunc)

Syntactic sugar for Handle("PUT", path, handler)

func (*Group) UsingContext Uses

func (g *Group) UsingContext() *ContextGroup

UsingContext wraps the receiver to return a new instance of a ContextGroup. The returned ContextGroup is a sibling to its wrapped Group, within the parent TreeMux. The choice of using a *Group as the receiver, as opposed to a function parameter, allows chaining while method calls between a TreeMux, Group, and ContextGroup. For example:

tree := httptreemux.New()
group := tree.NewGroup("/api")

group.GET("/v1", func(w http.ResponseWriter, r *http.Request, params map[string]string) {
    w.Write([]byte(`GET /api/v1`))
})

group.UsingContext().GET("/v2", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte(`GET /api/v2`))
})

http.ListenAndServe(":8080", tree)

type HandlerFunc Uses

type HandlerFunc func(http.ResponseWriter, *http.Request, map[string]string)

The params argument contains the parameters parsed from wildcards and catch-alls in the URL.

type LookupResult Uses

type LookupResult struct {
    // StatusCode informs the caller about the result of the lookup.
    // This will generally be `http.StatusNotFound` or `http.StatusMethodNotAllowed` for an
    // error case. On a normal success, the statusCode will be `http.StatusOK`. A redirect code
    // will also be used in the case
    StatusCode int
    // contains filtered or unexported fields
}

LookupResult contains information about a route lookup, which is returned from Lookup and can be passed to ServeLookupResult if the request should be served.

type PanicHandler Uses

type PanicHandler func(http.ResponseWriter, *http.Request, interface{})

type PathSource Uses

type PathSource int

type RedirectBehavior Uses

type RedirectBehavior int

RedirectBehavior sets the behavior when the router redirects the request to the canonical version of the requested URL using RedirectTrailingSlash or RedirectClean. The default behavior is to return a 301 status, redirecting the browser to the version of the URL that matches the given pattern.

On a POST request, most browsers that receive a 301 will submit a GET request to the redirected URL, meaning that any data will likely be lost. If you want to handle and avoid this behavior, you may use Redirect307, which causes most browsers to resubmit the request using the original method and request body.

Since 307 is supposed to be a temporary redirect, the new 308 status code has been proposed, which is treated the same, except it indicates correctly that the redirection is permanent. The big caveat here is that the RFC is relatively recent, and older browsers will not know what to do with it. Therefore its use is not recommended unless you really know what you're doing.

Finally, the UseHandler value will simply call the handler function for the pattern.

type TreeMux Uses

type TreeMux struct {
    Group

    // The default PanicHandler just returns a 500 code.
    PanicHandler PanicHandler

    // The default NotFoundHandler is http.NotFound.
    NotFoundHandler func(w http.ResponseWriter, r *http.Request)

    // Any OPTIONS request that matches a path without its own OPTIONS handler will use this handler,
    // if set, instead of calling MethodNotAllowedHandler.
    OptionsHandler HandlerFunc

    // MethodNotAllowedHandler is called when a pattern matches, but that
    // pattern does not have a handler for the requested method. The default
    // handler just writes the status code http.StatusMethodNotAllowed and adds
    // the required Allowed header.
    // The methods parameter contains the map of each method to the corresponding
    // handler function.
    MethodNotAllowedHandler func(w http.ResponseWriter, r *http.Request,
        methods map[string]HandlerFunc)

    // HeadCanUseGet allows the router to use the GET handler to respond to
    // HEAD requests if no explicit HEAD handler has been added for the
    // matching pattern. This is true by default.
    HeadCanUseGet bool

    // RedirectCleanPath allows the router to try clean the current request path,
    // if no handler is registered for it, using CleanPath from github.com/dimfeld/httppath.
    // This is true by default.
    RedirectCleanPath bool

    // RedirectTrailingSlash enables automatic redirection in case router doesn't find a matching route
    // for the current request path but a handler for the path with or without the trailing
    // slash exists. This is true by default.
    RedirectTrailingSlash bool

    // RemoveCatchAllTrailingSlash removes the trailing slash when a catch-all pattern
    // is matched, if set to true. By default, catch-all paths are never redirected.
    RemoveCatchAllTrailingSlash bool

    // RedirectBehavior sets the default redirect behavior when RedirectTrailingSlash or
    // RedirectCleanPath are true. The default value is Redirect301.
    RedirectBehavior RedirectBehavior

    // RedirectMethodBehavior overrides the default behavior for a particular HTTP method.
    // The key is the method name, and the value is the behavior to use for that method.
    RedirectMethodBehavior map[string]RedirectBehavior

    // PathSource determines from where the router gets its path to search.
    // By default it pulls the data from the RequestURI member, but this can
    // be overridden to use URL.Path instead.
    //
    // There is a small tradeoff here. Using RequestURI allows the router to handle
    // encoded slashes (i.e. %2f) in the URL properly, while URL.Path provides
    // better compatibility with some utility functions in the http
    // library that modify the Request before passing it to the router.
    PathSource PathSource

    // EscapeAddedRoutes controls URI escaping behavior when adding a route to the tree.
    // If set to true, the router will add both the route as originally passed, and
    // a version passed through URL.EscapedPath. This behavior is disabled by default.
    EscapeAddedRoutes bool

    // If present, override the default context with this one.
    DefaultContext context.Context

    // SafeAddRoutesWhileRunning tells the router to protect all accesses to the tree with an RWMutex. This is only needed
    // if you are going to add routes after the router has already begun serving requests. There is a potential
    // performance penalty at high load.
    SafeAddRoutesWhileRunning bool
    // contains filtered or unexported fields
}

func New Uses

func New() *TreeMux

func (*TreeMux) Dump Uses

func (t *TreeMux) Dump() string

Dump returns a text representation of the routing tree.

func (*TreeMux) Lookup Uses

func (t *TreeMux) Lookup(w http.ResponseWriter, r *http.Request) (LookupResult, bool)

Lookup performs a lookup without actually serving the request or mutating the request or response. The return values are a LookupResult and a boolean. The boolean will be true when a handler was found or the lookup resulted in a redirect which will point to a real handler. It is false for requests which would result in a `StatusNotFound` or `StatusMethodNotAllowed`.

Regardless of the returned boolean's value, the LookupResult may be passed to ServeLookupResult to be served appropriately.

func (*TreeMux) ServeHTTP Uses

func (t *TreeMux) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*TreeMux) ServeLookupResult Uses

func (t *TreeMux) ServeLookupResult(w http.ResponseWriter, r *http.Request, lr LookupResult)

ServeLookupResult serves a request, given a lookup result from the Lookup function.

Package httptreemux imports 11 packages (graph) and is imported by 145 packages. Updated 2018-09-15. Refresh now. Tools for package owners.