mirror of https://github.com/fatedier/frp
fatedier
7 years ago
43 changed files with 5104 additions and 3237 deletions
@ -1 +1 @@
|
||||
<!DOCTYPE html> <html lang=en> <head> <meta charset=utf-8> <title>frps dashboard</title> <link rel="shortcut icon" href="favicon.ico"></head> <body> <div id=app></div> <script type="text/javascript" src="manifest.js?b90a32ccfb87def61aaa"></script><script type="text/javascript" src="vendor.js?f04985ef00f520142368"></script></body> </html> |
||||
<!DOCTYPE html> <html lang=en> <head> <meta charset=utf-8> <title>frps dashboard</title> <link rel="shortcut icon" href="favicon.ico"></head> <body> <div id=app></div> <script type="text/javascript" src="manifest.js?bc42bc4eff72df8da372"></script><script type="text/javascript" src="vendor.js?ee403fce53c8757fc931"></script></body> </html> |
||||
@ -1 +1 @@
|
||||
!function(e){function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}var r=window.webpackJsonp;window.webpackJsonp=function(t,u,c){for(var i,a,f,l=0,s=[];l<t.length;l++)a=t[l],o[a]&&s.push(o[a][0]),o[a]=0;for(i in u)Object.prototype.hasOwnProperty.call(u,i)&&(e[i]=u[i]);for(r&&r(t,u,c);s.length;)s.shift()();if(c)for(l=0;l<c.length;l++)f=n(n.s=c[l]);return f};var t={},o={1:0};n.e=function(e){function r(){i.onerror=i.onload=null,clearTimeout(a);var n=o[e];0!==n&&(n&&n[1](new Error("Loading chunk "+e+" failed.")),o[e]=void 0)}var t=o[e];if(0===t)return new Promise(function(e){e()});if(t)return t[2];var u=new Promise(function(n,r){t=o[e]=[n,r]});t[2]=u;var c=document.getElementsByTagName("head")[0],i=document.createElement("script");i.type="text/javascript",i.charset="utf-8",i.async=!0,i.timeout=12e4,n.nc&&i.setAttribute("nonce",n.nc),i.src=n.p+""+e+".js?"+{0:"f04985ef00f520142368"}[e];var a=setTimeout(r,12e4);return i.onerror=i.onload=r,c.appendChild(i),u},n.m=e,n.c=t,n.i=function(e){return e},n.d=function(e,r,t){n.o(e,r)||Object.defineProperty(e,r,{configurable:!1,enumerable:!0,get:t})},n.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(r,"a",r),r},n.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},n.p="",n.oe=function(e){throw console.error(e),e}}([]); |
||||
!function(e){function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}var r=window.webpackJsonp;window.webpackJsonp=function(t,c,u){for(var i,a,f,l=0,s=[];l<t.length;l++)a=t[l],o[a]&&s.push(o[a][0]),o[a]=0;for(i in c)Object.prototype.hasOwnProperty.call(c,i)&&(e[i]=c[i]);for(r&&r(t,c,u);s.length;)s.shift()();if(u)for(l=0;l<u.length;l++)f=n(n.s=u[l]);return f};var t={},o={1:0};n.e=function(e){function r(){i.onerror=i.onload=null,clearTimeout(a);var n=o[e];0!==n&&(n&&n[1](new Error("Loading chunk "+e+" failed.")),o[e]=void 0)}var t=o[e];if(0===t)return new Promise(function(e){e()});if(t)return t[2];var c=new Promise(function(n,r){t=o[e]=[n,r]});t[2]=c;var u=document.getElementsByTagName("head")[0],i=document.createElement("script");i.type="text/javascript",i.charset="utf-8",i.async=!0,i.timeout=12e4,n.nc&&i.setAttribute("nonce",n.nc),i.src=n.p+""+e+".js?"+{0:"ee403fce53c8757fc931"}[e];var a=setTimeout(r,12e4);return i.onerror=i.onload=r,u.appendChild(i),c},n.m=e,n.c=t,n.i=function(e){return e},n.d=function(e,r,t){n.o(e,r)||Object.defineProperty(e,r,{configurable:!1,enumerable:!0,get:t})},n.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(r,"a",r),r},n.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},n.p="",n.oe=function(e){throw console.error(e),e}}([]); |
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,19 @@
|
||||
language: go |
||||
sudo: false |
||||
|
||||
matrix: |
||||
include: |
||||
- go: 1.3 |
||||
- go: 1.4 |
||||
- go: 1.5 |
||||
- go: 1.6 |
||||
- go: 1.7 |
||||
- go: tip |
||||
allow_failures: |
||||
- go: tip |
||||
|
||||
script: |
||||
- go get -t -v ./... |
||||
- diff -u <(echo -n) <(gofmt -d .) |
||||
- go vet $(go list ./... | grep -v /vendor/) |
||||
- go test -v -race ./... |
||||
@ -0,0 +1,27 @@
|
||||
Copyright (c) 2012 Rodrigo Moraes. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,10 @@
|
||||
context |
||||
======= |
||||
[](https://travis-ci.org/gorilla/context) |
||||
|
||||
gorilla/context is a general purpose registry for global request variables. |
||||
|
||||
> Note: gorilla/context, having been born well before `context.Context` existed, does not play well |
||||
> with the shallow copying of the request that [`http.Request.WithContext`](https://golang.org/pkg/net/http/#Request.WithContext) (added to net/http Go 1.7 onwards) performs. You should either use *just* gorilla/context, or moving forward, the new `http.Request.Context()`. |
||||
|
||||
Read the full documentation here: http://www.gorillatoolkit.org/pkg/context |
||||
@ -0,0 +1,143 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package context |
||||
|
||||
import ( |
||||
"net/http" |
||||
"sync" |
||||
"time" |
||||
) |
||||
|
||||
var ( |
||||
mutex sync.RWMutex |
||||
data = make(map[*http.Request]map[interface{}]interface{}) |
||||
datat = make(map[*http.Request]int64) |
||||
) |
||||
|
||||
// Set stores a value for a given key in a given request.
|
||||
func Set(r *http.Request, key, val interface{}) { |
||||
mutex.Lock() |
||||
if data[r] == nil { |
||||
data[r] = make(map[interface{}]interface{}) |
||||
datat[r] = time.Now().Unix() |
||||
} |
||||
data[r][key] = val |
||||
mutex.Unlock() |
||||
} |
||||
|
||||
// Get returns a value stored for a given key in a given request.
|
||||
func Get(r *http.Request, key interface{}) interface{} { |
||||
mutex.RLock() |
||||
if ctx := data[r]; ctx != nil { |
||||
value := ctx[key] |
||||
mutex.RUnlock() |
||||
return value |
||||
} |
||||
mutex.RUnlock() |
||||
return nil |
||||
} |
||||
|
||||
// GetOk returns stored value and presence state like multi-value return of map access.
|
||||
func GetOk(r *http.Request, key interface{}) (interface{}, bool) { |
||||
mutex.RLock() |
||||
if _, ok := data[r]; ok { |
||||
value, ok := data[r][key] |
||||
mutex.RUnlock() |
||||
return value, ok |
||||
} |
||||
mutex.RUnlock() |
||||
return nil, false |
||||
} |
||||
|
||||
// GetAll returns all stored values for the request as a map. Nil is returned for invalid requests.
|
||||
func GetAll(r *http.Request) map[interface{}]interface{} { |
||||
mutex.RLock() |
||||
if context, ok := data[r]; ok { |
||||
result := make(map[interface{}]interface{}, len(context)) |
||||
for k, v := range context { |
||||
result[k] = v |
||||
} |
||||
mutex.RUnlock() |
||||
return result |
||||
} |
||||
mutex.RUnlock() |
||||
return nil |
||||
} |
||||
|
||||
// GetAllOk returns all stored values for the request as a map and a boolean value that indicates if
|
||||
// the request was registered.
|
||||
func GetAllOk(r *http.Request) (map[interface{}]interface{}, bool) { |
||||
mutex.RLock() |
||||
context, ok := data[r] |
||||
result := make(map[interface{}]interface{}, len(context)) |
||||
for k, v := range context { |
||||
result[k] = v |
||||
} |
||||
mutex.RUnlock() |
||||
return result, ok |
||||
} |
||||
|
||||
// Delete removes a value stored for a given key in a given request.
|
||||
func Delete(r *http.Request, key interface{}) { |
||||
mutex.Lock() |
||||
if data[r] != nil { |
||||
delete(data[r], key) |
||||
} |
||||
mutex.Unlock() |
||||
} |
||||
|
||||
// Clear removes all values stored for a given request.
|
||||
//
|
||||
// This is usually called by a handler wrapper to clean up request
|
||||
// variables at the end of a request lifetime. See ClearHandler().
|
||||
func Clear(r *http.Request) { |
||||
mutex.Lock() |
||||
clear(r) |
||||
mutex.Unlock() |
||||
} |
||||
|
||||
// clear is Clear without the lock.
|
||||
func clear(r *http.Request) { |
||||
delete(data, r) |
||||
delete(datat, r) |
||||
} |
||||
|
||||
// Purge removes request data stored for longer than maxAge, in seconds.
|
||||
// It returns the amount of requests removed.
|
||||
//
|
||||
// If maxAge <= 0, all request data is removed.
|
||||
//
|
||||
// This is only used for sanity check: in case context cleaning was not
|
||||
// properly set some request data can be kept forever, consuming an increasing
|
||||
// amount of memory. In case this is detected, Purge() must be called
|
||||
// periodically until the problem is fixed.
|
||||
func Purge(maxAge int) int { |
||||
mutex.Lock() |
||||
count := 0 |
||||
if maxAge <= 0 { |
||||
count = len(data) |
||||
data = make(map[*http.Request]map[interface{}]interface{}) |
||||
datat = make(map[*http.Request]int64) |
||||
} else { |
||||
min := time.Now().Unix() - int64(maxAge) |
||||
for r := range data { |
||||
if datat[r] < min { |
||||
clear(r) |
||||
count++ |
||||
} |
||||
} |
||||
} |
||||
mutex.Unlock() |
||||
return count |
||||
} |
||||
|
||||
// ClearHandler wraps an http.Handler and clears request values at the end
|
||||
// of a request lifetime.
|
||||
func ClearHandler(h http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
defer Clear(r) |
||||
h.ServeHTTP(w, r) |
||||
}) |
||||
} |
||||
@ -0,0 +1,88 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package context stores values shared during a request lifetime. |
||||
|
||||
Note: gorilla/context, having been born well before `context.Context` existed, |
||||
does not play well > with the shallow copying of the request that |
||||
[`http.Request.WithContext`](https://golang.org/pkg/net/http/#Request.WithContext)
|
||||
(added to net/http Go 1.7 onwards) performs. You should either use *just* |
||||
gorilla/context, or moving forward, the new `http.Request.Context()`. |
||||
|
||||
For example, a router can set variables extracted from the URL and later |
||||
application handlers can access those values, or it can be used to store |
||||
sessions values to be saved at the end of a request. There are several |
||||
others common uses. |
||||
|
||||
The idea was posted by Brad Fitzpatrick to the go-nuts mailing list: |
||||
|
||||
http://groups.google.com/group/golang-nuts/msg/e2d679d303aa5d53
|
||||
|
||||
Here's the basic usage: first define the keys that you will need. The key |
||||
type is interface{} so a key can be of any type that supports equality. |
||||
Here we define a key using a custom int type to avoid name collisions: |
||||
|
||||
package foo |
||||
|
||||
import ( |
||||
"github.com/gorilla/context" |
||||
) |
||||
|
||||
type key int |
||||
|
||||
const MyKey key = 0 |
||||
|
||||
Then set a variable. Variables are bound to an http.Request object, so you |
||||
need a request instance to set a value: |
||||
|
||||
context.Set(r, MyKey, "bar") |
||||
|
||||
The application can later access the variable using the same key you provided: |
||||
|
||||
func MyHandler(w http.ResponseWriter, r *http.Request) { |
||||
// val is "bar".
|
||||
val := context.Get(r, foo.MyKey) |
||||
|
||||
// returns ("bar", true)
|
||||
val, ok := context.GetOk(r, foo.MyKey) |
||||
// ...
|
||||
} |
||||
|
||||
And that's all about the basic usage. We discuss some other ideas below. |
||||
|
||||
Any type can be stored in the context. To enforce a given type, make the key |
||||
private and wrap Get() and Set() to accept and return values of a specific |
||||
type: |
||||
|
||||
type key int |
||||
|
||||
const mykey key = 0 |
||||
|
||||
// GetMyKey returns a value for this package from the request values.
|
||||
func GetMyKey(r *http.Request) SomeType { |
||||
if rv := context.Get(r, mykey); rv != nil { |
||||
return rv.(SomeType) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// SetMyKey sets a value for this package in the request values.
|
||||
func SetMyKey(r *http.Request, val SomeType) { |
||||
context.Set(r, mykey, val) |
||||
} |
||||
|
||||
Variables must be cleared at the end of a request, to remove all values |
||||
that were stored. This can be done in an http.Handler, after a request was |
||||
served. Just call Clear() passing the request: |
||||
|
||||
context.Clear(r) |
||||
|
||||
...or use ClearHandler(), which conveniently wraps an http.Handler to clear |
||||
variables at the end of a request lifetime. |
||||
|
||||
The Routers from the packages gorilla/mux and gorilla/pat call Clear() |
||||
so if you are using either of them you don't need to clear the context manually. |
||||
*/ |
||||
package context |
||||
@ -0,0 +1,23 @@
|
||||
language: go |
||||
sudo: false |
||||
|
||||
matrix: |
||||
include: |
||||
- go: 1.5.x |
||||
- go: 1.6.x |
||||
- go: 1.7.x |
||||
- go: 1.8.x |
||||
- go: 1.9.x |
||||
- go: 1.10.x |
||||
- go: tip |
||||
allow_failures: |
||||
- go: tip |
||||
|
||||
install: |
||||
- # Skip |
||||
|
||||
script: |
||||
- go get -t -v ./... |
||||
- diff -u <(echo -n) <(gofmt -d .) |
||||
- go tool vet . |
||||
- go test -v -race ./... |
||||
@ -0,0 +1,11 @@
|
||||
**What version of Go are you running?** (Paste the output of `go version`) |
||||
|
||||
|
||||
**What version of gorilla/mux are you at?** (Paste the output of `git rev-parse HEAD` inside `$GOPATH/src/github.com/gorilla/mux`) |
||||
|
||||
|
||||
**Describe your problem** (and what you have tried so far) |
||||
|
||||
|
||||
**Paste a minimal, runnable, reproduction of your issue below** (use backticks to format it) |
||||
|
||||
@ -0,0 +1,27 @@
|
||||
Copyright (c) 2012 Rodrigo Moraes. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,649 @@
|
||||
# gorilla/mux |
||||
|
||||
[](https://godoc.org/github.com/gorilla/mux) |
||||
[](https://travis-ci.org/gorilla/mux) |
||||
[](https://sourcegraph.com/github.com/gorilla/mux?badge) |
||||
|
||||
 |
||||
|
||||
http://www.gorillatoolkit.org/pkg/mux |
||||
|
||||
Package `gorilla/mux` implements a request router and dispatcher for matching incoming requests to |
||||
their respective handler. |
||||
|
||||
The name mux stands for "HTTP request multiplexer". Like the standard `http.ServeMux`, `mux.Router` matches incoming requests against a list of registered routes and calls a handler for the route that matches the URL or other conditions. The main features are: |
||||
|
||||
* It implements the `http.Handler` interface so it is compatible with the standard `http.ServeMux`. |
||||
* Requests can be matched based on URL host, path, path prefix, schemes, header and query values, HTTP methods or using custom matchers. |
||||
* URL hosts, paths and query values can have variables with an optional regular expression. |
||||
* Registered URLs can be built, or "reversed", which helps maintaining references to resources. |
||||
* Routes can be used as subrouters: nested routes are only tested if the parent route matches. This is useful to define groups of routes that share common conditions like a host, a path prefix or other repeated attributes. As a bonus, this optimizes request matching. |
||||
|
||||
--- |
||||
|
||||
* [Install](#install) |
||||
* [Examples](#examples) |
||||
* [Matching Routes](#matching-routes) |
||||
* [Static Files](#static-files) |
||||
* [Registered URLs](#registered-urls) |
||||
* [Walking Routes](#walking-routes) |
||||
* [Graceful Shutdown](#graceful-shutdown) |
||||
* [Middleware](#middleware) |
||||
* [Testing Handlers](#testing-handlers) |
||||
* [Full Example](#full-example) |
||||
|
||||
--- |
||||
|
||||
## Install |
||||
|
||||
With a [correctly configured](https://golang.org/doc/install#testing) Go toolchain: |
||||
|
||||
```sh |
||||
go get -u github.com/gorilla/mux |
||||
``` |
||||
|
||||
## Examples |
||||
|
||||
Let's start registering a couple of URL paths and handlers: |
||||
|
||||
```go |
||||
func main() { |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", HomeHandler) |
||||
r.HandleFunc("/products", ProductsHandler) |
||||
r.HandleFunc("/articles", ArticlesHandler) |
||||
http.Handle("/", r) |
||||
} |
||||
``` |
||||
|
||||
Here we register three routes mapping URL paths to handlers. This is equivalent to how `http.HandleFunc()` works: if an incoming request URL matches one of the paths, the corresponding handler is called passing (`http.ResponseWriter`, `*http.Request`) as parameters. |
||||
|
||||
Paths can have variables. They are defined using the format `{name}` or `{name:pattern}`. If a regular expression pattern is not defined, the matched variable will be anything until the next slash. For example: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/products/{key}", ProductHandler) |
||||
r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler) |
||||
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler) |
||||
``` |
||||
|
||||
The names are used to create a map of route variables which can be retrieved calling `mux.Vars()`: |
||||
|
||||
```go |
||||
func ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) { |
||||
vars := mux.Vars(r) |
||||
w.WriteHeader(http.StatusOK) |
||||
fmt.Fprintf(w, "Category: %v\n", vars["category"]) |
||||
} |
||||
``` |
||||
|
||||
And this is all you need to know about the basic usage. More advanced options are explained below. |
||||
|
||||
### Matching Routes |
||||
|
||||
Routes can also be restricted to a domain or subdomain. Just define a host pattern to be matched. They can also have variables: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
// Only matches if domain is "www.example.com". |
||||
r.Host("www.example.com") |
||||
// Matches a dynamic subdomain. |
||||
r.Host("{subdomain:[a-z]+}.domain.com") |
||||
``` |
||||
|
||||
There are several other matchers that can be added. To match path prefixes: |
||||
|
||||
```go |
||||
r.PathPrefix("/products/") |
||||
``` |
||||
|
||||
...or HTTP methods: |
||||
|
||||
```go |
||||
r.Methods("GET", "POST") |
||||
``` |
||||
|
||||
...or URL schemes: |
||||
|
||||
```go |
||||
r.Schemes("https") |
||||
``` |
||||
|
||||
...or header values: |
||||
|
||||
```go |
||||
r.Headers("X-Requested-With", "XMLHttpRequest") |
||||
``` |
||||
|
||||
...or query values: |
||||
|
||||
```go |
||||
r.Queries("key", "value") |
||||
``` |
||||
|
||||
...or to use a custom matcher function: |
||||
|
||||
```go |
||||
r.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool { |
||||
return r.ProtoMajor == 0 |
||||
}) |
||||
``` |
||||
|
||||
...and finally, it is possible to combine several matchers in a single route: |
||||
|
||||
```go |
||||
r.HandleFunc("/products", ProductsHandler). |
||||
Host("www.example.com"). |
||||
Methods("GET"). |
||||
Schemes("http") |
||||
``` |
||||
|
||||
Routes are tested in the order they were added to the router. If two routes match, the first one wins: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/specific", specificHandler) |
||||
r.PathPrefix("/").Handler(catchAllHandler) |
||||
``` |
||||
|
||||
Setting the same matching conditions again and again can be boring, so we have a way to group several routes that share the same requirements. We call it "subrouting". |
||||
|
||||
For example, let's say we have several URLs that should only match when the host is `www.example.com`. Create a route for that host and get a "subrouter" from it: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
s := r.Host("www.example.com").Subrouter() |
||||
``` |
||||
|
||||
Then register routes in the subrouter: |
||||
|
||||
```go |
||||
s.HandleFunc("/products/", ProductsHandler) |
||||
s.HandleFunc("/products/{key}", ProductHandler) |
||||
s.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler) |
||||
``` |
||||
|
||||
The three URL paths we registered above will only be tested if the domain is `www.example.com`, because the subrouter is tested first. This is not only convenient, but also optimizes request matching. You can create subrouters combining any attribute matchers accepted by a route. |
||||
|
||||
Subrouters can be used to create domain or path "namespaces": you define subrouters in a central place and then parts of the app can register its paths relatively to a given subrouter. |
||||
|
||||
There's one more thing about subroutes. When a subrouter has a path prefix, the inner routes use it as base for their paths: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
s := r.PathPrefix("/products").Subrouter() |
||||
// "/products/" |
||||
s.HandleFunc("/", ProductsHandler) |
||||
// "/products/{key}/" |
||||
s.HandleFunc("/{key}/", ProductHandler) |
||||
// "/products/{key}/details" |
||||
s.HandleFunc("/{key}/details", ProductDetailsHandler) |
||||
``` |
||||
|
||||
|
||||
### Static Files |
||||
|
||||
Note that the path provided to `PathPrefix()` represents a "wildcard": calling |
||||
`PathPrefix("/static/").Handler(...)` means that the handler will be passed any |
||||
request that matches "/static/\*". This makes it easy to serve static files with mux: |
||||
|
||||
```go |
||||
func main() { |
||||
var dir string |
||||
|
||||
flag.StringVar(&dir, "dir", ".", "the directory to serve files from. Defaults to the current dir") |
||||
flag.Parse() |
||||
r := mux.NewRouter() |
||||
|
||||
// This will serve files under http://localhost:8000/static/<filename> |
||||
r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(dir)))) |
||||
|
||||
srv := &http.Server{ |
||||
Handler: r, |
||||
Addr: "127.0.0.1:8000", |
||||
// Good practice: enforce timeouts for servers you create! |
||||
WriteTimeout: 15 * time.Second, |
||||
ReadTimeout: 15 * time.Second, |
||||
} |
||||
|
||||
log.Fatal(srv.ListenAndServe()) |
||||
} |
||||
``` |
||||
|
||||
### Registered URLs |
||||
|
||||
Now let's see how to build registered URLs. |
||||
|
||||
Routes can be named. All routes that define a name can have their URLs built, or "reversed". We define a name calling `Name()` on a route. For example: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler). |
||||
Name("article") |
||||
``` |
||||
|
||||
To build a URL, get the route and call the `URL()` method, passing a sequence of key/value pairs for the route variables. For the previous route, we would do: |
||||
|
||||
```go |
||||
url, err := r.Get("article").URL("category", "technology", "id", "42") |
||||
``` |
||||
|
||||
...and the result will be a `url.URL` with the following path: |
||||
|
||||
``` |
||||
"/articles/technology/42" |
||||
``` |
||||
|
||||
This also works for host and query value variables: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.Host("{subdomain}.domain.com"). |
||||
Path("/articles/{category}/{id:[0-9]+}"). |
||||
Queries("filter", "{filter}"). |
||||
HandlerFunc(ArticleHandler). |
||||
Name("article") |
||||
|
||||
// url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla" |
||||
url, err := r.Get("article").URL("subdomain", "news", |
||||
"category", "technology", |
||||
"id", "42", |
||||
"filter", "gorilla") |
||||
``` |
||||
|
||||
All variables defined in the route are required, and their values must conform to the corresponding patterns. These requirements guarantee that a generated URL will always match a registered route -- the only exception is for explicitly defined "build-only" routes which never match. |
||||
|
||||
Regex support also exists for matching Headers within a route. For example, we could do: |
||||
|
||||
```go |
||||
r.HeadersRegexp("Content-Type", "application/(text|json)") |
||||
``` |
||||
|
||||
...and the route will match both requests with a Content-Type of `application/json` as well as `application/text` |
||||
|
||||
There's also a way to build only the URL host or path for a route: use the methods `URLHost()` or `URLPath()` instead. For the previous route, we would do: |
||||
|
||||
```go |
||||
// "http://news.domain.com/" |
||||
host, err := r.Get("article").URLHost("subdomain", "news") |
||||
|
||||
// "/articles/technology/42" |
||||
path, err := r.Get("article").URLPath("category", "technology", "id", "42") |
||||
``` |
||||
|
||||
And if you use subrouters, host and path defined separately can be built as well: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
s := r.Host("{subdomain}.domain.com").Subrouter() |
||||
s.Path("/articles/{category}/{id:[0-9]+}"). |
||||
HandlerFunc(ArticleHandler). |
||||
Name("article") |
||||
|
||||
// "http://news.domain.com/articles/technology/42" |
||||
url, err := r.Get("article").URL("subdomain", "news", |
||||
"category", "technology", |
||||
"id", "42") |
||||
``` |
||||
|
||||
### Walking Routes |
||||
|
||||
The `Walk` function on `mux.Router` can be used to visit all of the routes that are registered on a router. For example, |
||||
the following prints all of the registered routes: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"net/http" |
||||
"strings" |
||||
|
||||
"github.com/gorilla/mux" |
||||
) |
||||
|
||||
func handler(w http.ResponseWriter, r *http.Request) { |
||||
return |
||||
} |
||||
|
||||
func main() { |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", handler) |
||||
r.HandleFunc("/products", handler).Methods("POST") |
||||
r.HandleFunc("/articles", handler).Methods("GET") |
||||
r.HandleFunc("/articles/{id}", handler).Methods("GET", "PUT") |
||||
r.HandleFunc("/authors", handler).Queries("surname", "{surname}") |
||||
err := r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error { |
||||
pathTemplate, err := route.GetPathTemplate() |
||||
if err == nil { |
||||
fmt.Println("ROUTE:", pathTemplate) |
||||
} |
||||
pathRegexp, err := route.GetPathRegexp() |
||||
if err == nil { |
||||
fmt.Println("Path regexp:", pathRegexp) |
||||
} |
||||
queriesTemplates, err := route.GetQueriesTemplates() |
||||
if err == nil { |
||||
fmt.Println("Queries templates:", strings.Join(queriesTemplates, ",")) |
||||
} |
||||
queriesRegexps, err := route.GetQueriesRegexp() |
||||
if err == nil { |
||||
fmt.Println("Queries regexps:", strings.Join(queriesRegexps, ",")) |
||||
} |
||||
methods, err := route.GetMethods() |
||||
if err == nil { |
||||
fmt.Println("Methods:", strings.Join(methods, ",")) |
||||
} |
||||
fmt.Println() |
||||
return nil |
||||
}) |
||||
|
||||
if err != nil { |
||||
fmt.Println(err) |
||||
} |
||||
|
||||
http.Handle("/", r) |
||||
} |
||||
``` |
||||
|
||||
### Graceful Shutdown |
||||
|
||||
Go 1.8 introduced the ability to [gracefully shutdown](https://golang.org/doc/go1.8#http_shutdown) a `*http.Server`. Here's how to do that alongside `mux`: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"context" |
||||
"flag" |
||||
"log" |
||||
"net/http" |
||||
"os" |
||||
"os/signal" |
||||
"time" |
||||
|
||||
"github.com/gorilla/mux" |
||||
) |
||||
|
||||
func main() { |
||||
var wait time.Duration |
||||
flag.DurationVar(&wait, "graceful-timeout", time.Second * 15, "the duration for which the server gracefully wait for existing connections to finish - e.g. 15s or 1m") |
||||
flag.Parse() |
||||
|
||||
r := mux.NewRouter() |
||||
// Add your routes as needed |
||||
|
||||
srv := &http.Server{ |
||||
Addr: "0.0.0.0:8080", |
||||
// Good practice to set timeouts to avoid Slowloris attacks. |
||||
WriteTimeout: time.Second * 15, |
||||
ReadTimeout: time.Second * 15, |
||||
IdleTimeout: time.Second * 60, |
||||
Handler: r, // Pass our instance of gorilla/mux in. |
||||
} |
||||
|
||||
// Run our server in a goroutine so that it doesn't block. |
||||
go func() { |
||||
if err := srv.ListenAndServe(); err != nil { |
||||
log.Println(err) |
||||
} |
||||
}() |
||||
|
||||
c := make(chan os.Signal, 1) |
||||
// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C) |
||||
// SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught. |
||||
signal.Notify(c, os.Interrupt) |
||||
|
||||
// Block until we receive our signal. |
||||
<-c |
||||
|
||||
// Create a deadline to wait for. |
||||
ctx, cancel := context.WithTimeout(context.Background(), wait) |
||||
defer cancel() |
||||
// Doesn't block if no connections, but will otherwise wait |
||||
// until the timeout deadline. |
||||
srv.Shutdown(ctx) |
||||
// Optionally, you could run srv.Shutdown in a goroutine and block on |
||||
// <-ctx.Done() if your application should wait for other services |
||||
// to finalize based on context cancellation. |
||||
log.Println("shutting down") |
||||
os.Exit(0) |
||||
} |
||||
``` |
||||
|
||||
### Middleware |
||||
|
||||
Mux supports the addition of middlewares to a [Router](https://godoc.org/github.com/gorilla/mux#Router), which are executed in the order they are added if a match is found, including its subrouters. |
||||
Middlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or `ResponseWriter` hijacking. |
||||
|
||||
Mux middlewares are defined using the de facto standard type: |
||||
|
||||
```go |
||||
type MiddlewareFunc func(http.Handler) http.Handler |
||||
``` |
||||
|
||||
Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc. This takes advantage of closures being able access variables from the context where they are created, while retaining the signature enforced by the receivers. |
||||
|
||||
A very basic middleware which logs the URI of the request being handled could be written as: |
||||
|
||||
```go |
||||
func loggingMiddleware(next http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
// Do stuff here |
||||
log.Println(r.RequestURI) |
||||
// Call the next handler, which can be another middleware in the chain, or the final handler. |
||||
next.ServeHTTP(w, r) |
||||
}) |
||||
} |
||||
``` |
||||
|
||||
Middlewares can be added to a router using `Router.Use()`: |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", handler) |
||||
r.Use(loggingMiddleware) |
||||
``` |
||||
|
||||
A more complex authentication middleware, which maps session token to users, could be written as: |
||||
|
||||
```go |
||||
// Define our struct |
||||
type authenticationMiddleware struct { |
||||
tokenUsers map[string]string |
||||
} |
||||
|
||||
// Initialize it somewhere |
||||
func (amw *authenticationMiddleware) Populate() { |
||||
amw.tokenUsers["00000000"] = "user0" |
||||
amw.tokenUsers["aaaaaaaa"] = "userA" |
||||
amw.tokenUsers["05f717e5"] = "randomUser" |
||||
amw.tokenUsers["deadbeef"] = "user0" |
||||
} |
||||
|
||||
// Middleware function, which will be called for each request |
||||
func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
token := r.Header.Get("X-Session-Token") |
||||
|
||||
if user, found := amw.tokenUsers[token]; found { |
||||
// We found the token in our map |
||||
log.Printf("Authenticated user %s\n", user) |
||||
// Pass down the request to the next middleware (or final handler) |
||||
next.ServeHTTP(w, r) |
||||
} else { |
||||
// Write an error and stop the handler chain |
||||
http.Error(w, "Forbidden", http.StatusForbidden) |
||||
} |
||||
}) |
||||
} |
||||
``` |
||||
|
||||
```go |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", handler) |
||||
|
||||
amw := authenticationMiddleware{} |
||||
amw.Populate() |
||||
|
||||
r.Use(amw.Middleware) |
||||
``` |
||||
|
||||
Note: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to. Middlewares _should_ write to `ResponseWriter` if they _are_ going to terminate the request, and they _should not_ write to `ResponseWriter` if they _are not_ going to terminate it. |
||||
|
||||
### Testing Handlers |
||||
|
||||
Testing handlers in a Go web application is straightforward, and _mux_ doesn't complicate this any further. Given two files: `endpoints.go` and `endpoints_test.go`, here's how we'd test an application using _mux_. |
||||
|
||||
First, our simple HTTP handler: |
||||
|
||||
```go |
||||
// endpoints.go |
||||
package main |
||||
|
||||
func HealthCheckHandler(w http.ResponseWriter, r *http.Request) { |
||||
// A very simple health check. |
||||
w.WriteHeader(http.StatusOK) |
||||
w.Header().Set("Content-Type", "application/json") |
||||
|
||||
// In the future we could report back on the status of our DB, or our cache |
||||
// (e.g. Redis) by performing a simple PING, and include them in the response. |
||||
io.WriteString(w, `{"alive": true}`) |
||||
} |
||||
|
||||
func main() { |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/health", HealthCheckHandler) |
||||
|
||||
log.Fatal(http.ListenAndServe("localhost:8080", r)) |
||||
} |
||||
``` |
||||
|
||||
Our test code: |
||||
|
||||
```go |
||||
// endpoints_test.go |
||||
package main |
||||
|
||||
import ( |
||||
"net/http" |
||||
"net/http/httptest" |
||||
"testing" |
||||
) |
||||
|
||||
func TestHealthCheckHandler(t *testing.T) { |
||||
// Create a request to pass to our handler. We don't have any query parameters for now, so we'll |
||||
// pass 'nil' as the third parameter. |
||||
req, err := http.NewRequest("GET", "/health", nil) |
||||
if err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
|
||||
// We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response. |
||||
rr := httptest.NewRecorder() |
||||
handler := http.HandlerFunc(HealthCheckHandler) |
||||
|
||||
// Our handlers satisfy http.Handler, so we can call their ServeHTTP method |
||||
// directly and pass in our Request and ResponseRecorder. |
||||
handler.ServeHTTP(rr, req) |
||||
|
||||
// Check the status code is what we expect. |
||||
if status := rr.Code; status != http.StatusOK { |
||||
t.Errorf("handler returned wrong status code: got %v want %v", |
||||
status, http.StatusOK) |
||||
} |
||||
|
||||
// Check the response body is what we expect. |
||||
expected := `{"alive": true}` |
||||
if rr.Body.String() != expected { |
||||
t.Errorf("handler returned unexpected body: got %v want %v", |
||||
rr.Body.String(), expected) |
||||
} |
||||
} |
||||
``` |
||||
|
||||
In the case that our routes have [variables](#examples), we can pass those in the request. We could write |
||||
[table-driven tests](https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go) to test multiple |
||||
possible route variables as needed. |
||||
|
||||
```go |
||||
// endpoints.go |
||||
func main() { |
||||
r := mux.NewRouter() |
||||
// A route with a route variable: |
||||
r.HandleFunc("/metrics/{type}", MetricsHandler) |
||||
|
||||
log.Fatal(http.ListenAndServe("localhost:8080", r)) |
||||
} |
||||
``` |
||||
|
||||
Our test file, with a table-driven test of `routeVariables`: |
||||
|
||||
```go |
||||
// endpoints_test.go |
||||
func TestMetricsHandler(t *testing.T) { |
||||
tt := []struct{ |
||||
routeVariable string |
||||
shouldPass bool |
||||
}{ |
||||
{"goroutines", true}, |
||||
{"heap", true}, |
||||
{"counters", true}, |
||||
{"queries", true}, |
||||
{"adhadaeqm3k", false}, |
||||
} |
||||
|
||||
for _, tc := range tt { |
||||
path := fmt.Sprintf("/metrics/%s", tc.routeVariable) |
||||
req, err := http.NewRequest("GET", path, nil) |
||||
if err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
|
||||
rr := httptest.NewRecorder() |
||||
|
||||
// Need to create a router that we can pass the request through so that the vars will be added to the context |
||||
router := mux.NewRouter() |
||||
router.HandleFunc("/metrics/{type}", MetricsHandler) |
||||
router.ServeHTTP(rr, req) |
||||
|
||||
// In this case, our MetricsHandler returns a non-200 response |
||||
// for a route variable it doesn't know about. |
||||
if rr.Code == http.StatusOK && !tc.shouldPass { |
||||
t.Errorf("handler should have failed on routeVariable %s: got %v want %v", |
||||
tc.routeVariable, rr.Code, http.StatusOK) |
||||
} |
||||
} |
||||
} |
||||
``` |
||||
|
||||
## Full Example |
||||
|
||||
Here's a complete, runnable example of a small `mux` based server: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"net/http" |
||||
"log" |
||||
"github.com/gorilla/mux" |
||||
) |
||||
|
||||
func YourHandler(w http.ResponseWriter, r *http.Request) { |
||||
w.Write([]byte("Gorilla!\n")) |
||||
} |
||||
|
||||
func main() { |
||||
r := mux.NewRouter() |
||||
// Routes consist of a path and a handler function. |
||||
r.HandleFunc("/", YourHandler) |
||||
|
||||
// Bind to a port and pass our router in |
||||
log.Fatal(http.ListenAndServe(":8000", r)) |
||||
} |
||||
``` |
||||
|
||||
## License |
||||
|
||||
BSD licensed. See the LICENSE file for details. |
||||
@ -0,0 +1,26 @@
|
||||
// +build !go1.7
|
||||
|
||||
package mux |
||||
|
||||
import ( |
||||
"net/http" |
||||
|
||||
"github.com/gorilla/context" |
||||
) |
||||
|
||||
func contextGet(r *http.Request, key interface{}) interface{} { |
||||
return context.Get(r, key) |
||||
} |
||||
|
||||
func contextSet(r *http.Request, key, val interface{}) *http.Request { |
||||
if val == nil { |
||||
return r |
||||
} |
||||
|
||||
context.Set(r, key, val) |
||||
return r |
||||
} |
||||
|
||||
func contextClear(r *http.Request) { |
||||
context.Clear(r) |
||||
} |
||||
@ -0,0 +1,24 @@
|
||||
// +build go1.7
|
||||
|
||||
package mux |
||||
|
||||
import ( |
||||
"context" |
||||
"net/http" |
||||
) |
||||
|
||||
func contextGet(r *http.Request, key interface{}) interface{} { |
||||
return r.Context().Value(key) |
||||
} |
||||
|
||||
func contextSet(r *http.Request, key, val interface{}) *http.Request { |
||||
if val == nil { |
||||
return r |
||||
} |
||||
|
||||
return r.WithContext(context.WithValue(r.Context(), key, val)) |
||||
} |
||||
|
||||
func contextClear(r *http.Request) { |
||||
return |
||||
} |
||||
@ -0,0 +1,306 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package mux implements a request router and dispatcher. |
||||
|
||||
The name mux stands for "HTTP request multiplexer". Like the standard |
||||
http.ServeMux, mux.Router matches incoming requests against a list of |
||||
registered routes and calls a handler for the route that matches the URL |
||||
or other conditions. The main features are: |
||||
|
||||
* Requests can be matched based on URL host, path, path prefix, schemes, |
||||
header and query values, HTTP methods or using custom matchers. |
||||
* URL hosts, paths and query values can have variables with an optional |
||||
regular expression. |
||||
* Registered URLs can be built, or "reversed", which helps maintaining |
||||
references to resources. |
||||
* Routes can be used as subrouters: nested routes are only tested if the |
||||
parent route matches. This is useful to define groups of routes that |
||||
share common conditions like a host, a path prefix or other repeated |
||||
attributes. As a bonus, this optimizes request matching. |
||||
* It implements the http.Handler interface so it is compatible with the |
||||
standard http.ServeMux. |
||||
|
||||
Let's start registering a couple of URL paths and handlers: |
||||
|
||||
func main() { |
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", HomeHandler) |
||||
r.HandleFunc("/products", ProductsHandler) |
||||
r.HandleFunc("/articles", ArticlesHandler) |
||||
http.Handle("/", r) |
||||
} |
||||
|
||||
Here we register three routes mapping URL paths to handlers. This is |
||||
equivalent to how http.HandleFunc() works: if an incoming request URL matches |
||||
one of the paths, the corresponding handler is called passing |
||||
(http.ResponseWriter, *http.Request) as parameters. |
||||
|
||||
Paths can have variables. They are defined using the format {name} or |
||||
{name:pattern}. If a regular expression pattern is not defined, the matched |
||||
variable will be anything until the next slash. For example: |
||||
|
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/products/{key}", ProductHandler) |
||||
r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler) |
||||
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler) |
||||
|
||||
Groups can be used inside patterns, as long as they are non-capturing (?:re). For example: |
||||
|
||||
r.HandleFunc("/articles/{category}/{sort:(?:asc|desc|new)}", ArticlesCategoryHandler) |
||||
|
||||
The names are used to create a map of route variables which can be retrieved |
||||
calling mux.Vars(): |
||||
|
||||
vars := mux.Vars(request) |
||||
category := vars["category"] |
||||
|
||||
Note that if any capturing groups are present, mux will panic() during parsing. To prevent |
||||
this, convert any capturing groups to non-capturing, e.g. change "/{sort:(asc|desc)}" to |
||||
"/{sort:(?:asc|desc)}". This is a change from prior versions which behaved unpredictably |
||||
when capturing groups were present. |
||||
|
||||
And this is all you need to know about the basic usage. More advanced options |
||||
are explained below. |
||||
|
||||
Routes can also be restricted to a domain or subdomain. Just define a host |
||||
pattern to be matched. They can also have variables: |
||||
|
||||
r := mux.NewRouter() |
||||
// Only matches if domain is "www.example.com".
|
||||
r.Host("www.example.com") |
||||
// Matches a dynamic subdomain.
|
||||
r.Host("{subdomain:[a-z]+}.domain.com") |
||||
|
||||
There are several other matchers that can be added. To match path prefixes: |
||||
|
||||
r.PathPrefix("/products/") |
||||
|
||||
...or HTTP methods: |
||||
|
||||
r.Methods("GET", "POST") |
||||
|
||||
...or URL schemes: |
||||
|
||||
r.Schemes("https") |
||||
|
||||
...or header values: |
||||
|
||||
r.Headers("X-Requested-With", "XMLHttpRequest") |
||||
|
||||
...or query values: |
||||
|
||||
r.Queries("key", "value") |
||||
|
||||
...or to use a custom matcher function: |
||||
|
||||
r.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool { |
||||
return r.ProtoMajor == 0 |
||||
}) |
||||
|
||||
...and finally, it is possible to combine several matchers in a single route: |
||||
|
||||
r.HandleFunc("/products", ProductsHandler). |
||||
Host("www.example.com"). |
||||
Methods("GET"). |
||||
Schemes("http") |
||||
|
||||
Setting the same matching conditions again and again can be boring, so we have |
||||
a way to group several routes that share the same requirements. |
||||
We call it "subrouting". |
||||
|
||||
For example, let's say we have several URLs that should only match when the |
||||
host is "www.example.com". Create a route for that host and get a "subrouter" |
||||
from it: |
||||
|
||||
r := mux.NewRouter() |
||||
s := r.Host("www.example.com").Subrouter() |
||||
|
||||
Then register routes in the subrouter: |
||||
|
||||
s.HandleFunc("/products/", ProductsHandler) |
||||
s.HandleFunc("/products/{key}", ProductHandler) |
||||
s.HandleFunc("/articles/{category}/{id:[0-9]+}"), ArticleHandler) |
||||
|
||||
The three URL paths we registered above will only be tested if the domain is |
||||
"www.example.com", because the subrouter is tested first. This is not |
||||
only convenient, but also optimizes request matching. You can create |
||||
subrouters combining any attribute matchers accepted by a route. |
||||
|
||||
Subrouters can be used to create domain or path "namespaces": you define |
||||
subrouters in a central place and then parts of the app can register its |
||||
paths relatively to a given subrouter. |
||||
|
||||
There's one more thing about subroutes. When a subrouter has a path prefix, |
||||
the inner routes use it as base for their paths: |
||||
|
||||
r := mux.NewRouter() |
||||
s := r.PathPrefix("/products").Subrouter() |
||||
// "/products/"
|
||||
s.HandleFunc("/", ProductsHandler) |
||||
// "/products/{key}/"
|
||||
s.HandleFunc("/{key}/", ProductHandler) |
||||
// "/products/{key}/details"
|
||||
s.HandleFunc("/{key}/details", ProductDetailsHandler) |
||||
|
||||
Note that the path provided to PathPrefix() represents a "wildcard": calling |
||||
PathPrefix("/static/").Handler(...) means that the handler will be passed any |
||||
request that matches "/static/*". This makes it easy to serve static files with mux: |
||||
|
||||
func main() { |
||||
var dir string |
||||
|
||||
flag.StringVar(&dir, "dir", ".", "the directory to serve files from. Defaults to the current dir") |
||||
flag.Parse() |
||||
r := mux.NewRouter() |
||||
|
||||
// This will serve files under http://localhost:8000/static/<filename>
|
||||
r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(dir)))) |
||||
|
||||
srv := &http.Server{ |
||||
Handler: r, |
||||
Addr: "127.0.0.1:8000", |
||||
// Good practice: enforce timeouts for servers you create!
|
||||
WriteTimeout: 15 * time.Second, |
||||
ReadTimeout: 15 * time.Second, |
||||
} |
||||
|
||||
log.Fatal(srv.ListenAndServe()) |
||||
} |
||||
|
||||
Now let's see how to build registered URLs. |
||||
|
||||
Routes can be named. All routes that define a name can have their URLs built, |
||||
or "reversed". We define a name calling Name() on a route. For example: |
||||
|
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler). |
||||
Name("article") |
||||
|
||||
To build a URL, get the route and call the URL() method, passing a sequence of |
||||
key/value pairs for the route variables. For the previous route, we would do: |
||||
|
||||
url, err := r.Get("article").URL("category", "technology", "id", "42") |
||||
|
||||
...and the result will be a url.URL with the following path: |
||||
|
||||
"/articles/technology/42" |
||||
|
||||
This also works for host and query value variables: |
||||
|
||||
r := mux.NewRouter() |
||||
r.Host("{subdomain}.domain.com"). |
||||
Path("/articles/{category}/{id:[0-9]+}"). |
||||
Queries("filter", "{filter}"). |
||||
HandlerFunc(ArticleHandler). |
||||
Name("article") |
||||
|
||||
// url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla"
|
||||
url, err := r.Get("article").URL("subdomain", "news", |
||||
"category", "technology", |
||||
"id", "42", |
||||
"filter", "gorilla") |
||||
|
||||
All variables defined in the route are required, and their values must |
||||
conform to the corresponding patterns. These requirements guarantee that a |
||||
generated URL will always match a registered route -- the only exception is |
||||
for explicitly defined "build-only" routes which never match. |
||||
|
||||
Regex support also exists for matching Headers within a route. For example, we could do: |
||||
|
||||
r.HeadersRegexp("Content-Type", "application/(text|json)") |
||||
|
||||
...and the route will match both requests with a Content-Type of `application/json` as well as |
||||
`application/text` |
||||
|
||||
There's also a way to build only the URL host or path for a route: |
||||
use the methods URLHost() or URLPath() instead. For the previous route, |
||||
we would do: |
||||
|
||||
// "http://news.domain.com/"
|
||||
host, err := r.Get("article").URLHost("subdomain", "news") |
||||
|
||||
// "/articles/technology/42"
|
||||
path, err := r.Get("article").URLPath("category", "technology", "id", "42") |
||||
|
||||
And if you use subrouters, host and path defined separately can be built |
||||
as well: |
||||
|
||||
r := mux.NewRouter() |
||||
s := r.Host("{subdomain}.domain.com").Subrouter() |
||||
s.Path("/articles/{category}/{id:[0-9]+}"). |
||||
HandlerFunc(ArticleHandler). |
||||
Name("article") |
||||
|
||||
// "http://news.domain.com/articles/technology/42"
|
||||
url, err := r.Get("article").URL("subdomain", "news", |
||||
"category", "technology", |
||||
"id", "42") |
||||
|
||||
Mux supports the addition of middlewares to a Router, which are executed in the order they are added if a match is found, including its subrouters. Middlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or ResponseWriter hijacking. |
||||
|
||||
type MiddlewareFunc func(http.Handler) http.Handler |
||||
|
||||
Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc (closures can access variables from the context where they are created). |
||||
|
||||
A very basic middleware which logs the URI of the request being handled could be written as: |
||||
|
||||
func simpleMw(next http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
// Do stuff here
|
||||
log.Println(r.RequestURI) |
||||
// Call the next handler, which can be another middleware in the chain, or the final handler.
|
||||
next.ServeHTTP(w, r) |
||||
}) |
||||
} |
||||
|
||||
Middlewares can be added to a router using `Router.Use()`: |
||||
|
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", handler) |
||||
r.Use(simpleMw) |
||||
|
||||
A more complex authentication middleware, which maps session token to users, could be written as: |
||||
|
||||
// Define our struct
|
||||
type authenticationMiddleware struct { |
||||
tokenUsers map[string]string |
||||
} |
||||
|
||||
// Initialize it somewhere
|
||||
func (amw *authenticationMiddleware) Populate() { |
||||
amw.tokenUsers["00000000"] = "user0" |
||||
amw.tokenUsers["aaaaaaaa"] = "userA" |
||||
amw.tokenUsers["05f717e5"] = "randomUser" |
||||
amw.tokenUsers["deadbeef"] = "user0" |
||||
} |
||||
|
||||
// Middleware function, which will be called for each request
|
||||
func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
||||
token := r.Header.Get("X-Session-Token") |
||||
|
||||
if user, found := amw.tokenUsers[token]; found { |
||||
// We found the token in our map
|
||||
log.Printf("Authenticated user %s\n", user) |
||||
next.ServeHTTP(w, r) |
||||
} else { |
||||
http.Error(w, "Forbidden", http.StatusForbidden) |
||||
} |
||||
}) |
||||
} |
||||
|
||||
r := mux.NewRouter() |
||||
r.HandleFunc("/", handler) |
||||
|
||||
amw := authenticationMiddleware{} |
||||
amw.Populate() |
||||
|
||||
r.Use(amw.Middleware) |
||||
|
||||
Note: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to. |
||||
|
||||
*/ |
||||
package mux |
||||
@ -0,0 +1,72 @@
|
||||
package mux |
||||
|
||||
import ( |
||||
"net/http" |
||||
"strings" |
||||
) |
||||
|
||||
// MiddlewareFunc is a function which receives an http.Handler and returns another http.Handler.
|
||||
// Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed
|
||||
// to it, and then calls the handler passed as parameter to the MiddlewareFunc.
|
||||
type MiddlewareFunc func(http.Handler) http.Handler |
||||
|
||||
// middleware interface is anything which implements a MiddlewareFunc named Middleware.
|
||||
type middleware interface { |
||||
Middleware(handler http.Handler) http.Handler |
||||
} |
||||
|
||||
// Middleware allows MiddlewareFunc to implement the middleware interface.
|
||||
func (mw MiddlewareFunc) Middleware(handler http.Handler) http.Handler { |
||||
return mw(handler) |
||||
} |
||||
|
||||
// Use appends a MiddlewareFunc to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.
|
||||
func (r *Router) Use(mwf ...MiddlewareFunc) { |
||||
for _, fn := range mwf { |
||||
r.middlewares = append(r.middlewares, fn) |
||||
} |
||||
} |
||||
|
||||
// useInterface appends a middleware to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.
|
||||
func (r *Router) useInterface(mw middleware) { |
||||
r.middlewares = append(r.middlewares, mw) |
||||
} |
||||
|
||||
// CORSMethodMiddleware sets the Access-Control-Allow-Methods response header
|
||||
// on a request, by matching routes based only on paths. It also handles
|
||||
// OPTIONS requests, by settings Access-Control-Allow-Methods, and then
|
||||
// returning without calling the next http handler.
|
||||
func CORSMethodMiddleware(r *Router) MiddlewareFunc { |
||||
return func(next http.Handler) http.Handler { |
||||
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { |
||||
var allMethods []string |
||||
|
||||
err := r.Walk(func(route *Route, _ *Router, _ []*Route) error { |
||||
for _, m := range route.matchers { |
||||
if _, ok := m.(*routeRegexp); ok { |
||||
if m.Match(req, &RouteMatch{}) { |
||||
methods, err := route.GetMethods() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
allMethods = append(allMethods, methods...) |
||||
} |
||||
break |
||||
} |
||||
} |
||||
return nil |
||||
}) |
||||
|
||||
if err == nil { |
||||
w.Header().Set("Access-Control-Allow-Methods", strings.Join(append(allMethods, "OPTIONS"), ",")) |
||||
|
||||
if req.Method == "OPTIONS" { |
||||
return |
||||
} |
||||
} |
||||
|
||||
next.ServeHTTP(w, req) |
||||
}) |
||||
} |
||||
} |
||||
@ -0,0 +1,588 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package mux |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"net/http" |
||||
"path" |
||||
"regexp" |
||||
) |
||||
|
||||
var ( |
||||
// ErrMethodMismatch is returned when the method in the request does not match
|
||||
// the method defined against the route.
|
||||
ErrMethodMismatch = errors.New("method is not allowed") |
||||
// ErrNotFound is returned when no route match is found.
|
||||
ErrNotFound = errors.New("no matching route was found") |
||||
) |
||||
|
||||
// NewRouter returns a new router instance.
|
||||
func NewRouter() *Router { |
||||
return &Router{namedRoutes: make(map[string]*Route), KeepContext: false} |
||||
} |
||||
|
||||
// Router registers routes to be matched and dispatches a handler.
|
||||
//
|
||||
// It implements the http.Handler interface, so it can be registered to serve
|
||||
// requests:
|
||||
//
|
||||
// var router = mux.NewRouter()
|
||||
//
|
||||
// func main() {
|
||||
// http.Handle("/", router)
|
||||
// }
|
||||
//
|
||||
// Or, for Google App Engine, register it in a init() function:
|
||||
//
|
||||
// func init() {
|
||||
// http.Handle("/", router)
|
||||
// }
|
||||
//
|
||||
// This will send all incoming requests to the router.
|
||||
type Router struct { |
||||
// Configurable Handler to be used when no route matches.
|
||||
NotFoundHandler http.Handler |
||||
|
||||
// Configurable Handler to be used when the request method does not match the route.
|
||||
MethodNotAllowedHandler http.Handler |
||||
|
||||
// Parent route, if this is a subrouter.
|
||||
parent parentRoute |
||||
// Routes to be matched, in order.
|
||||
routes []*Route |
||||
// Routes by name for URL building.
|
||||
namedRoutes map[string]*Route |
||||
// See Router.StrictSlash(). This defines the flag for new routes.
|
||||
strictSlash bool |
||||
// See Router.SkipClean(). This defines the flag for new routes.
|
||||
skipClean bool |
||||
// If true, do not clear the request context after handling the request.
|
||||
// This has no effect when go1.7+ is used, since the context is stored
|
||||
// on the request itself.
|
||||
KeepContext bool |
||||
// see Router.UseEncodedPath(). This defines a flag for all routes.
|
||||
useEncodedPath bool |
||||
// Slice of middlewares to be called after a match is found
|
||||
middlewares []middleware |
||||
} |
||||
|
||||
// Match attempts to match the given request against the router's registered routes.
|
||||
//
|
||||
// If the request matches a route of this router or one of its subrouters the Route,
|
||||
// Handler, and Vars fields of the the match argument are filled and this function
|
||||
// returns true.
|
||||
//
|
||||
// If the request does not match any of this router's or its subrouters' routes
|
||||
// then this function returns false. If available, a reason for the match failure
|
||||
// will be filled in the match argument's MatchErr field. If the match failure type
|
||||
// (eg: not found) has a registered handler, the handler is assigned to the Handler
|
||||
// field of the match argument.
|
||||
func (r *Router) Match(req *http.Request, match *RouteMatch) bool { |
||||
for _, route := range r.routes { |
||||
if route.Match(req, match) { |
||||
// Build middleware chain if no error was found
|
||||
if match.MatchErr == nil { |
||||
for i := len(r.middlewares) - 1; i >= 0; i-- { |
||||
match.Handler = r.middlewares[i].Middleware(match.Handler) |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
} |
||||
|
||||
if match.MatchErr == ErrMethodMismatch { |
||||
if r.MethodNotAllowedHandler != nil { |
||||
match.Handler = r.MethodNotAllowedHandler |
||||
return true |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
// Closest match for a router (includes sub-routers)
|
||||
if r.NotFoundHandler != nil { |
||||
match.Handler = r.NotFoundHandler |
||||
match.MatchErr = ErrNotFound |
||||
return true |
||||
} |
||||
|
||||
match.MatchErr = ErrNotFound |
||||
return false |
||||
} |
||||
|
||||
// ServeHTTP dispatches the handler registered in the matched route.
|
||||
//
|
||||
// When there is a match, the route variables can be retrieved calling
|
||||
// mux.Vars(request).
|
||||
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { |
||||
if !r.skipClean { |
||||
path := req.URL.Path |
||||
if r.useEncodedPath { |
||||
path = req.URL.EscapedPath() |
||||
} |
||||
// Clean path to canonical form and redirect.
|
||||
if p := cleanPath(path); p != path { |
||||
|
||||
// Added 3 lines (Philip Schlump) - It was dropping the query string and #whatever from query.
|
||||
// This matches with fix in go 1.2 r.c. 4 for same problem. Go Issue:
|
||||
// http://code.google.com/p/go/issues/detail?id=5252
|
||||
url := *req.URL |
||||
url.Path = p |
||||
p = url.String() |
||||
|
||||
w.Header().Set("Location", p) |
||||
w.WriteHeader(http.StatusMovedPermanently) |
||||
return |
||||
} |
||||
} |
||||
var match RouteMatch |
||||
var handler http.Handler |
||||
if r.Match(req, &match) { |
||||
handler = match.Handler |
||||
req = setVars(req, match.Vars) |
||||
req = setCurrentRoute(req, match.Route) |
||||
} |
||||
|
||||
if handler == nil && match.MatchErr == ErrMethodMismatch { |
||||
handler = methodNotAllowedHandler() |
||||
} |
||||
|
||||
if handler == nil { |
||||
handler = http.NotFoundHandler() |
||||
} |
||||
|
||||
if !r.KeepContext { |
||||
defer contextClear(req) |
||||
} |
||||
|
||||
handler.ServeHTTP(w, req) |
||||
} |
||||
|
||||
// Get returns a route registered with the given name.
|
||||
func (r *Router) Get(name string) *Route { |
||||
return r.getNamedRoutes()[name] |
||||
} |
||||
|
||||
// GetRoute returns a route registered with the given name. This method
|
||||
// was renamed to Get() and remains here for backwards compatibility.
|
||||
func (r *Router) GetRoute(name string) *Route { |
||||
return r.getNamedRoutes()[name] |
||||
} |
||||
|
||||
// StrictSlash defines the trailing slash behavior for new routes. The initial
|
||||
// value is false.
|
||||
//
|
||||
// When true, if the route path is "/path/", accessing "/path" will perform a redirect
|
||||
// to the former and vice versa. In other words, your application will always
|
||||
// see the path as specified in the route.
|
||||
//
|
||||
// When false, if the route path is "/path", accessing "/path/" will not match
|
||||
// this route and vice versa.
|
||||
//
|
||||
// The re-direct is a HTTP 301 (Moved Permanently). Note that when this is set for
|
||||
// routes with a non-idempotent method (e.g. POST, PUT), the subsequent re-directed
|
||||
// request will be made as a GET by most clients. Use middleware or client settings
|
||||
// to modify this behaviour as needed.
|
||||
//
|
||||
// Special case: when a route sets a path prefix using the PathPrefix() method,
|
||||
// strict slash is ignored for that route because the redirect behavior can't
|
||||
// be determined from a prefix alone. However, any subrouters created from that
|
||||
// route inherit the original StrictSlash setting.
|
||||
func (r *Router) StrictSlash(value bool) *Router { |
||||
r.strictSlash = value |
||||
return r |
||||
} |
||||
|
||||
// SkipClean defines the path cleaning behaviour for new routes. The initial
|
||||
// value is false. Users should be careful about which routes are not cleaned
|
||||
//
|
||||
// When true, if the route path is "/path//to", it will remain with the double
|
||||
// slash. This is helpful if you have a route like: /fetch/http://xkcd.com/534/
|
||||
//
|
||||
// When false, the path will be cleaned, so /fetch/http://xkcd.com/534/ will
|
||||
// become /fetch/http/xkcd.com/534
|
||||
func (r *Router) SkipClean(value bool) *Router { |
||||
r.skipClean = value |
||||
return r |
||||
} |
||||
|
||||
// UseEncodedPath tells the router to match the encoded original path
|
||||
// to the routes.
|
||||
// For eg. "/path/foo%2Fbar/to" will match the path "/path/{var}/to".
|
||||
//
|
||||
// If not called, the router will match the unencoded path to the routes.
|
||||
// For eg. "/path/foo%2Fbar/to" will match the path "/path/foo/bar/to"
|
||||
func (r *Router) UseEncodedPath() *Router { |
||||
r.useEncodedPath = true |
||||
return r |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// parentRoute
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
func (r *Router) getBuildScheme() string { |
||||
if r.parent != nil { |
||||
return r.parent.getBuildScheme() |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
// getNamedRoutes returns the map where named routes are registered.
|
||||
func (r *Router) getNamedRoutes() map[string]*Route { |
||||
if r.namedRoutes == nil { |
||||
if r.parent != nil { |
||||
r.namedRoutes = r.parent.getNamedRoutes() |
||||
} else { |
||||
r.namedRoutes = make(map[string]*Route) |
||||
} |
||||
} |
||||
return r.namedRoutes |
||||
} |
||||
|
||||
// getRegexpGroup returns regexp definitions from the parent route, if any.
|
||||
func (r *Router) getRegexpGroup() *routeRegexpGroup { |
||||
if r.parent != nil { |
||||
return r.parent.getRegexpGroup() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (r *Router) buildVars(m map[string]string) map[string]string { |
||||
if r.parent != nil { |
||||
m = r.parent.buildVars(m) |
||||
} |
||||
return m |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Route factories
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// NewRoute registers an empty route.
|
||||
func (r *Router) NewRoute() *Route { |
||||
route := &Route{parent: r, strictSlash: r.strictSlash, skipClean: r.skipClean, useEncodedPath: r.useEncodedPath} |
||||
r.routes = append(r.routes, route) |
||||
return route |
||||
} |
||||
|
||||
// Handle registers a new route with a matcher for the URL path.
|
||||
// See Route.Path() and Route.Handler().
|
||||
func (r *Router) Handle(path string, handler http.Handler) *Route { |
||||
return r.NewRoute().Path(path).Handler(handler) |
||||
} |
||||
|
||||
// HandleFunc registers a new route with a matcher for the URL path.
|
||||
// See Route.Path() and Route.HandlerFunc().
|
||||
func (r *Router) HandleFunc(path string, f func(http.ResponseWriter, |
||||
*http.Request)) *Route { |
||||
return r.NewRoute().Path(path).HandlerFunc(f) |
||||
} |
||||
|
||||
// Headers registers a new route with a matcher for request header values.
|
||||
// See Route.Headers().
|
||||
func (r *Router) Headers(pairs ...string) *Route { |
||||
return r.NewRoute().Headers(pairs...) |
||||
} |
||||
|
||||
// Host registers a new route with a matcher for the URL host.
|
||||
// See Route.Host().
|
||||
func (r *Router) Host(tpl string) *Route { |
||||
return r.NewRoute().Host(tpl) |
||||
} |
||||
|
||||
// MatcherFunc registers a new route with a custom matcher function.
|
||||
// See Route.MatcherFunc().
|
||||
func (r *Router) MatcherFunc(f MatcherFunc) *Route { |
||||
return r.NewRoute().MatcherFunc(f) |
||||
} |
||||
|
||||
// Methods registers a new route with a matcher for HTTP methods.
|
||||
// See Route.Methods().
|
||||
func (r *Router) Methods(methods ...string) *Route { |
||||
return r.NewRoute().Methods(methods...) |
||||
} |
||||
|
||||
// Path registers a new route with a matcher for the URL path.
|
||||
// See Route.Path().
|
||||
func (r *Router) Path(tpl string) *Route { |
||||
return r.NewRoute().Path(tpl) |
||||
} |
||||
|
||||
// PathPrefix registers a new route with a matcher for the URL path prefix.
|
||||
// See Route.PathPrefix().
|
||||
func (r *Router) PathPrefix(tpl string) *Route { |
||||
return r.NewRoute().PathPrefix(tpl) |
||||
} |
||||
|
||||
// Queries registers a new route with a matcher for URL query values.
|
||||
// See Route.Queries().
|
||||
func (r *Router) Queries(pairs ...string) *Route { |
||||
return r.NewRoute().Queries(pairs...) |
||||
} |
||||
|
||||
// Schemes registers a new route with a matcher for URL schemes.
|
||||
// See Route.Schemes().
|
||||
func (r *Router) Schemes(schemes ...string) *Route { |
||||
return r.NewRoute().Schemes(schemes...) |
||||
} |
||||
|
||||
// BuildVarsFunc registers a new route with a custom function for modifying
|
||||
// route variables before building a URL.
|
||||
func (r *Router) BuildVarsFunc(f BuildVarsFunc) *Route { |
||||
return r.NewRoute().BuildVarsFunc(f) |
||||
} |
||||
|
||||
// Walk walks the router and all its sub-routers, calling walkFn for each route
|
||||
// in the tree. The routes are walked in the order they were added. Sub-routers
|
||||
// are explored depth-first.
|
||||
func (r *Router) Walk(walkFn WalkFunc) error { |
||||
return r.walk(walkFn, []*Route{}) |
||||
} |
||||
|
||||
// SkipRouter is used as a return value from WalkFuncs to indicate that the
|
||||
// router that walk is about to descend down to should be skipped.
|
||||
var SkipRouter = errors.New("skip this router") |
||||
|
||||
// WalkFunc is the type of the function called for each route visited by Walk.
|
||||
// At every invocation, it is given the current route, and the current router,
|
||||
// and a list of ancestor routes that lead to the current route.
|
||||
type WalkFunc func(route *Route, router *Router, ancestors []*Route) error |
||||
|
||||
func (r *Router) walk(walkFn WalkFunc, ancestors []*Route) error { |
||||
for _, t := range r.routes { |
||||
err := walkFn(t, r, ancestors) |
||||
if err == SkipRouter { |
||||
continue |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
for _, sr := range t.matchers { |
||||
if h, ok := sr.(*Router); ok { |
||||
ancestors = append(ancestors, t) |
||||
err := h.walk(walkFn, ancestors) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
ancestors = ancestors[:len(ancestors)-1] |
||||
} |
||||
} |
||||
if h, ok := t.handler.(*Router); ok { |
||||
ancestors = append(ancestors, t) |
||||
err := h.walk(walkFn, ancestors) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
ancestors = ancestors[:len(ancestors)-1] |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Context
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// RouteMatch stores information about a matched route.
|
||||
type RouteMatch struct { |
||||
Route *Route |
||||
Handler http.Handler |
||||
Vars map[string]string |
||||
|
||||
// MatchErr is set to appropriate matching error
|
||||
// It is set to ErrMethodMismatch if there is a mismatch in
|
||||
// the request method and route method
|
||||
MatchErr error |
||||
} |
||||
|
||||
type contextKey int |
||||
|
||||
const ( |
||||
varsKey contextKey = iota |
||||
routeKey |
||||
) |
||||
|
||||
// Vars returns the route variables for the current request, if any.
|
||||
func Vars(r *http.Request) map[string]string { |
||||
if rv := contextGet(r, varsKey); rv != nil { |
||||
return rv.(map[string]string) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// CurrentRoute returns the matched route for the current request, if any.
|
||||
// This only works when called inside the handler of the matched route
|
||||
// because the matched route is stored in the request context which is cleared
|
||||
// after the handler returns, unless the KeepContext option is set on the
|
||||
// Router.
|
||||
func CurrentRoute(r *http.Request) *Route { |
||||
if rv := contextGet(r, routeKey); rv != nil { |
||||
return rv.(*Route) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func setVars(r *http.Request, val interface{}) *http.Request { |
||||
return contextSet(r, varsKey, val) |
||||
} |
||||
|
||||
func setCurrentRoute(r *http.Request, val interface{}) *http.Request { |
||||
return contextSet(r, routeKey, val) |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// cleanPath returns the canonical path for p, eliminating . and .. elements.
|
||||
// Borrowed from the net/http package.
|
||||
func cleanPath(p string) string { |
||||
if p == "" { |
||||
return "/" |
||||
} |
||||
if p[0] != '/' { |
||||
p = "/" + p |
||||
} |
||||
np := path.Clean(p) |
||||
// path.Clean removes trailing slash except for root;
|
||||
// put the trailing slash back if necessary.
|
||||
if p[len(p)-1] == '/' && np != "/" { |
||||
np += "/" |
||||
} |
||||
|
||||
return np |
||||
} |
||||
|
||||
// uniqueVars returns an error if two slices contain duplicated strings.
|
||||
func uniqueVars(s1, s2 []string) error { |
||||
for _, v1 := range s1 { |
||||
for _, v2 := range s2 { |
||||
if v1 == v2 { |
||||
return fmt.Errorf("mux: duplicated route variable %q", v2) |
||||
} |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// checkPairs returns the count of strings passed in, and an error if
|
||||
// the count is not an even number.
|
||||
func checkPairs(pairs ...string) (int, error) { |
||||
length := len(pairs) |
||||
if length%2 != 0 { |
||||
return length, fmt.Errorf( |
||||
"mux: number of parameters must be multiple of 2, got %v", pairs) |
||||
} |
||||
return length, nil |
||||
} |
||||
|
||||
// mapFromPairsToString converts variadic string parameters to a
|
||||
// string to string map.
|
||||
func mapFromPairsToString(pairs ...string) (map[string]string, error) { |
||||
length, err := checkPairs(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
m := make(map[string]string, length/2) |
||||
for i := 0; i < length; i += 2 { |
||||
m[pairs[i]] = pairs[i+1] |
||||
} |
||||
return m, nil |
||||
} |
||||
|
||||
// mapFromPairsToRegex converts variadic string parameters to a
|
||||
// string to regex map.
|
||||
func mapFromPairsToRegex(pairs ...string) (map[string]*regexp.Regexp, error) { |
||||
length, err := checkPairs(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
m := make(map[string]*regexp.Regexp, length/2) |
||||
for i := 0; i < length; i += 2 { |
||||
regex, err := regexp.Compile(pairs[i+1]) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
m[pairs[i]] = regex |
||||
} |
||||
return m, nil |
||||
} |
||||
|
||||
// matchInArray returns true if the given string value is in the array.
|
||||
func matchInArray(arr []string, value string) bool { |
||||
for _, v := range arr { |
||||
if v == value { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// matchMapWithString returns true if the given key/value pairs exist in a given map.
|
||||
func matchMapWithString(toCheck map[string]string, toMatch map[string][]string, canonicalKey bool) bool { |
||||
for k, v := range toCheck { |
||||
// Check if key exists.
|
||||
if canonicalKey { |
||||
k = http.CanonicalHeaderKey(k) |
||||
} |
||||
if values := toMatch[k]; values == nil { |
||||
return false |
||||
} else if v != "" { |
||||
// If value was defined as an empty string we only check that the
|
||||
// key exists. Otherwise we also check for equality.
|
||||
valueExists := false |
||||
for _, value := range values { |
||||
if v == value { |
||||
valueExists = true |
||||
break |
||||
} |
||||
} |
||||
if !valueExists { |
||||
return false |
||||
} |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// matchMapWithRegex returns true if the given key/value pairs exist in a given map compiled against
|
||||
// the given regex
|
||||
func matchMapWithRegex(toCheck map[string]*regexp.Regexp, toMatch map[string][]string, canonicalKey bool) bool { |
||||
for k, v := range toCheck { |
||||
// Check if key exists.
|
||||
if canonicalKey { |
||||
k = http.CanonicalHeaderKey(k) |
||||
} |
||||
if values := toMatch[k]; values == nil { |
||||
return false |
||||
} else if v != nil { |
||||
// If value was defined as an empty string we only check that the
|
||||
// key exists. Otherwise we also check for equality.
|
||||
valueExists := false |
||||
for _, value := range values { |
||||
if v.MatchString(value) { |
||||
valueExists = true |
||||
break |
||||
} |
||||
} |
||||
if !valueExists { |
||||
return false |
||||
} |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// methodNotAllowed replies to the request with an HTTP status code 405.
|
||||
func methodNotAllowed(w http.ResponseWriter, r *http.Request) { |
||||
w.WriteHeader(http.StatusMethodNotAllowed) |
||||
} |
||||
|
||||
// methodNotAllowedHandler returns a simple request handler
|
||||
// that replies to each request with a status code 405.
|
||||
func methodNotAllowedHandler() http.Handler { return http.HandlerFunc(methodNotAllowed) } |
||||
@ -0,0 +1,332 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package mux |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"net/http" |
||||
"net/url" |
||||
"regexp" |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
type routeRegexpOptions struct { |
||||
strictSlash bool |
||||
useEncodedPath bool |
||||
} |
||||
|
||||
type regexpType int |
||||
|
||||
const ( |
||||
regexpTypePath regexpType = 0 |
||||
regexpTypeHost regexpType = 1 |
||||
regexpTypePrefix regexpType = 2 |
||||
regexpTypeQuery regexpType = 3 |
||||
) |
||||
|
||||
// newRouteRegexp parses a route template and returns a routeRegexp,
|
||||
// used to match a host, a path or a query string.
|
||||
//
|
||||
// It will extract named variables, assemble a regexp to be matched, create
|
||||
// a "reverse" template to build URLs and compile regexps to validate variable
|
||||
// values used in URL building.
|
||||
//
|
||||
// Previously we accepted only Python-like identifiers for variable
|
||||
// names ([a-zA-Z_][a-zA-Z0-9_]*), but currently the only restriction is that
|
||||
// name and pattern can't be empty, and names can't contain a colon.
|
||||
func newRouteRegexp(tpl string, typ regexpType, options routeRegexpOptions) (*routeRegexp, error) { |
||||
// Check if it is well-formed.
|
||||
idxs, errBraces := braceIndices(tpl) |
||||
if errBraces != nil { |
||||
return nil, errBraces |
||||
} |
||||
// Backup the original.
|
||||
template := tpl |
||||
// Now let's parse it.
|
||||
defaultPattern := "[^/]+" |
||||
if typ == regexpTypeQuery { |
||||
defaultPattern = ".*" |
||||
} else if typ == regexpTypeHost { |
||||
defaultPattern = "[^.]+" |
||||
} |
||||
// Only match strict slash if not matching
|
||||
if typ != regexpTypePath { |
||||
options.strictSlash = false |
||||
} |
||||
// Set a flag for strictSlash.
|
||||
endSlash := false |
||||
if options.strictSlash && strings.HasSuffix(tpl, "/") { |
||||
tpl = tpl[:len(tpl)-1] |
||||
endSlash = true |
||||
} |
||||
varsN := make([]string, len(idxs)/2) |
||||
varsR := make([]*regexp.Regexp, len(idxs)/2) |
||||
pattern := bytes.NewBufferString("") |
||||
pattern.WriteByte('^') |
||||
reverse := bytes.NewBufferString("") |
||||
var end int |
||||
var err error |
||||
for i := 0; i < len(idxs); i += 2 { |
||||
// Set all values we are interested in.
|
||||
raw := tpl[end:idxs[i]] |
||||
end = idxs[i+1] |
||||
parts := strings.SplitN(tpl[idxs[i]+1:end-1], ":", 2) |
||||
name := parts[0] |
||||
patt := defaultPattern |
||||
if len(parts) == 2 { |
||||
patt = parts[1] |
||||
} |
||||
// Name or pattern can't be empty.
|
||||
if name == "" || patt == "" { |
||||
return nil, fmt.Errorf("mux: missing name or pattern in %q", |
||||
tpl[idxs[i]:end]) |
||||
} |
||||
// Build the regexp pattern.
|
||||
fmt.Fprintf(pattern, "%s(?P<%s>%s)", regexp.QuoteMeta(raw), varGroupName(i/2), patt) |
||||
|
||||
// Build the reverse template.
|
||||
fmt.Fprintf(reverse, "%s%%s", raw) |
||||
|
||||
// Append variable name and compiled pattern.
|
||||
varsN[i/2] = name |
||||
varsR[i/2], err = regexp.Compile(fmt.Sprintf("^%s$", patt)) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
// Add the remaining.
|
||||
raw := tpl[end:] |
||||
pattern.WriteString(regexp.QuoteMeta(raw)) |
||||
if options.strictSlash { |
||||
pattern.WriteString("[/]?") |
||||
} |
||||
if typ == regexpTypeQuery { |
||||
// Add the default pattern if the query value is empty
|
||||
if queryVal := strings.SplitN(template, "=", 2)[1]; queryVal == "" { |
||||
pattern.WriteString(defaultPattern) |
||||
} |
||||
} |
||||
if typ != regexpTypePrefix { |
||||
pattern.WriteByte('$') |
||||
} |
||||
reverse.WriteString(raw) |
||||
if endSlash { |
||||
reverse.WriteByte('/') |
||||
} |
||||
// Compile full regexp.
|
||||
reg, errCompile := regexp.Compile(pattern.String()) |
||||
if errCompile != nil { |
||||
return nil, errCompile |
||||
} |
||||
|
||||
// Check for capturing groups which used to work in older versions
|
||||
if reg.NumSubexp() != len(idxs)/2 { |
||||
panic(fmt.Sprintf("route %s contains capture groups in its regexp. ", template) + |
||||
"Only non-capturing groups are accepted: e.g. (?:pattern) instead of (pattern)") |
||||
} |
||||
|
||||
// Done!
|
||||
return &routeRegexp{ |
||||
template: template, |
||||
regexpType: typ, |
||||
options: options, |
||||
regexp: reg, |
||||
reverse: reverse.String(), |
||||
varsN: varsN, |
||||
varsR: varsR, |
||||
}, nil |
||||
} |
||||
|
||||
// routeRegexp stores a regexp to match a host or path and information to
|
||||
// collect and validate route variables.
|
||||
type routeRegexp struct { |
||||
// The unmodified template.
|
||||
template string |
||||
// The type of match
|
||||
regexpType regexpType |
||||
// Options for matching
|
||||
options routeRegexpOptions |
||||
// Expanded regexp.
|
||||
regexp *regexp.Regexp |
||||
// Reverse template.
|
||||
reverse string |
||||
// Variable names.
|
||||
varsN []string |
||||
// Variable regexps (validators).
|
||||
varsR []*regexp.Regexp |
||||
} |
||||
|
||||
// Match matches the regexp against the URL host or path.
|
||||
func (r *routeRegexp) Match(req *http.Request, match *RouteMatch) bool { |
||||
if r.regexpType != regexpTypeHost { |
||||
if r.regexpType == regexpTypeQuery { |
||||
return r.matchQueryString(req) |
||||
} |
||||
path := req.URL.Path |
||||
if r.options.useEncodedPath { |
||||
path = req.URL.EscapedPath() |
||||
} |
||||
return r.regexp.MatchString(path) |
||||
} |
||||
|
||||
return r.regexp.MatchString(getHost(req)) |
||||
} |
||||
|
||||
// url builds a URL part using the given values.
|
||||
func (r *routeRegexp) url(values map[string]string) (string, error) { |
||||
urlValues := make([]interface{}, len(r.varsN)) |
||||
for k, v := range r.varsN { |
||||
value, ok := values[v] |
||||
if !ok { |
||||
return "", fmt.Errorf("mux: missing route variable %q", v) |
||||
} |
||||
if r.regexpType == regexpTypeQuery { |
||||
value = url.QueryEscape(value) |
||||
} |
||||
urlValues[k] = value |
||||
} |
||||
rv := fmt.Sprintf(r.reverse, urlValues...) |
||||
if !r.regexp.MatchString(rv) { |
||||
// The URL is checked against the full regexp, instead of checking
|
||||
// individual variables. This is faster but to provide a good error
|
||||
// message, we check individual regexps if the URL doesn't match.
|
||||
for k, v := range r.varsN { |
||||
if !r.varsR[k].MatchString(values[v]) { |
||||
return "", fmt.Errorf( |
||||
"mux: variable %q doesn't match, expected %q", values[v], |
||||
r.varsR[k].String()) |
||||
} |
||||
} |
||||
} |
||||
return rv, nil |
||||
} |
||||
|
||||
// getURLQuery returns a single query parameter from a request URL.
|
||||
// For a URL with foo=bar&baz=ding, we return only the relevant key
|
||||
// value pair for the routeRegexp.
|
||||
func (r *routeRegexp) getURLQuery(req *http.Request) string { |
||||
if r.regexpType != regexpTypeQuery { |
||||
return "" |
||||
} |
||||
templateKey := strings.SplitN(r.template, "=", 2)[0] |
||||
for key, vals := range req.URL.Query() { |
||||
if key == templateKey && len(vals) > 0 { |
||||
return key + "=" + vals[0] |
||||
} |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
func (r *routeRegexp) matchQueryString(req *http.Request) bool { |
||||
return r.regexp.MatchString(r.getURLQuery(req)) |
||||
} |
||||
|
||||
// braceIndices returns the first level curly brace indices from a string.
|
||||
// It returns an error in case of unbalanced braces.
|
||||
func braceIndices(s string) ([]int, error) { |
||||
var level, idx int |
||||
var idxs []int |
||||
for i := 0; i < len(s); i++ { |
||||
switch s[i] { |
||||
case '{': |
||||
if level++; level == 1 { |
||||
idx = i |
||||
} |
||||
case '}': |
||||
if level--; level == 0 { |
||||
idxs = append(idxs, idx, i+1) |
||||
} else if level < 0 { |
||||
return nil, fmt.Errorf("mux: unbalanced braces in %q", s) |
||||
} |
||||
} |
||||
} |
||||
if level != 0 { |
||||
return nil, fmt.Errorf("mux: unbalanced braces in %q", s) |
||||
} |
||||
return idxs, nil |
||||
} |
||||
|
||||
// varGroupName builds a capturing group name for the indexed variable.
|
||||
func varGroupName(idx int) string { |
||||
return "v" + strconv.Itoa(idx) |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// routeRegexpGroup
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// routeRegexpGroup groups the route matchers that carry variables.
|
||||
type routeRegexpGroup struct { |
||||
host *routeRegexp |
||||
path *routeRegexp |
||||
queries []*routeRegexp |
||||
} |
||||
|
||||
// setMatch extracts the variables from the URL once a route matches.
|
||||
func (v *routeRegexpGroup) setMatch(req *http.Request, m *RouteMatch, r *Route) { |
||||
// Store host variables.
|
||||
if v.host != nil { |
||||
host := getHost(req) |
||||
matches := v.host.regexp.FindStringSubmatchIndex(host) |
||||
if len(matches) > 0 { |
||||
extractVars(host, matches, v.host.varsN, m.Vars) |
||||
} |
||||
} |
||||
path := req.URL.Path |
||||
if r.useEncodedPath { |
||||
path = req.URL.EscapedPath() |
||||
} |
||||
// Store path variables.
|
||||
if v.path != nil { |
||||
matches := v.path.regexp.FindStringSubmatchIndex(path) |
||||
if len(matches) > 0 { |
||||
extractVars(path, matches, v.path.varsN, m.Vars) |
||||
// Check if we should redirect.
|
||||
if v.path.options.strictSlash { |
||||
p1 := strings.HasSuffix(path, "/") |
||||
p2 := strings.HasSuffix(v.path.template, "/") |
||||
if p1 != p2 { |
||||
u, _ := url.Parse(req.URL.String()) |
||||
if p1 { |
||||
u.Path = u.Path[:len(u.Path)-1] |
||||
} else { |
||||
u.Path += "/" |
||||
} |
||||
m.Handler = http.RedirectHandler(u.String(), 301) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
// Store query string variables.
|
||||
for _, q := range v.queries { |
||||
queryURL := q.getURLQuery(req) |
||||
matches := q.regexp.FindStringSubmatchIndex(queryURL) |
||||
if len(matches) > 0 { |
||||
extractVars(queryURL, matches, q.varsN, m.Vars) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// getHost tries its best to return the request host.
|
||||
func getHost(r *http.Request) string { |
||||
if r.URL.IsAbs() { |
||||
return r.URL.Host |
||||
} |
||||
host := r.Host |
||||
// Slice off any port information.
|
||||
if i := strings.Index(host, ":"); i != -1 { |
||||
host = host[:i] |
||||
} |
||||
return host |
||||
|
||||
} |
||||
|
||||
func extractVars(input string, matches []int, names []string, output map[string]string) { |
||||
for i, name := range names { |
||||
output[name] = input[matches[2*i+2]:matches[2*i+3]] |
||||
} |
||||
} |
||||
@ -0,0 +1,763 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package mux |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"net/http" |
||||
"net/url" |
||||
"regexp" |
||||
"strings" |
||||
) |
||||
|
||||
// Route stores information to match a request and build URLs.
|
||||
type Route struct { |
||||
// Parent where the route was registered (a Router).
|
||||
parent parentRoute |
||||
// Request handler for the route.
|
||||
handler http.Handler |
||||
// List of matchers.
|
||||
matchers []matcher |
||||
// Manager for the variables from host and path.
|
||||
regexp *routeRegexpGroup |
||||
// If true, when the path pattern is "/path/", accessing "/path" will
|
||||
// redirect to the former and vice versa.
|
||||
strictSlash bool |
||||
// If true, when the path pattern is "/path//to", accessing "/path//to"
|
||||
// will not redirect
|
||||
skipClean bool |
||||
// If true, "/path/foo%2Fbar/to" will match the path "/path/{var}/to"
|
||||
useEncodedPath bool |
||||
// The scheme used when building URLs.
|
||||
buildScheme string |
||||
// If true, this route never matches: it is only used to build URLs.
|
||||
buildOnly bool |
||||
// The name used to build URLs.
|
||||
name string |
||||
// Error resulted from building a route.
|
||||
err error |
||||
|
||||
buildVarsFunc BuildVarsFunc |
||||
} |
||||
|
||||
// SkipClean reports whether path cleaning is enabled for this route via
|
||||
// Router.SkipClean.
|
||||
func (r *Route) SkipClean() bool { |
||||
return r.skipClean |
||||
} |
||||
|
||||
// Match matches the route against the request.
|
||||
func (r *Route) Match(req *http.Request, match *RouteMatch) bool { |
||||
if r.buildOnly || r.err != nil { |
||||
return false |
||||
} |
||||
|
||||
var matchErr error |
||||
|
||||
// Match everything.
|
||||
for _, m := range r.matchers { |
||||
if matched := m.Match(req, match); !matched { |
||||
if _, ok := m.(methodMatcher); ok { |
||||
matchErr = ErrMethodMismatch |
||||
continue |
||||
} |
||||
matchErr = nil |
||||
return false |
||||
} |
||||
} |
||||
|
||||
if matchErr != nil { |
||||
match.MatchErr = matchErr |
||||
return false |
||||
} |
||||
|
||||
if match.MatchErr == ErrMethodMismatch { |
||||
// We found a route which matches request method, clear MatchErr
|
||||
match.MatchErr = nil |
||||
// Then override the mis-matched handler
|
||||
match.Handler = r.handler |
||||
} |
||||
|
||||
// Yay, we have a match. Let's collect some info about it.
|
||||
if match.Route == nil { |
||||
match.Route = r |
||||
} |
||||
if match.Handler == nil { |
||||
match.Handler = r.handler |
||||
} |
||||
if match.Vars == nil { |
||||
match.Vars = make(map[string]string) |
||||
} |
||||
|
||||
// Set variables.
|
||||
if r.regexp != nil { |
||||
r.regexp.setMatch(req, match, r) |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Route attributes
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// GetError returns an error resulted from building the route, if any.
|
||||
func (r *Route) GetError() error { |
||||
return r.err |
||||
} |
||||
|
||||
// BuildOnly sets the route to never match: it is only used to build URLs.
|
||||
func (r *Route) BuildOnly() *Route { |
||||
r.buildOnly = true |
||||
return r |
||||
} |
||||
|
||||
// Handler --------------------------------------------------------------------
|
||||
|
||||
// Handler sets a handler for the route.
|
||||
func (r *Route) Handler(handler http.Handler) *Route { |
||||
if r.err == nil { |
||||
r.handler = handler |
||||
} |
||||
return r |
||||
} |
||||
|
||||
// HandlerFunc sets a handler function for the route.
|
||||
func (r *Route) HandlerFunc(f func(http.ResponseWriter, *http.Request)) *Route { |
||||
return r.Handler(http.HandlerFunc(f)) |
||||
} |
||||
|
||||
// GetHandler returns the handler for the route, if any.
|
||||
func (r *Route) GetHandler() http.Handler { |
||||
return r.handler |
||||
} |
||||
|
||||
// Name -----------------------------------------------------------------------
|
||||
|
||||
// Name sets the name for the route, used to build URLs.
|
||||
// If the name was registered already it will be overwritten.
|
||||
func (r *Route) Name(name string) *Route { |
||||
if r.name != "" { |
||||
r.err = fmt.Errorf("mux: route already has name %q, can't set %q", |
||||
r.name, name) |
||||
} |
||||
if r.err == nil { |
||||
r.name = name |
||||
r.getNamedRoutes()[name] = r |
||||
} |
||||
return r |
||||
} |
||||
|
||||
// GetName returns the name for the route, if any.
|
||||
func (r *Route) GetName() string { |
||||
return r.name |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Matchers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// matcher types try to match a request.
|
||||
type matcher interface { |
||||
Match(*http.Request, *RouteMatch) bool |
||||
} |
||||
|
||||
// addMatcher adds a matcher to the route.
|
||||
func (r *Route) addMatcher(m matcher) *Route { |
||||
if r.err == nil { |
||||
r.matchers = append(r.matchers, m) |
||||
} |
||||
return r |
||||
} |
||||
|
||||
// addRegexpMatcher adds a host or path matcher and builder to a route.
|
||||
func (r *Route) addRegexpMatcher(tpl string, typ regexpType) error { |
||||
if r.err != nil { |
||||
return r.err |
||||
} |
||||
r.regexp = r.getRegexpGroup() |
||||
if typ == regexpTypePath || typ == regexpTypePrefix { |
||||
if len(tpl) > 0 && tpl[0] != '/' { |
||||
return fmt.Errorf("mux: path must start with a slash, got %q", tpl) |
||||
} |
||||
if r.regexp.path != nil { |
||||
tpl = strings.TrimRight(r.regexp.path.template, "/") + tpl |
||||
} |
||||
} |
||||
rr, err := newRouteRegexp(tpl, typ, routeRegexpOptions{ |
||||
strictSlash: r.strictSlash, |
||||
useEncodedPath: r.useEncodedPath, |
||||
}) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
for _, q := range r.regexp.queries { |
||||
if err = uniqueVars(rr.varsN, q.varsN); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if typ == regexpTypeHost { |
||||
if r.regexp.path != nil { |
||||
if err = uniqueVars(rr.varsN, r.regexp.path.varsN); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
r.regexp.host = rr |
||||
} else { |
||||
if r.regexp.host != nil { |
||||
if err = uniqueVars(rr.varsN, r.regexp.host.varsN); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if typ == regexpTypeQuery { |
||||
r.regexp.queries = append(r.regexp.queries, rr) |
||||
} else { |
||||
r.regexp.path = rr |
||||
} |
||||
} |
||||
r.addMatcher(rr) |
||||
return nil |
||||
} |
||||
|
||||
// Headers --------------------------------------------------------------------
|
||||
|
||||
// headerMatcher matches the request against header values.
|
||||
type headerMatcher map[string]string |
||||
|
||||
func (m headerMatcher) Match(r *http.Request, match *RouteMatch) bool { |
||||
return matchMapWithString(m, r.Header, true) |
||||
} |
||||
|
||||
// Headers adds a matcher for request header values.
|
||||
// It accepts a sequence of key/value pairs to be matched. For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.Headers("Content-Type", "application/json",
|
||||
// "X-Requested-With", "XMLHttpRequest")
|
||||
//
|
||||
// The above route will only match if both request header values match.
|
||||
// If the value is an empty string, it will match any value if the key is set.
|
||||
func (r *Route) Headers(pairs ...string) *Route { |
||||
if r.err == nil { |
||||
var headers map[string]string |
||||
headers, r.err = mapFromPairsToString(pairs...) |
||||
return r.addMatcher(headerMatcher(headers)) |
||||
} |
||||
return r |
||||
} |
||||
|
||||
// headerRegexMatcher matches the request against the route given a regex for the header
|
||||
type headerRegexMatcher map[string]*regexp.Regexp |
||||
|
||||
func (m headerRegexMatcher) Match(r *http.Request, match *RouteMatch) bool { |
||||
return matchMapWithRegex(m, r.Header, true) |
||||
} |
||||
|
||||
// HeadersRegexp accepts a sequence of key/value pairs, where the value has regex
|
||||
// support. For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.HeadersRegexp("Content-Type", "application/(text|json)",
|
||||
// "X-Requested-With", "XMLHttpRequest")
|
||||
//
|
||||
// The above route will only match if both the request header matches both regular expressions.
|
||||
// If the value is an empty string, it will match any value if the key is set.
|
||||
// Use the start and end of string anchors (^ and $) to match an exact value.
|
||||
func (r *Route) HeadersRegexp(pairs ...string) *Route { |
||||
if r.err == nil { |
||||
var headers map[string]*regexp.Regexp |
||||
headers, r.err = mapFromPairsToRegex(pairs...) |
||||
return r.addMatcher(headerRegexMatcher(headers)) |
||||
} |
||||
return r |
||||
} |
||||
|
||||
// Host -----------------------------------------------------------------------
|
||||
|
||||
// Host adds a matcher for the URL host.
|
||||
// It accepts a template with zero or more URL variables enclosed by {}.
|
||||
// Variables can define an optional regexp pattern to be matched:
|
||||
//
|
||||
// - {name} matches anything until the next dot.
|
||||
//
|
||||
// - {name:pattern} matches the given regexp pattern.
|
||||
//
|
||||
// For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.Host("www.example.com")
|
||||
// r.Host("{subdomain}.domain.com")
|
||||
// r.Host("{subdomain:[a-z]+}.domain.com")
|
||||
//
|
||||
// Variable names must be unique in a given route. They can be retrieved
|
||||
// calling mux.Vars(request).
|
||||
func (r *Route) Host(tpl string) *Route { |
||||
r.err = r.addRegexpMatcher(tpl, regexpTypeHost) |
||||
return r |
||||
} |
||||
|
||||
// MatcherFunc ----------------------------------------------------------------
|
||||
|
||||
// MatcherFunc is the function signature used by custom matchers.
|
||||
type MatcherFunc func(*http.Request, *RouteMatch) bool |
||||
|
||||
// Match returns the match for a given request.
|
||||
func (m MatcherFunc) Match(r *http.Request, match *RouteMatch) bool { |
||||
return m(r, match) |
||||
} |
||||
|
||||
// MatcherFunc adds a custom function to be used as request matcher.
|
||||
func (r *Route) MatcherFunc(f MatcherFunc) *Route { |
||||
return r.addMatcher(f) |
||||
} |
||||
|
||||
// Methods --------------------------------------------------------------------
|
||||
|
||||
// methodMatcher matches the request against HTTP methods.
|
||||
type methodMatcher []string |
||||
|
||||
func (m methodMatcher) Match(r *http.Request, match *RouteMatch) bool { |
||||
return matchInArray(m, r.Method) |
||||
} |
||||
|
||||
// Methods adds a matcher for HTTP methods.
|
||||
// It accepts a sequence of one or more methods to be matched, e.g.:
|
||||
// "GET", "POST", "PUT".
|
||||
func (r *Route) Methods(methods ...string) *Route { |
||||
for k, v := range methods { |
||||
methods[k] = strings.ToUpper(v) |
||||
} |
||||
return r.addMatcher(methodMatcher(methods)) |
||||
} |
||||
|
||||
// Path -----------------------------------------------------------------------
|
||||
|
||||
// Path adds a matcher for the URL path.
|
||||
// It accepts a template with zero or more URL variables enclosed by {}. The
|
||||
// template must start with a "/".
|
||||
// Variables can define an optional regexp pattern to be matched:
|
||||
//
|
||||
// - {name} matches anything until the next slash.
|
||||
//
|
||||
// - {name:pattern} matches the given regexp pattern.
|
||||
//
|
||||
// For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.Path("/products/").Handler(ProductsHandler)
|
||||
// r.Path("/products/{key}").Handler(ProductsHandler)
|
||||
// r.Path("/articles/{category}/{id:[0-9]+}").
|
||||
// Handler(ArticleHandler)
|
||||
//
|
||||
// Variable names must be unique in a given route. They can be retrieved
|
||||
// calling mux.Vars(request).
|
||||
func (r *Route) Path(tpl string) *Route { |
||||
r.err = r.addRegexpMatcher(tpl, regexpTypePath) |
||||
return r |
||||
} |
||||
|
||||
// PathPrefix -----------------------------------------------------------------
|
||||
|
||||
// PathPrefix adds a matcher for the URL path prefix. This matches if the given
|
||||
// template is a prefix of the full URL path. See Route.Path() for details on
|
||||
// the tpl argument.
|
||||
//
|
||||
// Note that it does not treat slashes specially ("/foobar/" will be matched by
|
||||
// the prefix "/foo") so you may want to use a trailing slash here.
|
||||
//
|
||||
// Also note that the setting of Router.StrictSlash() has no effect on routes
|
||||
// with a PathPrefix matcher.
|
||||
func (r *Route) PathPrefix(tpl string) *Route { |
||||
r.err = r.addRegexpMatcher(tpl, regexpTypePrefix) |
||||
return r |
||||
} |
||||
|
||||
// Query ----------------------------------------------------------------------
|
||||
|
||||
// Queries adds a matcher for URL query values.
|
||||
// It accepts a sequence of key/value pairs. Values may define variables.
|
||||
// For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.Queries("foo", "bar", "id", "{id:[0-9]+}")
|
||||
//
|
||||
// The above route will only match if the URL contains the defined queries
|
||||
// values, e.g.: ?foo=bar&id=42.
|
||||
//
|
||||
// It the value is an empty string, it will match any value if the key is set.
|
||||
//
|
||||
// Variables can define an optional regexp pattern to be matched:
|
||||
//
|
||||
// - {name} matches anything until the next slash.
|
||||
//
|
||||
// - {name:pattern} matches the given regexp pattern.
|
||||
func (r *Route) Queries(pairs ...string) *Route { |
||||
length := len(pairs) |
||||
if length%2 != 0 { |
||||
r.err = fmt.Errorf( |
||||
"mux: number of parameters must be multiple of 2, got %v", pairs) |
||||
return nil |
||||
} |
||||
for i := 0; i < length; i += 2 { |
||||
if r.err = r.addRegexpMatcher(pairs[i]+"="+pairs[i+1], regexpTypeQuery); r.err != nil { |
||||
return r |
||||
} |
||||
} |
||||
|
||||
return r |
||||
} |
||||
|
||||
// Schemes --------------------------------------------------------------------
|
||||
|
||||
// schemeMatcher matches the request against URL schemes.
|
||||
type schemeMatcher []string |
||||
|
||||
func (m schemeMatcher) Match(r *http.Request, match *RouteMatch) bool { |
||||
return matchInArray(m, r.URL.Scheme) |
||||
} |
||||
|
||||
// Schemes adds a matcher for URL schemes.
|
||||
// It accepts a sequence of schemes to be matched, e.g.: "http", "https".
|
||||
func (r *Route) Schemes(schemes ...string) *Route { |
||||
for k, v := range schemes { |
||||
schemes[k] = strings.ToLower(v) |
||||
} |
||||
if r.buildScheme == "" && len(schemes) > 0 { |
||||
r.buildScheme = schemes[0] |
||||
} |
||||
return r.addMatcher(schemeMatcher(schemes)) |
||||
} |
||||
|
||||
// BuildVarsFunc --------------------------------------------------------------
|
||||
|
||||
// BuildVarsFunc is the function signature used by custom build variable
|
||||
// functions (which can modify route variables before a route's URL is built).
|
||||
type BuildVarsFunc func(map[string]string) map[string]string |
||||
|
||||
// BuildVarsFunc adds a custom function to be used to modify build variables
|
||||
// before a route's URL is built.
|
||||
func (r *Route) BuildVarsFunc(f BuildVarsFunc) *Route { |
||||
r.buildVarsFunc = f |
||||
return r |
||||
} |
||||
|
||||
// Subrouter ------------------------------------------------------------------
|
||||
|
||||
// Subrouter creates a subrouter for the route.
|
||||
//
|
||||
// It will test the inner routes only if the parent route matched. For example:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// s := r.Host("www.example.com").Subrouter()
|
||||
// s.HandleFunc("/products/", ProductsHandler)
|
||||
// s.HandleFunc("/products/{key}", ProductHandler)
|
||||
// s.HandleFunc("/articles/{category}/{id:[0-9]+}"), ArticleHandler)
|
||||
//
|
||||
// Here, the routes registered in the subrouter won't be tested if the host
|
||||
// doesn't match.
|
||||
func (r *Route) Subrouter() *Router { |
||||
router := &Router{parent: r, strictSlash: r.strictSlash} |
||||
r.addMatcher(router) |
||||
return router |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// URL building
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// URL builds a URL for the route.
|
||||
//
|
||||
// It accepts a sequence of key/value pairs for the route variables. For
|
||||
// example, given this route:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
|
||||
// Name("article")
|
||||
//
|
||||
// ...a URL for it can be built using:
|
||||
//
|
||||
// url, err := r.Get("article").URL("category", "technology", "id", "42")
|
||||
//
|
||||
// ...which will return an url.URL with the following path:
|
||||
//
|
||||
// "/articles/technology/42"
|
||||
//
|
||||
// This also works for host variables:
|
||||
//
|
||||
// r := mux.NewRouter()
|
||||
// r.Host("{subdomain}.domain.com").
|
||||
// HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
|
||||
// Name("article")
|
||||
//
|
||||
// // url.String() will be "http://news.domain.com/articles/technology/42"
|
||||
// url, err := r.Get("article").URL("subdomain", "news",
|
||||
// "category", "technology",
|
||||
// "id", "42")
|
||||
//
|
||||
// All variables defined in the route are required, and their values must
|
||||
// conform to the corresponding patterns.
|
||||
func (r *Route) URL(pairs ...string) (*url.URL, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
if r.regexp == nil { |
||||
return nil, errors.New("mux: route doesn't have a host or path") |
||||
} |
||||
values, err := r.prepareVars(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
var scheme, host, path string |
||||
queries := make([]string, 0, len(r.regexp.queries)) |
||||
if r.regexp.host != nil { |
||||
if host, err = r.regexp.host.url(values); err != nil { |
||||
return nil, err |
||||
} |
||||
scheme = "http" |
||||
if s := r.getBuildScheme(); s != "" { |
||||
scheme = s |
||||
} |
||||
} |
||||
if r.regexp.path != nil { |
||||
if path, err = r.regexp.path.url(values); err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
for _, q := range r.regexp.queries { |
||||
var query string |
||||
if query, err = q.url(values); err != nil { |
||||
return nil, err |
||||
} |
||||
queries = append(queries, query) |
||||
} |
||||
return &url.URL{ |
||||
Scheme: scheme, |
||||
Host: host, |
||||
Path: path, |
||||
RawQuery: strings.Join(queries, "&"), |
||||
}, nil |
||||
} |
||||
|
||||
// URLHost builds the host part of the URL for a route. See Route.URL().
|
||||
//
|
||||
// The route must have a host defined.
|
||||
func (r *Route) URLHost(pairs ...string) (*url.URL, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.host == nil { |
||||
return nil, errors.New("mux: route doesn't have a host") |
||||
} |
||||
values, err := r.prepareVars(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
host, err := r.regexp.host.url(values) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
u := &url.URL{ |
||||
Scheme: "http", |
||||
Host: host, |
||||
} |
||||
if s := r.getBuildScheme(); s != "" { |
||||
u.Scheme = s |
||||
} |
||||
return u, nil |
||||
} |
||||
|
||||
// URLPath builds the path part of the URL for a route. See Route.URL().
|
||||
//
|
||||
// The route must have a path defined.
|
||||
func (r *Route) URLPath(pairs ...string) (*url.URL, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.path == nil { |
||||
return nil, errors.New("mux: route doesn't have a path") |
||||
} |
||||
values, err := r.prepareVars(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
path, err := r.regexp.path.url(values) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &url.URL{ |
||||
Path: path, |
||||
}, nil |
||||
} |
||||
|
||||
// GetPathTemplate returns the template used to build the
|
||||
// route match.
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if the route does not define a path.
|
||||
func (r *Route) GetPathTemplate() (string, error) { |
||||
if r.err != nil { |
||||
return "", r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.path == nil { |
||||
return "", errors.New("mux: route doesn't have a path") |
||||
} |
||||
return r.regexp.path.template, nil |
||||
} |
||||
|
||||
// GetPathRegexp returns the expanded regular expression used to match route path.
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if the route does not define a path.
|
||||
func (r *Route) GetPathRegexp() (string, error) { |
||||
if r.err != nil { |
||||
return "", r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.path == nil { |
||||
return "", errors.New("mux: route does not have a path") |
||||
} |
||||
return r.regexp.path.regexp.String(), nil |
||||
} |
||||
|
||||
// GetQueriesRegexp returns the expanded regular expressions used to match the
|
||||
// route queries.
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if the route does not have queries.
|
||||
func (r *Route) GetQueriesRegexp() ([]string, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.queries == nil { |
||||
return nil, errors.New("mux: route doesn't have queries") |
||||
} |
||||
var queries []string |
||||
for _, query := range r.regexp.queries { |
||||
queries = append(queries, query.regexp.String()) |
||||
} |
||||
return queries, nil |
||||
} |
||||
|
||||
// GetQueriesTemplates returns the templates used to build the
|
||||
// query matching.
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if the route does not define queries.
|
||||
func (r *Route) GetQueriesTemplates() ([]string, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.queries == nil { |
||||
return nil, errors.New("mux: route doesn't have queries") |
||||
} |
||||
var queries []string |
||||
for _, query := range r.regexp.queries { |
||||
queries = append(queries, query.template) |
||||
} |
||||
return queries, nil |
||||
} |
||||
|
||||
// GetMethods returns the methods the route matches against
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if route does not have methods.
|
||||
func (r *Route) GetMethods() ([]string, error) { |
||||
if r.err != nil { |
||||
return nil, r.err |
||||
} |
||||
for _, m := range r.matchers { |
||||
if methods, ok := m.(methodMatcher); ok { |
||||
return []string(methods), nil |
||||
} |
||||
} |
||||
return nil, errors.New("mux: route doesn't have methods") |
||||
} |
||||
|
||||
// GetHostTemplate returns the template used to build the
|
||||
// route match.
|
||||
// This is useful for building simple REST API documentation and for instrumentation
|
||||
// against third-party services.
|
||||
// An error will be returned if the route does not define a host.
|
||||
func (r *Route) GetHostTemplate() (string, error) { |
||||
if r.err != nil { |
||||
return "", r.err |
||||
} |
||||
if r.regexp == nil || r.regexp.host == nil { |
||||
return "", errors.New("mux: route doesn't have a host") |
||||
} |
||||
return r.regexp.host.template, nil |
||||
} |
||||
|
||||
// prepareVars converts the route variable pairs into a map. If the route has a
|
||||
// BuildVarsFunc, it is invoked.
|
||||
func (r *Route) prepareVars(pairs ...string) (map[string]string, error) { |
||||
m, err := mapFromPairsToString(pairs...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return r.buildVars(m), nil |
||||
} |
||||
|
||||
func (r *Route) buildVars(m map[string]string) map[string]string { |
||||
if r.parent != nil { |
||||
m = r.parent.buildVars(m) |
||||
} |
||||
if r.buildVarsFunc != nil { |
||||
m = r.buildVarsFunc(m) |
||||
} |
||||
return m |
||||
} |
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// parentRoute
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// parentRoute allows routes to know about parent host and path definitions.
|
||||
type parentRoute interface { |
||||
getBuildScheme() string |
||||
getNamedRoutes() map[string]*Route |
||||
getRegexpGroup() *routeRegexpGroup |
||||
buildVars(map[string]string) map[string]string |
||||
} |
||||
|
||||
func (r *Route) getBuildScheme() string { |
||||
if r.buildScheme != "" { |
||||
return r.buildScheme |
||||
} |
||||
if r.parent != nil { |
||||
return r.parent.getBuildScheme() |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
// getNamedRoutes returns the map where named routes are registered.
|
||||
func (r *Route) getNamedRoutes() map[string]*Route { |
||||
if r.parent == nil { |
||||
// During tests router is not always set.
|
||||
r.parent = NewRouter() |
||||
} |
||||
return r.parent.getNamedRoutes() |
||||
} |
||||
|
||||
// getRegexpGroup returns regexp definitions from this route.
|
||||
func (r *Route) getRegexpGroup() *routeRegexpGroup { |
||||
if r.regexp == nil { |
||||
if r.parent == nil { |
||||
// During tests router is not always set.
|
||||
r.parent = NewRouter() |
||||
} |
||||
regexp := r.parent.getRegexpGroup() |
||||
if regexp == nil { |
||||
r.regexp = new(routeRegexpGroup) |
||||
} else { |
||||
// Copy.
|
||||
r.regexp = &routeRegexpGroup{ |
||||
host: regexp.host, |
||||
path: regexp.path, |
||||
queries: regexp.queries, |
||||
} |
||||
} |
||||
} |
||||
return r.regexp |
||||
} |
||||
@ -0,0 +1,19 @@
|
||||
// Copyright 2012 The Gorilla Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package mux |
||||
|
||||
import "net/http" |
||||
|
||||
// SetURLVars sets the URL variables for the given request, to be accessed via
|
||||
// mux.Vars for testing route behaviour. Arguments are not modified, a shallow
|
||||
// copy is returned.
|
||||
//
|
||||
// This API should only be used for testing purposes; it provides a way to
|
||||
// inject variables into the request context. Alternatively, URL variables
|
||||
// can be set by making a route that captures the required variables,
|
||||
// starting a server and sending the request to that server.
|
||||
func SetURLVars(r *http.Request, val map[string]string) *http.Request { |
||||
return setVars(r, val) |
||||
} |
||||
@ -1,8 +0,0 @@
|
||||
sudo: false |
||||
language: go |
||||
go: |
||||
- 1.1 |
||||
- 1.2 |
||||
- 1.3 |
||||
- 1.4 |
||||
- tip |
||||
@ -1,24 +0,0 @@
|
||||
Copyright (c) 2013 Julien Schmidt. All rights reserved. |
||||
|
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are met: |
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above copyright |
||||
notice, this list of conditions and the following disclaimer in the |
||||
documentation and/or other materials provided with the distribution. |
||||
* The names of the contributors may not be used to endorse or promote |
||||
products derived from this software without specific prior written |
||||
permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
DISCLAIMED. IN NO EVENT SHALL JULIEN SCHMIDT BE LIABLE FOR ANY |
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -1,323 +0,0 @@
|
||||
# HttpRouter [](https://travis-ci.org/julienschmidt/httprouter) [](http://gocover.io/github.com/julienschmidt/httprouter) [](http://godoc.org/github.com/julienschmidt/httprouter) |
||||
|
||||
HttpRouter is a lightweight high performance HTTP request router |
||||
(also called *multiplexer* or just *mux* for short) for [Go](http://golang.org/). |
||||
|
||||
In contrast to the [default mux](http://golang.org/pkg/net/http/#ServeMux) of Go's net/http package, this router supports |
||||
variables in the routing pattern and matches against the request method. |
||||
It also scales better. |
||||
|
||||
The router is optimized for high performance and a small memory footprint. |
||||
It scales well even with very long paths and a large number of routes. |
||||
A compressing dynamic trie (radix tree) structure is used for efficient matching. |
||||
|
||||
## Features |
||||
**Only explicit matches:** With other routers, like [http.ServeMux](http://golang.org/pkg/net/http/#ServeMux), |
||||
a requested URL path could match multiple patterns. Therefore they have some |
||||
awkward pattern priority rules, like *longest match* or *first registered, |
||||
first matched*. By design of this router, a request can only match exactly one |
||||
or no route. As a result, there are also no unintended matches, which makes it |
||||
great for SEO and improves the user experience. |
||||
|
||||
**Stop caring about trailing slashes:** Choose the URL style you like, the |
||||
router automatically redirects the client if a trailing slash is missing or if |
||||
there is one extra. Of course it only does so, if the new path has a handler. |
||||
If you don't like it, you can [turn off this behavior](http://godoc.org/github.com/julienschmidt/httprouter#Router.RedirectTrailingSlash). |
||||
|
||||
**Path auto-correction:** Besides detecting the missing or additional trailing |
||||
slash at no extra cost, the router can also fix wrong cases and remove |
||||
superfluous path elements (like `../` or `//`). |
||||
Is [CAPTAIN CAPS LOCK](http://www.urbandictionary.com/define.php?term=Captain+Caps+Lock) one of your users? |
||||
HttpRouter can help him by making a case-insensitive look-up and redirecting him |
||||
to the correct URL. |
||||
|
||||
**Parameters in your routing pattern:** Stop parsing the requested URL path, |
||||
just give the path segment a name and the router delivers the dynamic value to |
||||
you. Because of the design of the router, path parameters are very cheap. |
||||
|
||||
**Zero Garbage:** The matching and dispatching process generates zero bytes of |
||||
garbage. In fact, the only heap allocations that are made, is by building the |
||||
slice of the key-value pairs for path parameters. If the request path contains |
||||
no parameters, not a single heap allocation is necessary. |
||||
|
||||
**Best Performance:** [Benchmarks speak for themselves](https://github.com/julienschmidt/go-http-routing-benchmark). |
||||
See below for technical details of the implementation. |
||||
|
||||
**No more server crashes:** You can set a [Panic handler](http://godoc.org/github.com/julienschmidt/httprouter#Router.PanicHandler) to deal with panics |
||||
occurring during handling a HTTP request. The router then recovers and lets the |
||||
PanicHandler log what happened and deliver a nice error page. |
||||
|
||||
Of course you can also set **custom [NotFound](http://godoc.org/github.com/julienschmidt/httprouter#Router.NotFound) and [MethodNotAllowed](http://godoc.org/github.com/julienschmidt/httprouter#Router.MethodNotAllowed) handlers** and [**serve static files**](http://godoc.org/github.com/julienschmidt/httprouter#Router.ServeFiles). |
||||
|
||||
## Usage |
||||
This is just a quick introduction, view the [GoDoc](http://godoc.org/github.com/julienschmidt/httprouter) for details. |
||||
|
||||
Let's start with a trivial example: |
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"github.com/julienschmidt/httprouter" |
||||
"net/http" |
||||
"log" |
||||
) |
||||
|
||||
func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { |
||||
fmt.Fprint(w, "Welcome!\n") |
||||
} |
||||
|
||||
func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) { |
||||
fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name")) |
||||
} |
||||
|
||||
func main() { |
||||
router := httprouter.New() |
||||
router.GET("/", Index) |
||||
router.GET("/hello/:name", Hello) |
||||
|
||||
log.Fatal(http.ListenAndServe(":8080", router)) |
||||
} |
||||
``` |
||||
|
||||
### Named parameters |
||||
As you can see, `:name` is a *named parameter*. |
||||
The values are accessible via `httprouter.Params`, which is just a slice of `httprouter.Param`s. |
||||
You can get the value of a parameter either by its index in the slice, or by using the `ByName(name)` method: |
||||
`:name` can be retrived by `ByName("name")`. |
||||
|
||||
Named parameters only match a single path segment: |
||||
``` |
||||
Pattern: /user/:user |
||||
|
||||
/user/gordon match |
||||
/user/you match |
||||
/user/gordon/profile no match |
||||
/user/ no match |
||||
``` |
||||
|
||||
**Note:** Since this router has only explicit matches, you can not register static routes and parameters for the same path segment. For example you can not register the patterns `/user/new` and `/user/:user` for the same request method at the same time. The routing of different request methods is independent from each other. |
||||
|
||||
### Catch-All parameters |
||||
The second type are *catch-all* parameters and have the form `*name`. |
||||
Like the name suggests, they match everything. |
||||
Therefore they must always be at the **end** of the pattern: |
||||
``` |
||||
Pattern: /src/*filepath |
||||
|
||||
/src/ match |
||||
/src/somefile.go match |
||||
/src/subdir/somefile.go match |
||||
``` |
||||
|
||||
## How does it work? |
||||
The router relies on a tree structure which makes heavy use of *common prefixes*, |
||||
it is basically a *compact* [*prefix tree*](http://en.wikipedia.org/wiki/Trie) |
||||
(or just [*Radix tree*](http://en.wikipedia.org/wiki/Radix_tree)). |
||||
Nodes with a common prefix also share a common parent. Here is a short example |
||||
what the routing tree for the `GET` request method could look like: |
||||
|
||||
``` |
||||
Priority Path Handle |
||||
9 \ *<1> |
||||
3 ├s nil |
||||
2 |├earch\ *<2> |
||||
1 |└upport\ *<3> |
||||
2 ├blog\ *<4> |
||||
1 | └:post nil |
||||
1 | └\ *<5> |
||||
2 ├about-us\ *<6> |
||||
1 | └team\ *<7> |
||||
1 └contact\ *<8> |
||||
``` |
||||
Every `*<num>` represents the memory address of a handler function (a pointer). |
||||
If you follow a path trough the tree from the root to the leaf, you get the |
||||
complete route path, e.g `\blog\:post\`, where `:post` is just a placeholder |
||||
([*parameter*](#named-parameters)) for an actual post name. Unlike hash-maps, a |
||||
tree structure also allows us to use dynamic parts like the `:post` parameter, |
||||
since we actually match against the routing patterns instead of just comparing |
||||
hashes. [As benchmarks show](https://github.com/julienschmidt/go-http-routing-benchmark), |
||||
this works very well and efficient. |
||||
|
||||
Since URL paths have a hierarchical structure and make use only of a limited set |
||||
of characters (byte values), it is very likely that there are a lot of common |
||||
prefixes. This allows us to easily reduce the routing into ever smaller problems. |
||||
Moreover the router manages a separate tree for every request method. |
||||
For one thing it is more space efficient than holding a method->handle map in |
||||
every single node, for another thing is also allows us to greatly reduce the |
||||
routing problem before even starting the look-up in the prefix-tree. |
||||
|
||||
For even better scalability, the child nodes on each tree level are ordered by |
||||
priority, where the priority is just the number of handles registered in sub |
||||
nodes (children, grandchildren, and so on..). |
||||
This helps in two ways: |
||||
|
||||
1. Nodes which are part of the most routing paths are evaluated first. This |
||||
helps to make as much routes as possible to be reachable as fast as possible. |
||||
2. It is some sort of cost compensation. The longest reachable path (highest |
||||
cost) can always be evaluated first. The following scheme visualizes the tree |
||||
structure. Nodes are evaluated from top to bottom and from left to right. |
||||
|
||||
``` |
||||
├------------ |
||||
├--------- |
||||
├----- |
||||
├---- |
||||
├-- |
||||
├-- |
||||
└- |
||||
``` |
||||
|
||||
|
||||
## Why doesn't this work with http.Handler? |
||||
**It does!** The router itself implements the http.Handler interface. |
||||
Moreover the router provides convenient [adapters for http.Handler](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handler)s and [http.HandlerFunc](http://godoc.org/github.com/julienschmidt/httprouter#Router.HandlerFunc)s |
||||
which allows them to be used as a [httprouter.Handle](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handle) when registering a route. |
||||
The only disadvantage is, that no parameter values can be retrieved when a |
||||
http.Handler or http.HandlerFunc is used, since there is no efficient way to |
||||
pass the values with the existing function parameters. |
||||
Therefore [httprouter.Handle](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handle) has a third function parameter. |
||||
|
||||
Just try it out for yourself, the usage of HttpRouter is very straightforward. The package is compact and minimalistic, but also probably one of the easiest routers to set up. |
||||
|
||||
|
||||
## Where can I find Middleware *X*? |
||||
This package just provides a very efficient request router with a few extra |
||||
features. The router is just a [http.Handler](http://golang.org/pkg/net/http/#Handler), |
||||
you can chain any http.Handler compatible middleware before the router, |
||||
for example the [Gorilla handlers](http://www.gorillatoolkit.org/pkg/handlers). |
||||
Or you could [just write your own](http://justinas.org/writing-http-middleware-in-go/), |
||||
it's very easy! |
||||
|
||||
Alternatively, you could try [a web framework based on HttpRouter](#web-frameworks-based-on-httprouter). |
||||
|
||||
### Multi-domain / Sub-domains |
||||
Here is a quick example: Does your server serve multiple domains / hosts? |
||||
You want to use sub-domains? |
||||
Define a router per host! |
||||
```go |
||||
// We need an object that implements the http.Handler interface. |
||||
// Therefore we need a type for which we implement the ServeHTTP method. |
||||
// We just use a map here, in which we map host names (with port) to http.Handlers |
||||
type HostSwitch map[string]http.Handler |
||||
|
||||
// Implement the ServerHTTP method on our new type |
||||
func (hs HostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) { |
||||
// Check if a http.Handler is registered for the given host. |
||||
// If yes, use it to handle the request. |
||||
if handler := hs[r.Host]; handler != nil { |
||||
handler.ServeHTTP(w, r) |
||||
} else { |
||||
// Handle host names for wich no handler is registered |
||||
http.Error(w, "Forbidden", 403) // Or Redirect? |
||||
} |
||||
} |
||||
|
||||
func main() { |
||||
// Initialize a router as usual |
||||
router := httprouter.New() |
||||
router.GET("/", Index) |
||||
router.GET("/hello/:name", Hello) |
||||
|
||||
// Make a new HostSwitch and insert the router (our http handler) |
||||
// for example.com and port 12345 |
||||
hs := make(HostSwitch) |
||||
hs["example.com:12345"] = router |
||||
|
||||
// Use the HostSwitch to listen and serve on port 12345 |
||||
log.Fatal(http.ListenAndServe(":12345", hs)) |
||||
} |
||||
``` |
||||
|
||||
### Basic Authentication |
||||
Another quick example: Basic Authentification (RFC 2617) for handles: |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/base64" |
||||
"fmt" |
||||
"github.com/julienschmidt/httprouter" |
||||
"net/http" |
||||
"log" |
||||
"strings" |
||||
) |
||||
|
||||
func BasicAuth(h httprouter.Handle, user, pass []byte) httprouter.Handle { |
||||
return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) { |
||||
const basicAuthPrefix string = "Basic " |
||||
|
||||
// Get the Basic Authentication credentials |
||||
auth := r.Header.Get("Authorization") |
||||
if strings.HasPrefix(auth, basicAuthPrefix) { |
||||
// Check credentials |
||||
payload, err := base64.StdEncoding.DecodeString(auth[len(basicAuthPrefix):]) |
||||
if err == nil { |
||||
pair := bytes.SplitN(payload, []byte(":"), 2) |
||||
if len(pair) == 2 && |
||||
bytes.Equal(pair[0], user) && |
||||
bytes.Equal(pair[1], pass) { |
||||
|
||||
// Delegate request to the given handle |
||||
h(w, r, ps) |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Request Basic Authentication otherwise |
||||
w.Header().Set("WWW-Authenticate", "Basic realm=Restricted") |
||||
http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized) |
||||
} |
||||
} |
||||
|
||||
func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { |
||||
fmt.Fprint(w, "Not protected!\n") |
||||
} |
||||
|
||||
func Protected(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { |
||||
fmt.Fprint(w, "Protected!\n") |
||||
} |
||||
|
||||
func main() { |
||||
user := []byte("gordon") |
||||
pass := []byte("secret!") |
||||
|
||||
router := httprouter.New() |
||||
router.GET("/", Index) |
||||
router.GET("/protected/", BasicAuth(Protected, user, pass)) |
||||
|
||||
log.Fatal(http.ListenAndServe(":8080", router)) |
||||
} |
||||
``` |
||||
|
||||
## Chaining with the NotFound handler |
||||
|
||||
**NOTE: It might be required to set [Router.HandleMethodNotAllowed](http://godoc.org/github.com/julienschmidt/httprouter#Router.HandleMethodNotAllowed) to `false` to avoid problems.** |
||||
|
||||
You can use another [http.HandlerFunc](http://golang.org/pkg/net/http/#HandlerFunc), for example another router, to handle requests which could not be matched by this router by using the [Router.NotFound](http://godoc.org/github.com/julienschmidt/httprouter#Router.NotFound) handler. This allows chaining. |
||||
|
||||
### Static files |
||||
The `NotFound` handler can for example be used to serve static files from the root path `/` (like an index.html file along with other assets): |
||||
```go |
||||
// Serve static files from the ./public directory |
||||
router.NotFound = http.FileServer(http.Dir("public")).ServeHTTP |
||||
``` |
||||
|
||||
But this approach sidesteps the strict core rules of this router to avoid routing problems. A cleaner approach is to use a distinct sub-path for serving files, like `/static/*filepath` or `/files/*filepath`. |
||||
|
||||
## Web Frameworks based on HttpRouter |
||||
If the HttpRouter is a bit too minimalistic for you, you might try one of the following more high-level 3rd-party web frameworks building upon the HttpRouter package: |
||||
* [Ace](https://github.com/plimble/ace): Blazing fast Go Web Framework |
||||
* [api2go](https://github.com/univedo/api2go): A JSON API Implementation for Go |
||||
* [Gin](https://github.com/gin-gonic/gin): Features a martini-like API with much better performance |
||||
* [Goat](https://github.com/bahlo/goat): A minimalistic REST API server in Go |
||||
* [Hikaru](https://github.com/najeira/hikaru): Supports standalone and Google AppEngine |
||||
* [Hitch](https://github.com/nbio/hitch): Hitch ties httprouter, [httpcontext](https://github.com/nbio/httpcontext), and middleware up in a bow |
||||
* [kami](https://github.com/guregu/kami): A tiny web framework using x/net/context |
||||
* [Medeina](https://github.com/imdario/medeina): Inspired by Ruby's Roda and Cuba |
||||
* [Neko](https://github.com/rocwong/neko): A lightweight web application framework for Golang |
||||
* [Roxanna](https://github.com/iamthemuffinman/Roxanna): An amalgamation of httprouter, better logging, and hot reload |
||||
* [siesta](https://github.com/VividCortex/siesta): Composable HTTP handlers with contexts |
||||
@ -1,123 +0,0 @@
|
||||
// Copyright 2013 Julien Schmidt. All rights reserved.
|
||||
// Based on the path package, Copyright 2009 The Go Authors.
|
||||
// Use of this source code is governed by a BSD-style license that can be found
|
||||
// in the LICENSE file.
|
||||
|
||||
package httprouter |
||||
|
||||
// CleanPath 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 CleanPath(p string) string { |
||||
// Turn empty string into "/"
|
||||
if p == "" { |
||||
return "/" |
||||
} |
||||
|
||||
n := len(p) |
||||
var buf []byte |
||||
|
||||
// Invariants:
|
||||
// reading from path; r is index of next byte to process.
|
||||
// writing to buf; w is index of next byte to write.
|
||||
|
||||
// path must start with '/'
|
||||
r := 1 |
||||
w := 1 |
||||
|
||||
if p[0] != '/' { |
||||
r = 0 |
||||
buf = make([]byte, n+1) |
||||
buf[0] = '/' |
||||
} |
||||
|
||||
trailing := n > 2 && p[n-1] == '/' |
||||
|
||||
// A bit more clunky without a 'lazybuf' like the path package, but the loop
|
||||
// gets completely inlined (bufApp). So in contrast to the path package this
|
||||
// loop has no expensive function calls (except 1x make)
|
||||
|
||||
for r < n { |
||||
switch { |
||||
case p[r] == '/': |
||||
// empty path element, trailing slash is added after the end
|
||||
r++ |
||||
|
||||
case p[r] == '.' && r+1 == n: |
||||
trailing = true |
||||
r++ |
||||
|
||||
case p[r] == '.' && p[r+1] == '/': |
||||
// . element
|
||||
r++ |
||||
|
||||
case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'): |
||||
// .. element: remove to last /
|
||||
r += 2 |
||||
|
||||
if w > 1 { |
||||
// can backtrack
|
||||
w-- |
||||
|
||||
if buf == nil { |
||||
for w > 1 && p[w] != '/' { |
||||
w-- |
||||
} |
||||
} else { |
||||
for w > 1 && buf[w] != '/' { |
||||
w-- |
||||
} |
||||
} |
||||
} |
||||
|
||||
default: |
||||
// real path element.
|
||||
// add slash if needed
|
||||
if w > 1 { |
||||
bufApp(&buf, p, w, '/') |
||||
w++ |
||||
} |
||||
|
||||
// copy element
|
||||
for r < n && p[r] != '/' { |
||||
bufApp(&buf, p, w, p[r]) |
||||
w++ |
||||
r++ |
||||
} |
||||
} |
||||
} |
||||
|
||||
// re-append trailing slash
|
||||
if trailing && w > 1 { |
||||
bufApp(&buf, p, w, '/') |
||||
w++ |
||||
} |
||||
|
||||
if buf == nil { |
||||
return p[:w] |
||||
} |
||||
return string(buf[:w]) |
||||
} |
||||
|
||||
// internal helper to lazily create a buffer if necessary
|
||||
func bufApp(buf *[]byte, s string, w int, c byte) { |
||||
if *buf == nil { |
||||
if s[w] == c { |
||||
return |
||||
} |
||||
|
||||
*buf = make([]byte, len(s)) |
||||
copy(*buf, s[:w]) |
||||
} |
||||
(*buf)[w] = c |
||||
} |
||||
@ -1,363 +0,0 @@
|
||||
// Copyright 2013 Julien Schmidt. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be found
|
||||
// in the LICENSE file.
|
||||
|
||||
// Package httprouter is a trie based high performance HTTP request router.
|
||||
//
|
||||
// A trivial example is:
|
||||
//
|
||||
// package main
|
||||
//
|
||||
// import (
|
||||
// "fmt"
|
||||
// "github.com/julienschmidt/httprouter"
|
||||
// "net/http"
|
||||
// "log"
|
||||
// )
|
||||
//
|
||||
// func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
|
||||
// fmt.Fprint(w, "Welcome!\n")
|
||||
// }
|
||||
//
|
||||
// func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
||||
// fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
|
||||
// }
|
||||
//
|
||||
// func main() {
|
||||
// router := httprouter.New()
|
||||
// router.GET("/", Index)
|
||||
// router.GET("/hello/:name", Hello)
|
||||
//
|
||||
// log.Fatal(http.ListenAndServe(":8080", router))
|
||||
// }
|
||||
//
|
||||
// The router matches incoming requests by the request method and the path.
|
||||
// If a handle is registered for this path and method, the router delegates the
|
||||
// request to that function.
|
||||
// For the methods GET, POST, PUT, PATCH and DELETE shortcut functions exist to
|
||||
// register handles, for all other methods router.Handle can be used.
|
||||
//
|
||||
// The registered path, against which the router matches incoming requests, can
|
||||
// contain two types of parameters:
|
||||
// Syntax Type
|
||||
// :name named parameter
|
||||
// *name catch-all parameter
|
||||
//
|
||||
// Named parameters are dynamic path segments. They match anything until the
|
||||
// next '/' or the path end:
|
||||
// Path: /blog/:category/:post
|
||||
//
|
||||
// Requests:
|
||||
// /blog/go/request-routers match: category="go", post="request-routers"
|
||||
// /blog/go/request-routers/ no match, but the router would redirect
|
||||
// /blog/go/ no match
|
||||
// /blog/go/request-routers/comments no match
|
||||
//
|
||||
// Catch-all parameters match anything until the path end, including the
|
||||
// directory index (the '/' before the catch-all). Since they match anything
|
||||
// until the end, catch-all paramerters must always be the final path element.
|
||||
// Path: /files/*filepath
|
||||
//
|
||||
// Requests:
|
||||
// /files/ match: filepath="/"
|
||||
// /files/LICENSE match: filepath="/LICENSE"
|
||||
// /files/templates/article.html match: filepath="/templates/article.html"
|
||||
// /files no match, but the router would redirect
|
||||
//
|
||||
// The value of parameters is saved as a slice of the Param struct, consisting
|
||||
// each of a key and a value. The slice is passed to the Handle func as a third
|
||||
// parameter.
|
||||
// There are two ways to retrieve the value of a parameter:
|
||||
// // by the name of the parameter
|
||||
// user := ps.ByName("user") // defined by :user or *user
|
||||
//
|
||||
// // by the index of the parameter. This way you can also get the name (key)
|
||||
// thirdKey := ps[2].Key // the name of the 3rd parameter
|
||||
// thirdValue := ps[2].Value // the value of the 3rd parameter
|
||||
package httprouter |
||||
|
||||
import ( |
||||
"net/http" |
||||
) |
||||
|
||||
// Handle is a function that can be registered to a route to handle HTTP
|
||||
// requests. Like http.HandlerFunc, but has a third parameter for the values of
|
||||
// wildcards (variables).
|
||||
type Handle func(http.ResponseWriter, *http.Request, Params) |
||||
|
||||
// Param is a single URL parameter, consisting of a key and a value.
|
||||
type Param struct { |
||||
Key string |
||||
Value string |
||||
} |
||||
|
||||
// Params is a Param-slice, as returned by the router.
|
||||
// The slice is ordered, the first URL parameter is also the first slice value.
|
||||
// It is therefore safe to read values by the index.
|
||||
type Params []Param |
||||
|
||||
// ByName returns the value of the first Param which key matches the given name.
|
||||
// If no matching Param is found, an empty string is returned.
|
||||
func (ps Params) ByName(name string) string { |
||||
for i := range ps { |
||||
if ps[i].Key == name { |
||||
return ps[i].Value |
||||
} |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
// Router is a http.Handler which can be used to dispatch requests to different
|
||||
// handler functions via configurable routes
|
||||
type Router struct { |
||||
trees map[string]*node |
||||
|
||||
// Enables automatic redirection if the current route can't be matched but a
|
||||
// handler for the path with (without) the trailing slash exists.
|
||||
// For example if /foo/ is requested but a route only exists for /foo, the
|
||||
// client is redirected to /foo with http status code 301 for GET requests
|
||||
// and 307 for all other request methods.
|
||||
RedirectTrailingSlash bool |
||||
|
||||
// If enabled, the router tries to fix the current request path, if no
|
||||
// handle is registered for it.
|
||||
// First superfluous path elements like ../ or // are removed.
|
||||
// Afterwards the router does a case-insensitive lookup of the cleaned path.
|
||||
// If a handle can be found for this route, the router makes a redirection
|
||||
// to the corrected path with status code 301 for GET requests and 307 for
|
||||
// all other request methods.
|
||||
// For example /FOO and /..//Foo could be redirected to /foo.
|
||||
// RedirectTrailingSlash is independent of this option.
|
||||
RedirectFixedPath bool |
||||
|
||||
// If enabled, the router checks if another method is allowed for the
|
||||
// current route, if the current request can not be routed.
|
||||
// If this is the case, the request is answered with 'Method Not Allowed'
|
||||
// and HTTP status code 405.
|
||||
// If no other Method is allowed, the request is delegated to the NotFound
|
||||
// handler.
|
||||
HandleMethodNotAllowed bool |
||||
|
||||
// Configurable http.HandlerFunc which is called when no matching route is
|
||||
// found. If it is not set, http.NotFound is used.
|
||||
NotFound http.HandlerFunc |
||||
|
||||
// Configurable http.HandlerFunc which is called when a request
|
||||
// cannot be routed and HandleMethodNotAllowed is true.
|
||||
// If it is not set, http.Error with http.StatusMethodNotAllowed is used.
|
||||
MethodNotAllowed http.HandlerFunc |
||||
|
||||
// Function to handle panics recovered from http handlers.
|
||||
// It should be used to generate a error page and return the http error code
|
||||
// 500 (Internal Server Error).
|
||||
// The handler can be used to keep your server from crashing because of
|
||||
// unrecovered panics.
|
||||
PanicHandler func(http.ResponseWriter, *http.Request, interface{}) |
||||
} |
||||
|
||||
// Make sure the Router conforms with the http.Handler interface
|
||||
var _ http.Handler = New() |
||||
|
||||
// New returns a new initialized Router.
|
||||
// Path auto-correction, including trailing slashes, is enabled by default.
|
||||
func New() *Router { |
||||
return &Router{ |
||||
RedirectTrailingSlash: true, |
||||
RedirectFixedPath: true, |
||||
HandleMethodNotAllowed: true, |
||||
} |
||||
} |
||||
|
||||
// GET is a shortcut for router.Handle("GET", path, handle)
|
||||
func (r *Router) GET(path string, handle Handle) { |
||||
r.Handle("GET", path, handle) |
||||
} |
||||
|
||||
// HEAD is a shortcut for router.Handle("HEAD", path, handle)
|
||||
func (r *Router) HEAD(path string, handle Handle) { |
||||
r.Handle("HEAD", path, handle) |
||||
} |
||||
|
||||
// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle)
|
||||
func (r *Router) OPTIONS(path string, handle Handle) { |
||||
r.Handle("OPTIONS", path, handle) |
||||
} |
||||
|
||||
// POST is a shortcut for router.Handle("POST", path, handle)
|
||||
func (r *Router) POST(path string, handle Handle) { |
||||
r.Handle("POST", path, handle) |
||||
} |
||||
|
||||
// PUT is a shortcut for router.Handle("PUT", path, handle)
|
||||
func (r *Router) PUT(path string, handle Handle) { |
||||
r.Handle("PUT", path, handle) |
||||
} |
||||
|
||||
// PATCH is a shortcut for router.Handle("PATCH", path, handle)
|
||||
func (r *Router) PATCH(path string, handle Handle) { |
||||
r.Handle("PATCH", path, handle) |
||||
} |
||||
|
||||
// DELETE is a shortcut for router.Handle("DELETE", path, handle)
|
||||
func (r *Router) DELETE(path string, handle Handle) { |
||||
r.Handle("DELETE", path, handle) |
||||
} |
||||
|
||||
// Handle registers a new request handle with the given path and method.
|
||||
//
|
||||
// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
|
||||
// functions can be used.
|
||||
//
|
||||
// This function is intended for bulk loading and to allow the usage of less
|
||||
// frequently used, non-standardized or custom methods (e.g. for internal
|
||||
// communication with a proxy).
|
||||
func (r *Router) Handle(method, path string, handle Handle) { |
||||
if path[0] != '/' { |
||||
panic("path must begin with '/' in path '" + path + "'") |
||||
} |
||||
|
||||
if r.trees == nil { |
||||
r.trees = make(map[string]*node) |
||||
} |
||||
|
||||
root := r.trees[method] |
||||
if root == nil { |
||||
root = new(node) |
||||
r.trees[method] = root |
||||
} |
||||
|
||||
root.addRoute(path, handle) |
||||
} |
||||
|
||||
// Handler is an adapter which allows the usage of an http.Handler as a
|
||||
// request handle.
|
||||
func (r *Router) Handler(method, path string, handler http.Handler) { |
||||
r.Handle(method, path, |
||||
func(w http.ResponseWriter, req *http.Request, _ Params) { |
||||
handler.ServeHTTP(w, req) |
||||
}, |
||||
) |
||||
} |
||||
|
||||
// HandlerFunc is an adapter which allows the usage of an http.HandlerFunc as a
|
||||
// request handle.
|
||||
func (r *Router) HandlerFunc(method, path string, handler http.HandlerFunc) { |
||||
r.Handler(method, path, handler) |
||||
} |
||||
|
||||
// ServeFiles serves files from the given file system root.
|
||||
// The path must end with "/*filepath", files are then served from the local
|
||||
// path /defined/root/dir/*filepath.
|
||||
// For example if root is "/etc" and *filepath is "passwd", the local file
|
||||
// "/etc/passwd" would be served.
|
||||
// Internally a http.FileServer is used, therefore http.NotFound is used instead
|
||||
// of the Router's NotFound handler.
|
||||
// To use the operating system's file system implementation,
|
||||
// use http.Dir:
|
||||
// router.ServeFiles("/src/*filepath", http.Dir("/var/www"))
|
||||
func (r *Router) ServeFiles(path string, root http.FileSystem) { |
||||
if len(path) < 10 || path[len(path)-10:] != "/*filepath" { |
||||
panic("path must end with /*filepath in path '" + path + "'") |
||||
} |
||||
|
||||
fileServer := http.FileServer(root) |
||||
|
||||
r.GET(path, func(w http.ResponseWriter, req *http.Request, ps Params) { |
||||
req.URL.Path = ps.ByName("filepath") |
||||
fileServer.ServeHTTP(w, req) |
||||
}) |
||||
} |
||||
|
||||
func (r *Router) recv(w http.ResponseWriter, req *http.Request) { |
||||
if rcv := recover(); rcv != nil { |
||||
r.PanicHandler(w, req, rcv) |
||||
} |
||||
} |
||||
|
||||
// Lookup allows the manual lookup of a method + path combo.
|
||||
// This is e.g. useful to build a framework around this router.
|
||||
// If the path was found, it returns the handle function and the path parameter
|
||||
// values. Otherwise the third return value indicates whether a redirection to
|
||||
// the same path with an extra / without the trailing slash should be performed.
|
||||
func (r *Router) Lookup(method, path string) (Handle, Params, bool) { |
||||
if root := r.trees[method]; root != nil { |
||||
return root.getValue(path) |
||||
} |
||||
return nil, nil, false |
||||
} |
||||
|
||||
// ServeHTTP makes the router implement the http.Handler interface.
|
||||
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { |
||||
if r.PanicHandler != nil { |
||||
defer r.recv(w, req) |
||||
} |
||||
|
||||
if root := r.trees[req.Method]; root != nil { |
||||
path := req.URL.Path |
||||
|
||||
if handle, ps, tsr := root.getValue(path); handle != nil { |
||||
handle(w, req, ps) |
||||
return |
||||
} else if req.Method != "CONNECT" && path != "/" { |
||||
code := 301 // Permanent redirect, request with GET method
|
||||
if req.Method != "GET" { |
||||
// Temporary redirect, request with same method
|
||||
// As of Go 1.3, Go does not support status code 308.
|
||||
code = 307 |
||||
} |
||||
|
||||
if tsr && r.RedirectTrailingSlash { |
||||
if len(path) > 1 && path[len(path)-1] == '/' { |
||||
req.URL.Path = path[:len(path)-1] |
||||
} else { |
||||
req.URL.Path = path + "/" |
||||
} |
||||
http.Redirect(w, req, req.URL.String(), code) |
||||
return |
||||
} |
||||
|
||||
// Try to fix the request path
|
||||
if r.RedirectFixedPath { |
||||
fixedPath, found := root.findCaseInsensitivePath( |
||||
CleanPath(path), |
||||
r.RedirectTrailingSlash, |
||||
) |
||||
if found { |
||||
req.URL.Path = string(fixedPath) |
||||
http.Redirect(w, req, req.URL.String(), code) |
||||
return |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Handle 405
|
||||
if r.HandleMethodNotAllowed { |
||||
for method := range r.trees { |
||||
// Skip the requested method - we already tried this one
|
||||
if method == req.Method { |
||||
continue |
||||
} |
||||
|
||||
handle, _, _ := r.trees[method].getValue(req.URL.Path) |
||||
if handle != nil { |
||||
if r.MethodNotAllowed != nil { |
||||
r.MethodNotAllowed(w, req) |
||||
} else { |
||||
http.Error(w, |
||||
http.StatusText(http.StatusMethodNotAllowed), |
||||
http.StatusMethodNotAllowed, |
||||
) |
||||
} |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Handle 404
|
||||
if r.NotFound != nil { |
||||
r.NotFound(w, req) |
||||
} else { |
||||
http.NotFound(w, req) |
||||
} |
||||
} |
||||
@ -1,555 +0,0 @@
|
||||
// Copyright 2013 Julien Schmidt. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be found
|
||||
// in the LICENSE file.
|
||||
|
||||
package httprouter |
||||
|
||||
import ( |
||||
"strings" |
||||
"unicode" |
||||
) |
||||
|
||||
func min(a, b int) int { |
||||
if a <= b { |
||||
return a |
||||
} |
||||
return b |
||||
} |
||||
|
||||
func countParams(path string) uint8 { |
||||
var n uint |
||||
for i := 0; i < len(path); i++ { |
||||
if path[i] != ':' && path[i] != '*' { |
||||
continue |
||||
} |
||||
n++ |
||||
} |
||||
if n >= 255 { |
||||
return 255 |
||||
} |
||||
return uint8(n) |
||||
} |
||||
|
||||
type nodeType uint8 |
||||
|
||||
const ( |
||||
static nodeType = 0 |
||||
param nodeType = 1 |
||||
catchAll nodeType = 2 |
||||
) |
||||
|
||||
type node struct { |
||||
path string |
||||
wildChild bool |
||||
nType nodeType |
||||
maxParams uint8 |
||||
indices string |
||||
children []*node |
||||
handle Handle |
||||
priority uint32 |
||||
} |
||||
|
||||
// increments priority of the given child and reorders if necessary
|
||||
func (n *node) incrementChildPrio(pos int) int { |
||||
n.children[pos].priority++ |
||||
prio := n.children[pos].priority |
||||
|
||||
// adjust position (move to front)
|
||||
newPos := pos |
||||
for newPos > 0 && n.children[newPos-1].priority < prio { |
||||
// swap node positions
|
||||
tmpN := n.children[newPos-1] |
||||
n.children[newPos-1] = n.children[newPos] |
||||
n.children[newPos] = tmpN |
||||
|
||||
newPos-- |
||||
} |
||||
|
||||
// build new index char string
|
||||
if newPos != pos { |
||||
n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
|
||||
n.indices[pos:pos+1] + // the index char we move
|
||||
n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
|
||||
} |
||||
|
||||
return newPos |
||||
} |
||||
|
||||
// addRoute adds a node with the given handle to the path.
|
||||
// Not concurrency-safe!
|
||||
func (n *node) addRoute(path string, handle Handle) { |
||||
fullPath := path |
||||
n.priority++ |
||||
numParams := countParams(path) |
||||
|
||||
// non-empty tree
|
||||
if len(n.path) > 0 || len(n.children) > 0 { |
||||
walk: |
||||
for { |
||||
// Update maxParams of the current node
|
||||
if numParams > n.maxParams { |
||||
n.maxParams = numParams |
||||
} |
||||
|
||||
// Find the longest common prefix.
|
||||
// This also implies that the common prefix contains no ':' or '*'
|
||||
// since the existing key can't contain those chars.
|
||||
i := 0 |
||||
max := min(len(path), len(n.path)) |
||||
for i < max && path[i] == n.path[i] { |
||||
i++ |
||||
} |
||||
|
||||
// Split edge
|
||||
if i < len(n.path) { |
||||
child := node{ |
||||
path: n.path[i:], |
||||
wildChild: n.wildChild, |
||||
indices: n.indices, |
||||
children: n.children, |
||||
handle: n.handle, |
||||
priority: n.priority - 1, |
||||
} |
||||
|
||||
// Update maxParams (max of all children)
|
||||
for i := range child.children { |
||||
if child.children[i].maxParams > child.maxParams { |
||||
child.maxParams = child.children[i].maxParams |
||||
} |
||||
} |
||||
|
||||
n.children = []*node{&child} |
||||
// []byte for proper unicode char conversion, see #65
|
||||
n.indices = string([]byte{n.path[i]}) |
||||
n.path = path[:i] |
||||
n.handle = nil |
||||
n.wildChild = false |
||||
} |
||||
|
||||
// Make new node a child of this node
|
||||
if i < len(path) { |
||||
path = path[i:] |
||||
|
||||
if n.wildChild { |
||||
n = n.children[0] |
||||
n.priority++ |
||||
|
||||
// Update maxParams of the child node
|
||||
if numParams > n.maxParams { |
||||
n.maxParams = numParams |
||||
} |
||||
numParams-- |
||||
|
||||
// Check if the wildcard matches
|
||||
if len(path) >= len(n.path) && n.path == path[:len(n.path)] { |
||||
// check for longer wildcard, e.g. :name and :names
|
||||
if len(n.path) >= len(path) || path[len(n.path)] == '/' { |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
panic("path segment '" + path + |
||||
"' conflicts with existing wildcard '" + n.path + |
||||
"' in path '" + fullPath + "'") |
||||
} |
||||
|
||||
c := path[0] |
||||
|
||||
// slash after param
|
||||
if n.nType == param && c == '/' && len(n.children) == 1 { |
||||
n = n.children[0] |
||||
n.priority++ |
||||
continue walk |
||||
} |
||||
|
||||
// Check if a child with the next path byte exists
|
||||
for i := 0; i < len(n.indices); i++ { |
||||
if c == n.indices[i] { |
||||
i = n.incrementChildPrio(i) |
||||
n = n.children[i] |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
// Otherwise insert it
|
||||
if c != ':' && c != '*' { |
||||
// []byte for proper unicode char conversion, see #65
|
||||
n.indices += string([]byte{c}) |
||||
child := &node{ |
||||
maxParams: numParams, |
||||
} |
||||
n.children = append(n.children, child) |
||||
n.incrementChildPrio(len(n.indices) - 1) |
||||
n = child |
||||
} |
||||
n.insertChild(numParams, path, fullPath, handle) |
||||
return |
||||
|
||||
} else if i == len(path) { // Make node a (in-path) leaf
|
||||
if n.handle != nil { |
||||
panic("a handle is already registered for path ''" + fullPath + "'") |
||||
} |
||||
n.handle = handle |
||||
} |
||||
return |
||||
} |
||||
} else { // Empty tree
|
||||
n.insertChild(numParams, path, fullPath, handle) |
||||
} |
||||
} |
||||
|
||||
func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle) { |
||||
var offset int // already handled bytes of the path
|
||||
|
||||
// find prefix until first wildcard (beginning with ':'' or '*'')
|
||||
for i, max := 0, len(path); numParams > 0; i++ { |
||||
c := path[i] |
||||
if c != ':' && c != '*' { |
||||
continue |
||||
} |
||||
|
||||
// find wildcard end (either '/' or path end)
|
||||
end := i + 1 |
||||
for end < max && path[end] != '/' { |
||||
switch path[end] { |
||||
// the wildcard name must not contain ':' and '*'
|
||||
case ':', '*': |
||||
panic("only one wildcard per path segment is allowed, has: '" + |
||||
path[i:] + "' in path '" + fullPath + "'") |
||||
default: |
||||
end++ |
||||
} |
||||
} |
||||
|
||||
// check if this Node existing children which would be
|
||||
// unreachable if we insert the wildcard here
|
||||
if len(n.children) > 0 { |
||||
panic("wildcard route '" + path[i:end] + |
||||
"' conflicts with existing children in path '" + fullPath + "'") |
||||
} |
||||
|
||||
// check if the wildcard has a name
|
||||
if end-i < 2 { |
||||
panic("wildcards must be named with a non-empty name in path '" + fullPath + "'") |
||||
} |
||||
|
||||
if c == ':' { // param
|
||||
// split path at the beginning of the wildcard
|
||||
if i > 0 { |
||||
n.path = path[offset:i] |
||||
offset = i |
||||
} |
||||
|
||||
child := &node{ |
||||
nType: param, |
||||
maxParams: numParams, |
||||
} |
||||
n.children = []*node{child} |
||||
n.wildChild = true |
||||
n = child |
||||
n.priority++ |
||||
numParams-- |
||||
|
||||
// if the path doesn't end with the wildcard, then there
|
||||
// will be another non-wildcard subpath starting with '/'
|
||||
if end < max { |
||||
n.path = path[offset:end] |
||||
offset = end |
||||
|
||||
child := &node{ |
||||
maxParams: numParams, |
||||
priority: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
n = child |
||||
} |
||||
|
||||
} else { // catchAll
|
||||
if end != max || numParams > 1 { |
||||
panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'") |
||||
} |
||||
|
||||
if len(n.path) > 0 && n.path[len(n.path)-1] == '/' { |
||||
panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'") |
||||
} |
||||
|
||||
// currently fixed width 1 for '/'
|
||||
i-- |
||||
if path[i] != '/' { |
||||
panic("no / before catch-all in path '" + fullPath + "'") |
||||
} |
||||
|
||||
n.path = path[offset:i] |
||||
|
||||
// first node: catchAll node with empty path
|
||||
child := &node{ |
||||
wildChild: true, |
||||
nType: catchAll, |
||||
maxParams: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
n.indices = string(path[i]) |
||||
n = child |
||||
n.priority++ |
||||
|
||||
// second node: node holding the variable
|
||||
child = &node{ |
||||
path: path[i:], |
||||
nType: catchAll, |
||||
maxParams: 1, |
||||
handle: handle, |
||||
priority: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
|
||||
return |
||||
} |
||||
} |
||||
|
||||
// insert remaining path part and handle to the leaf
|
||||
n.path = path[offset:] |
||||
n.handle = handle |
||||
} |
||||
|
||||
// Returns the handle registered with the given path (key). The values of
|
||||
// wildcards are saved to a map.
|
||||
// If no handle can be found, a TSR (trailing slash redirect) recommendation is
|
||||
// made if a handle exists with an extra (without the) trailing slash for the
|
||||
// given path.
|
||||
func (n *node) getValue(path string) (handle Handle, p Params, tsr bool) { |
||||
walk: // Outer loop for walking the tree
|
||||
for { |
||||
if len(path) > len(n.path) { |
||||
if path[:len(n.path)] == n.path { |
||||
path = path[len(n.path):] |
||||
// If this node does not have a wildcard (param or catchAll)
|
||||
// child, we can just look up the next child node and continue
|
||||
// to walk down the tree
|
||||
if !n.wildChild { |
||||
c := path[0] |
||||
for i := 0; i < len(n.indices); i++ { |
||||
if c == n.indices[i] { |
||||
n = n.children[i] |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
// Nothing found.
|
||||
// We can recommend to redirect to the same URL without a
|
||||
// trailing slash if a leaf exists for that path.
|
||||
tsr = (path == "/" && n.handle != nil) |
||||
return |
||||
|
||||
} |
||||
|
||||
// handle wildcard child
|
||||
n = n.children[0] |
||||
switch n.nType { |
||||
case param: |
||||
// find param end (either '/' or path end)
|
||||
end := 0 |
||||
for end < len(path) && path[end] != '/' { |
||||
end++ |
||||
} |
||||
|
||||
// save param value
|
||||
if p == nil { |
||||
// lazy allocation
|
||||
p = make(Params, 0, n.maxParams) |
||||
} |
||||
i := len(p) |
||||
p = p[:i+1] // expand slice within preallocated capacity
|
||||
p[i].Key = n.path[1:] |
||||
p[i].Value = path[:end] |
||||
|
||||
// we need to go deeper!
|
||||
if end < len(path) { |
||||
if len(n.children) > 0 { |
||||
path = path[end:] |
||||
n = n.children[0] |
||||
continue walk |
||||
} |
||||
|
||||
// ... but we can't
|
||||
tsr = (len(path) == end+1) |
||||
return |
||||
} |
||||
|
||||
if handle = n.handle; handle != nil { |
||||
return |
||||
} else if len(n.children) == 1 { |
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists for TSR recommendation
|
||||
n = n.children[0] |
||||
tsr = (n.path == "/" && n.handle != nil) |
||||
} |
||||
|
||||
return |
||||
|
||||
case catchAll: |
||||
// save param value
|
||||
if p == nil { |
||||
// lazy allocation
|
||||
p = make(Params, 0, n.maxParams) |
||||
} |
||||
i := len(p) |
||||
p = p[:i+1] // expand slice within preallocated capacity
|
||||
p[i].Key = n.path[2:] |
||||
p[i].Value = path |
||||
|
||||
handle = n.handle |
||||
return |
||||
|
||||
default: |
||||
panic("invalid node type") |
||||
} |
||||
} |
||||
} else if path == n.path { |
||||
// We should have reached the node containing the handle.
|
||||
// Check if this node has a handle registered.
|
||||
if handle = n.handle; handle != nil { |
||||
return |
||||
} |
||||
|
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists for trailing slash recommendation
|
||||
for i := 0; i < len(n.indices); i++ { |
||||
if n.indices[i] == '/' { |
||||
n = n.children[i] |
||||
tsr = (len(n.path) == 1 && n.handle != nil) || |
||||
(n.nType == catchAll && n.children[0].handle != nil) |
||||
return |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
// Nothing found. We can recommend to redirect to the same URL with an
|
||||
// extra trailing slash if a leaf exists for that path
|
||||
tsr = (path == "/") || |
||||
(len(n.path) == len(path)+1 && n.path[len(path)] == '/' && |
||||
path == n.path[:len(n.path)-1] && n.handle != nil) |
||||
return |
||||
} |
||||
} |
||||
|
||||
// Makes a case-insensitive lookup of the given path and tries to find a handler.
|
||||
// It can optionally also fix trailing slashes.
|
||||
// It returns the case-corrected path and a bool indicating whether the lookup
|
||||
// was successful.
|
||||
func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) { |
||||
ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
|
||||
|
||||
// Outer loop for walking the tree
|
||||
for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) { |
||||
path = path[len(n.path):] |
||||
ciPath = append(ciPath, n.path...) |
||||
|
||||
if len(path) > 0 { |
||||
// If this node does not have a wildcard (param or catchAll) child,
|
||||
// we can just look up the next child node and continue to walk down
|
||||
// the tree
|
||||
if !n.wildChild { |
||||
r := unicode.ToLower(rune(path[0])) |
||||
for i, index := range n.indices { |
||||
// must use recursive approach since both index and
|
||||
// ToLower(index) could exist. We must check both.
|
||||
if r == unicode.ToLower(index) { |
||||
out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash) |
||||
if found { |
||||
return append(ciPath, out...), true |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Nothing found. We can recommend to redirect to the same URL
|
||||
// without a trailing slash if a leaf exists for that path
|
||||
found = (fixTrailingSlash && path == "/" && n.handle != nil) |
||||
return |
||||
} |
||||
|
||||
n = n.children[0] |
||||
switch n.nType { |
||||
case param: |
||||
// find param end (either '/' or path end)
|
||||
k := 0 |
||||
for k < len(path) && path[k] != '/' { |
||||
k++ |
||||
} |
||||
|
||||
// add param value to case insensitive path
|
||||
ciPath = append(ciPath, path[:k]...) |
||||
|
||||
// we need to go deeper!
|
||||
if k < len(path) { |
||||
if len(n.children) > 0 { |
||||
path = path[k:] |
||||
n = n.children[0] |
||||
continue |
||||
} |
||||
|
||||
// ... but we can't
|
||||
if fixTrailingSlash && len(path) == k+1 { |
||||
return ciPath, true |
||||
} |
||||
return |
||||
} |
||||
|
||||
if n.handle != nil { |
||||
return ciPath, true |
||||
} else if fixTrailingSlash && len(n.children) == 1 { |
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists
|
||||
n = n.children[0] |
||||
if n.path == "/" && n.handle != nil { |
||||
return append(ciPath, '/'), true |
||||
} |
||||
} |
||||
return |
||||
|
||||
case catchAll: |
||||
return append(ciPath, path...), true |
||||
|
||||
default: |
||||
panic("invalid node type") |
||||
} |
||||
} else { |
||||
// We should have reached the node containing the handle.
|
||||
// Check if this node has a handle registered.
|
||||
if n.handle != nil { |
||||
return ciPath, true |
||||
} |
||||
|
||||
// No handle found.
|
||||
// Try to fix the path by adding a trailing slash
|
||||
if fixTrailingSlash { |
||||
for i := 0; i < len(n.indices); i++ { |
||||
if n.indices[i] == '/' { |
||||
n = n.children[i] |
||||
if (len(n.path) == 1 && n.handle != nil) || |
||||
(n.nType == catchAll && n.children[0].handle != nil) { |
||||
return append(ciPath, '/'), true |
||||
} |
||||
return |
||||
} |
||||
} |
||||
} |
||||
return |
||||
} |
||||
} |
||||
|
||||
// Nothing found.
|
||||
// Try to fix the path by adding / removing a trailing slash
|
||||
if fixTrailingSlash { |
||||
if path == "/" { |
||||
return ciPath, true |
||||
} |
||||
if len(path)+1 == len(n.path) && n.path[len(path)] == '/' && |
||||
strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) && |
||||
n.handle != nil { |
||||
return append(ciPath, n.path...), true |
||||
} |
||||
} |
||||
return |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,116 @@
|
||||
<template> |
||||
<div> |
||||
<el-table :data="proxies" :default-sort="{prop: 'name', order: 'ascending'}" style="width: 100%"> |
||||
<el-table-column type="expand"> |
||||
<template slot-scope="props"> |
||||
<el-popover |
||||
ref="popover4" |
||||
placement="right" |
||||
width="600" |
||||
style="margin-left:0px" |
||||
trigger="click"> |
||||
<my-traffic-chart :proxy_name="props.row.name"></my-traffic-chart> |
||||
</el-popover> |
||||
|
||||
<el-button v-popover:popover4 type="primary" size="small" icon="view" :name="props.row.name" style="margin-bottom:10px" @click="fetchData2">Traffic Statistics</el-button> |
||||
|
||||
<el-form label-position="left" inline class="demo-table-expand"> |
||||
<el-form-item label="Name"> |
||||
<span>{{ props.row.name }}</span> |
||||
</el-form-item> |
||||
<el-form-item label="Type"> |
||||
<span>{{ props.row.type }}</span> |
||||
</el-form-item> |
||||
<el-form-item label="Encryption"> |
||||
<span>{{ props.row.encryption }}</span> |
||||
</el-form-item> |
||||
<el-form-item label="Compression"> |
||||
<span>{{ props.row.compression }}</span> |
||||
</el-form-item> |
||||
<el-form-item label="Last Start"> |
||||
<span>{{ props.row.last_start_time }}</span> |
||||
</el-form-item> |
||||
<el-form-item label="Last Close"> |
||||
<span>{{ props.row.last_close_time }}</span> |
||||
</el-form-item> |
||||
</el-form> |
||||
</template> |
||||
</el-table-column> |
||||
<el-table-column |
||||
label="Name" |
||||
prop="name" |
||||
sortable> |
||||
</el-table-column> |
||||
<el-table-column |
||||
label="Connections" |
||||
prop="conns" |
||||
sortable> |
||||
</el-table-column> |
||||
<el-table-column |
||||
label="Traffic In" |
||||
prop="traffic_in" |
||||
:formatter="formatTrafficIn" |
||||
sortable> |
||||
</el-table-column> |
||||
<el-table-column |
||||
label="Traffic Out" |
||||
prop="traffic_out" |
||||
:formatter="formatTrafficOut" |
||||
sortable> |
||||
</el-table-column> |
||||
<el-table-column |
||||
label="status" |
||||
prop="status" |
||||
sortable> |
||||
<template slot-scope="scope"> |
||||
<el-tag type="success" v-if="scope.row.status === 'online'">{{ scope.row.status }}</el-tag> |
||||
<el-tag type="danger" v-else>{{ scope.row.status }}</el-tag> |
||||
</template> |
||||
</el-table-column> |
||||
</el-table> |
||||
</div> |
||||
</template> |
||||
|
||||
<script> |
||||
import Humanize from 'humanize-plus' |
||||
import Traffic from './Traffic.vue' |
||||
import { StcpProxy } from '../utils/proxy.js' |
||||
export default { |
||||
data() { |
||||
return { |
||||
proxies: null |
||||
} |
||||
}, |
||||
created() { |
||||
this.fetchData() |
||||
}, |
||||
watch: { |
||||
'$route': 'fetchData' |
||||
}, |
||||
methods: { |
||||
formatTrafficIn(row, column) { |
||||
return Humanize.fileSize(row.traffic_in) |
||||
}, |
||||
formatTrafficOut(row, column) { |
||||
return Humanize.fileSize(row.traffic_out) |
||||
}, |
||||
fetchData() { |
||||
fetch('/api/proxy/stcp', {credentials: 'include'}) |
||||
.then(res => { |
||||
return res.json() |
||||
}).then(json => { |
||||
this.proxies = new Array() |
||||
for (let proxyStats of json.proxies) { |
||||
this.proxies.push(new StcpProxy(proxyStats)) |
||||
} |
||||
}) |
||||
} |
||||
}, |
||||
components: { |
||||
'my-traffic-chart': Traffic |
||||
} |
||||
} |
||||
</script> |
||||
|
||||
<style> |
||||
</style> |
||||
Loading…
Reference in new issue