MVP, no mod tools or anything but it works

2025-08-20 12:04:16 +00:00 · 2017-03-12 20:37:53 +01:00
parent 70b12c516a
commit 69b0d20825
186 changed files with 44200 additions and 0 deletions
--- a/vendor/github.com/pressly/chi/CHANGELOG.md
+++ b/vendor/github.com/pressly/chi/CHANGELOG.md
@@ -0,0 +1,40 @@
+# Changelog
+
+## v2.0.0 (2017-01-06)
+
+- After many months of v2 being in an RC state with many companies and users running it in
+production, the inclusion of some improvements to the middlewares, we are very pleased to
+announce v2.0.0 of chi.
+
+
+## v2.0.0-rc1 (2016-07-26)
+
+- Huge update! chi v2 is a large refactor targetting Go 1.7+. As of Go 1.7, the popular
+community `"net/context"` package has been included in the standard library as `"context"` and
+utilized by `"net/http"` and `http.Request` to managing deadlines, cancelation signals and other
+request-scoped values. We're very excited about the new context addition and are proud to
+introduce chi v2, a minimal and powerful routing package for building large HTTP services,
+with zero external dependencies. Chi focuses on idiomatic design and encourages the use of 
+stdlib HTTP handlers and middlwares.
+- chi v2 deprecates its `chi.Handler` interface and requires `http.Handler` or `http.HandlerFunc`
+- chi v2 stores URL routing parameters and patterns in the standard request context: `r.Context()`
+- chi v2 lower-level routing context is accessible by `chi.RouteContext(r.Context()) *chi.Context`,
+  which provides direct access to URL routing parameters, the routing path and the matching
+  routing patterns.
+- Users upgrading from chi v1 to v2, need to:
+  1. Update the old chi.Handler signature, `func(ctx context.Context, w http.ResponseWriter, r *http.Request)` to
+     the standard http.Handler: `func(w http.ResponseWriter, r *http.Request)`
+  2. Use `chi.URLParam(r *http.Request, paramKey string) string`
+     or `URLParamFromCtx(ctx context.Context, paramKey string) string` to access a url parameter value
+
+
+## v1.0.0 (2016-07-01)
+
+- Released chi v1 stable https://github.com/pressly/chi/tree/v1.0.0 for Go 1.6 and older.
+
+
+## v0.9.0 (2016-03-31)
+
+- Reuse context objects via sync.Pool for zero-allocation routing [#33](https://github.com/pressly/chi/pull/33)
+- BREAKING NOTE: due to subtle API changes, previously `chi.URLParams(ctx)["id"]` used to access url parameters
+  has changed to: `chi.URLParam(ctx, "id")`
--- a/vendor/github.com/pressly/chi/CONTRIBUTING.md
+++ b/vendor/github.com/pressly/chi/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing
+
+## Prerequisites
+
+1. [Install Go][go-install].
+2. Download the sources and switch the working directory:
+
+    ```bash
+    go get -u -d github.com/pressly/chi
+    cd $GOPATH/src/github.com/pressly/chi
+    ```
+
+## Submitting a Pull Request
+
+A typical workflow is:
+
+1. [Fork the repository.][fork] [This tip maybe also helpful.][go-fork-tip]
+2. [Create a topic branch.][branch]
+3. Add tests for your change.
+4. Run `go test`. If your tests pass, return to the step 3.
+5. Implement the change and ensure the steps from the previous step pass.
+6. Run `goimports -w .`, to ensure the new code conforms to Go formatting guideline.
+7. [Add, commit and push your changes.][git-help]
+8. [Submit a pull request.][pull-req]
+
+[go-install]: https://golang.org/doc/install
+[go-fork-tip]: http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html
+[fork]: https://help.github.com/articles/fork-a-repo
+[branch]: http://learn.github.com/p/branching.html
+[git-help]: https://guides.github.com
+[pull-req]: https://help.github.com/articles/using-pull-requests
--- a/vendor/github.com/pressly/chi/LICENSE
+++ b/vendor/github.com/pressly/chi/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka)
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/pressly/chi/README.md
+++ b/vendor/github.com/pressly/chi/README.md
@@ -0,0 +1,408 @@
+<img alt="chi" src="https://cdn.rawgit.com/pressly/chi/master/_examples/chi.svg" width="220" />
+===
+
+[![GoDoc Widget]][GoDoc] [![Travis Widget]][Travis]
+
+`chi` is a lightweight, idiomatic and composable router for building Go 1.7+ HTTP services. It's
+especially good at helping you write large REST API services that are kept maintainable as your
+project grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to
+handle signaling, cancelation and request-scoped values across a handler chain.
+
+The focus of the project has been to seek out an elegant and comfortable design for writing
+REST API servers, written during the development of the Pressly API service that powers our
+public API service, which in turn powers all of our client-side applications.
+
+The key considerations of chi's design are: project structure, maintainability, standard http
+handlers (stdlib-only), developer productivity, and deconstructing a large system into many small
+parts. The core router `github.com/pressly/chi` is quite small (less than 1000 LOC), but we've also
+included some useful/optional subpackages: `middleware`, `render` and `docgen`. We hope you enjoy it too!
+
+## Install
+
+`go get -u github.com/pressly/chi`
+
+
+## Features
+
+* **Lightweight** - cloc'd in <1000 LOC for the chi router
+* **Fast** - yes, see [benchmarks](#benchmarks)
+* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compat with `net/http`
+* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and subrouter mounting
+* **Context control** - built on new `context` package, providing value chaining, cancelations and timeouts
+* **Robust** - tested / used in production at Pressly.com, and many others
+* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown
+* **No external dependencies** - plain ol' Go 1.7+ stdlib + net/http
+
+
+## Examples
+
+* [rest](https://github.com/pressly/chi/blob/master/_examples/rest/main.go) - REST APIs made easy, productive and maintainable
+* [logging](https://github.com/pressly/chi/blob/master/_examples/logging/main.go) - Easy structured logging for any backend
+* [limits](https://github.com/pressly/chi/blob/master/_examples/limits/main.go) - Timeouts and Throttling
+* [todos-resource](https://github.com/pressly/chi/blob/master/_examples/todos-resource/main.go) - Struct routers/handlers, an example of another code layout style
+* [versions](https://github.com/pressly/chi/blob/master/_examples/versions/main.go) - Demo of `chi/render` subpkg
+* [fileserver](https://github.com/pressly/chi/blob/master/_examples/fileserver/main.go) - Easily serve static files
+* [graceful](https://github.com/pressly/chi/blob/master/_examples/graceful/main.go) - Graceful context signaling and server shutdown
+
+
+**As easy as:**
+
+```go
+package main
+
+import (
+	"net/http"
+	"github.com/pressly/chi"
+)
+
+func main() {
+	r := chi.NewRouter()
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("welcome"))
+	})
+	http.ListenAndServe(":3000", r)
+}
+```
+
+**REST Preview:**
+
+Here is a little preview of how routing looks like with chi. Also take a look at the generated routing docs
+in JSON ([routes.json](https://github.com/pressly/chi/blob/master/_examples/rest/routes.json)) and in
+Markdown ([routes.md](https://github.com/pressly/chi/blob/master/_examples/rest/routes.md)).
+
+I highly recommend reading the source of the [examples](#examples) listed above, they will show you all the features
+of chi and serve as a good form of documentation.
+
+```go
+import (
+  //...
+  "context"
+  "github.com/pressly/chi"
+  "github.com/pressly/chi/middleware"
+)
+
+func main() {
+  r := chi.NewRouter()
+
+  // A good base middleware stack
+  r.Use(middleware.RequestID)
+  r.Use(middleware.RealIP)
+  r.Use(middleware.Logger)
+  r.Use(middleware.Recoverer)
+
+  // When a client closes their connection midway through a request, the
+  // http.CloseNotifier will cancel the request context (ctx).
+  r.Use(middleware.CloseNotify)
+
+  // Set a timeout value on the request context (ctx), that will signal
+  // through ctx.Done() that the request has timed out and further
+  // processing should be stopped.
+  r.Use(middleware.Timeout(60 * time.Second))
+
+  r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+    w.Write([]byte("hi"))
+  })
+
+  // RESTy routes for "articles" resource
+  r.Route("/articles", func(r chi.Router) {
+    r.With(paginate).Get("/", listArticles)  // GET /articles
+    r.Post("/", createArticle)               // POST /articles
+    r.Get("/search", searchArticles)         // GET /articles/search
+
+    r.Route("/:articleID", func(r chi.Router) {
+      r.Use(ArticleCtx)
+      r.Get("/", getArticle)                 // GET /articles/123
+      r.Put("/", updateArticle)              // PUT /articles/123
+      r.Delete("/", deleteArticle)           // DELETE /articles/123
+    })
+  })
+
+  // Mount the admin sub-router
+  r.Mount("/admin", adminRouter())
+
+  http.ListenAndServe(":3333", r)
+}
+
+func ArticleCtx(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    articleID := chi.URLParam(r, "articleID")
+    article, err := dbGetArticle(articleID)
+    if err != nil {
+      http.Error(w, http.StatusText(404), 404)
+      return
+    }
+    ctx := context.WithValue(r.Context(), "article", article)
+    next.ServeHTTP(w, r.WithContext(ctx))
+  })
+}
+
+func getArticle(w http.ResponseWriter, r *http.Request) {
+  ctx := r.Context()
+  article, ok := ctx.Value("article").(*Article)
+  if !ok {
+    http.Error(w, http.StatusText(422), 422)
+    return
+  }
+  w.Write([]byte(fmt.Sprintf("title:%s", article.Title)))
+}
+
+// A completely separate router for administrator routes
+func adminRouter() http.Handler {
+  r := chi.NewRouter()
+  r.Use(AdminOnly)
+  r.Get("/", adminIndex)
+  r.Get("/accounts", adminListAccounts)
+  return r
+}
+
+func AdminOnly(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    ctx := r.Context()
+    perm, ok := ctx.Value("acl.permission").(YourPermissionType)
+    if !ok || !perm.IsAdmin() {
+      http.Error(w, http.StatusText(403), 403)
+      return
+    }
+    next.ServeHTTP(w, r)
+  })
+}
+```
+
+
+## Router design
+
+chi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree).
+The router is fully compatible with `net/http`.
+
+Built on top of the tree is the `Router` interface:
+
+```go
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+	http.Handler
+	Routes
+
+	// Use appends one of more middlewares onto the Router stack.
+	Use(middlewares ...func(http.Handler) http.Handler)
+
+	// With adds inline middlewares for an endpoint handler.
+	With(middlewares ...func(http.Handler) http.Handler) Router
+
+	// Group adds a new inline-Router along the current routing
+	// path, with a fresh middleware stack for the inline-Router.
+	Group(fn func(r Router)) Router
+
+	// Route mounts a sub-Router along a `pattern`` string.
+	Route(pattern string, fn func(r Router)) Router
+
+	// Mount attaches another http.Handler along ./pattern/*
+	Mount(pattern string, h http.Handler)
+
+	// Handle and HandleFunc adds routes for `pattern` that matches
+	// all HTTP methods.
+	Handle(pattern string, h http.Handler)
+	HandleFunc(pattern string, h http.HandlerFunc)
+
+	// HTTP-method routing along `pattern`
+	Connect(pattern string, h http.HandlerFunc)
+	Delete(pattern string, h http.HandlerFunc)
+	Get(pattern string, h http.HandlerFunc)
+	Head(pattern string, h http.HandlerFunc)
+	Options(pattern string, h http.HandlerFunc)
+	Patch(pattern string, h http.HandlerFunc)
+	Post(pattern string, h http.HandlerFunc)
+	Put(pattern string, h http.HandlerFunc)
+	Trace(pattern string, h http.HandlerFunc)
+
+	// NotFound defines a handler to respond whenever a route could
+	// not be found.
+	NotFound(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the `docgen` subpackage to generation documentation for Routers.
+type Routes interface {
+	// Routes returns the routing tree in an easily traversable structure.
+	Routes() []Route
+
+	// Middlewares returns the list of middlewares in use by the router.
+	Middlewares() Middlewares
+}
+```
+
+Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern
+supports named params (ie. `/users/:userID`) and wildcards (ie. `/admin/*`).
+
+
+### Middleware handlers
+
+chi's middlewares are just stdlib net/http middleware handlers. There is nothing special
+about them, which means the router and all the tooling is designed to be compatible and
+friendly with any middleware in the community. This offers much better extensibility and reuse
+of packages and is at the heart of chi's purpose.
+
+Here is an example of a standard net/http middleware handler using the new request context
+available in Go 1.7+. This middleware sets a hypothetical user identifier on the request
+context and calls the next handler in the chain.
+
+```go
+// HTTP middleware setting a value on the request context
+func MyMiddleware(next http.Handler) http.Handler {
+  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    ctx := context.WithValue(r.Context(), "user", "123")
+    next.ServeHTTP(w, r.WithContext(ctx))
+  })
+}
+```
+
+
+### Request handlers
+
+chi uses standard net/http request handlers. This little snippet is an example of a http.Handler
+func that reads a user identifier from the request context - hypothetically, identifying
+the user sending an authenticated request, validated+set by a previous middleware handler.
+
+```go
+// HTTP handler accessing data from the request context.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+  user := r.Context().Value("user").(string)
+  w.Write([]byte(fmt.Sprintf("hi %s", user)))
+}
+```
+
+
+### URL parameters
+
+chi's router parses and stores URL parameters right onto the request context. Here is
+an example of how to access URL params in your net/http handlers. And of course, middlewares
+are able to access the same information.
+
+```go
+// HTTP handler accessing the url routing parameters.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+  userID := chi.URLParam(r, "userID") // from a route like /users/:userID
+
+  ctx := r.Context()
+  key := ctx.Value("key").(string)
+
+  w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key)))
+}
+```
+
+
+## Middlewares
+
+chi comes equipped with an optional `middleware` package, providing a suite of standard
+`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible
+with `net/http` can be used with chi's mux.
+
+----------------------------------------------------------------------------------------------------------
+| Middleware           | Description                                                                     |
+|:---------------------|:---------------------------------------------------------------------------------
+| RequestID            | Injects a request ID into the context of each request.                          |
+| RealIP               | Sets a http.Request's RemoteAddr to either X-Forwarded-For or X-Real-IP.        |
+| Logger               | Logs the start and end of each request with the elapsed processing time.        |
+| Recoverer            | Gracefully absorb panics and prints the stack trace.                            |
+| NoCache              | Sets response headers to prevent clients from caching.                          |
+| Timeout              | Signals to the request context when the timeout deadline is reached.            |
+| Throttle             | Puts a ceiling on the number of concurrent requests.                            |
+| Compress             | Gzip compression for clients that accept compressed responses.                  |
+| Profiler             | Easily attach net/http/pprof to your routers.                                   |
+| StripSlashes         | Strip slashes on routing paths.                                                 |
+| RedirectSlashes      | Redirect slashes on routing paths.                                              |
+| WithValue            | Short-hand middleware to set a key/value on the request context.                |
+| Heartbeat            | Monitoring endpoint to check the servers pulse.                                 |
+----------------------------------------------------------------------------------------------------------
+
+Other cool net/http middlewares:
+
+* [jwtauth](https://github.com/goware/jwtauth) - JWT authenticator
+* [cors](https://github.com/goware/cors) - CORS middleware
+* [httpcoala](https://github.com/goware/httpcoala) - Request coalescer
+
+please [submit a PR](./CONTRIBUTING.md) if you'd like to include a link to a chi middleware
+
+
+## context?
+
+`context` is a tiny pkg that provides simple interface to signal context across call stacks
+and goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani)
+and is available in stdlib since go1.7.
+
+Learn more at https://blog.golang.org/context
+
+and..
+* Docs: https://golang.org/pkg/context
+* Source: https://github.com/golang/go/tree/master/src/context
+
+
+## Benchmarks
+
+The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark
+
+Comparison with other routers (as of Jan 7/17): https://gist.github.com/pkieltyka/d0814d5396c996cb3ff8076399583d1f
+
+```shell
+BenchmarkChi_Param        	 5000000	       398 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param5       	 3000000	       556 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param20      	 1000000	      1184 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParamWrite   	 3000000	       443 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubStatic 	 3000000	       427 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubParam  	 3000000	       565 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubAll    	   10000	    122143 ns/op	   61716 B/op	     406 allocs/op
+BenchmarkChi_GPlusStatic  	 5000000	       383 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusParam   	 3000000	       431 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlus2Params 	 3000000	       500 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusAll     	  200000	      6410 ns/op	    3952 B/op	      26 allocs/op
+BenchmarkChi_ParseStatic  	 5000000	       384 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseParam   	 3000000	       415 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Parse2Params 	 3000000	       450 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseAll     	  100000	     12124 ns/op	    7904 B/op	      52 allocs/op
+BenchmarkChi_StaticAll    	   20000	     78501 ns/op	   47731 B/op	     314 allocs/op
+```
+
+NOTE: the allocs in the benchmark above are from the calls to http.Request's
+`WithContext(context.Context)` method that clones the http.Request, sets the `Context()`
+on the duplicated (alloc'd) request and returns it the new request object. This is just
+how setting context on a request in Go 1.7+ works.
+
+
+## Credits
+
+* Carl Jackson for https://github.com/zenazn/goji
+  * Parts of chi's thinking comes from goji, and chi's middleware package
+    sources from goji.
+* Armon Dadgar for https://github.com/armon/go-radix
+* Contributions: [@VojtechVitek](https://github.com/VojtechVitek)
+
+We'll be more than happy to see [your contributions](./CONTRIBUTING.md)!
+
+
+## Beyond REST
+
+chi is just a http router that lets you decompose request handling into many smaller layers.
+Many companies including Pressly.com (of course) use chi to write REST services for their public
+APIs. But, REST is just a convention for managing state via HTTP, and there's a lot of other pieces
+required to write a complete client-server system or network of microservices.
+
+Looking ahead beyond REST, I also recommend some newer works in the field coming from
+[gRPC](https://github.com/grpc/grpc-go), [NATS](https://nats.io), [go-kit](https://github.com/go-kit/kit)
+and even [graphql](https://github.com/graphql-go/graphql). They're all pretty cool with their
+own unique approaches and benefits. Specifically, I'd look at gRPC since it makes client-server
+communication feel like a single program on a single computer, no need to hand-write a client library
+and the request/response payloads are typed contracts. NATS is pretty amazing too as a super
+fast and lightweight pub-sub transport that can speak protobufs, with nice service discovery -
+an excellent combination with gRPC.
+
+
+## License
+
+Copyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka)
+
+Licensed under [MIT License](./LICENSE)
+
+[GoDoc]: https://godoc.org/github.com/pressly/chi
+[GoDoc Widget]: https://godoc.org/github.com/pressly/chi?status.svg
+[Travis]: https://travis-ci.org/pressly/chi
+[Travis Widget]: https://travis-ci.org/pressly/chi.svg?branch=master
--- a/vendor/github.com/pressly/chi/chain.go
+++ b/vendor/github.com/pressly/chi/chain.go
@@ -0,0 +1,47 @@
+package chi
+
+import "net/http"
+
+// Chain returns a Middlewares type from a slice of middleware handlers.
+func Chain(middlewares ...func(http.Handler) http.Handler) Middlewares {
+	return Middlewares(middlewares)
+}
+
+// Handler builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) Handler(h http.Handler) http.Handler {
+	return &ChainHandler{mws, h, chain(mws, h)}
+}
+
+// HandlerFunc builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler {
+	return &ChainHandler{mws, h, chain(mws, h)}
+}
+
+type ChainHandler struct {
+	Middlewares Middlewares
+	Endpoint    http.Handler
+	chain       http.Handler
+}
+
+func (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c.chain.ServeHTTP(w, r)
+}
+
+// chain builds a http.Handler composed of an inline middleware stack and endpoint
+// handler in the order they are passed.
+func chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler {
+	// Return ahead of time if there aren't any middlewares for the chain
+	if len(middlewares) == 0 {
+		return endpoint
+	}
+
+	// Wrap the end handler with the middleware chain
+	h := middlewares[len(middlewares)-1](endpoint)
+	for i := len(middlewares) - 2; i >= 0; i-- {
+		h = middlewares[i](h)
+	}
+
+	return h
+}
--- a/vendor/github.com/pressly/chi/chi.go
+++ b/vendor/github.com/pressly/chi/chi.go
@@ -0,0 +1,98 @@
+//
+// Package chi is a small, idiomatic and composable router for building HTTP services.
+//
+// chi requires Go 1.7 or newer.
+//
+// Example:
+//  package main
+//
+//  import (
+//  	"net/http"
+//
+//  	"github.com/pressly/chi"
+//  	"github.com/pressly/chi/middleware"
+//  )
+//
+//  func main() {
+//  	r := chi.NewRouter()
+//  	r.Use(middleware.Logger)
+//  	r.Use(middleware.Recoverer)
+//
+//  	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+//  		w.Write([]byte("root."))
+//  	})
+//
+//  	http.ListenAndServe(":3333", r)
+//  }
+//
+// See github.com/pressly/chi/_examples/ for more in-depth examples.
+//
+package chi
+
+import "net/http"
+
+// NewRouter returns a new Mux object that implements the Router interface.
+func NewRouter() *Mux {
+	return NewMux()
+}
+
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+	http.Handler
+	Routes
+
+	// Use appends one of more middlewares onto the Router stack.
+	Use(middlewares ...func(http.Handler) http.Handler)
+
+	// With adds inline middlewares for an endpoint handler.
+	With(middlewares ...func(http.Handler) http.Handler) Router
+
+	// Group adds a new inline-Router along the current routing
+	// path, with a fresh middleware stack for the inline-Router.
+	Group(fn func(r Router)) Router
+
+	// Route mounts a sub-Router along a `pattern`` string.
+	Route(pattern string, fn func(r Router)) Router
+
+	// Mount attaches another http.Handler along ./pattern/*
+	Mount(pattern string, h http.Handler)
+
+	// Handle and HandleFunc adds routes for `pattern` that matches
+	// all HTTP methods.
+	Handle(pattern string, h http.Handler)
+	HandleFunc(pattern string, h http.HandlerFunc)
+
+	// HTTP-method routing along `pattern`
+	Connect(pattern string, h http.HandlerFunc)
+	Delete(pattern string, h http.HandlerFunc)
+	Get(pattern string, h http.HandlerFunc)
+	Head(pattern string, h http.HandlerFunc)
+	Options(pattern string, h http.HandlerFunc)
+	Patch(pattern string, h http.HandlerFunc)
+	Post(pattern string, h http.HandlerFunc)
+	Put(pattern string, h http.HandlerFunc)
+	Trace(pattern string, h http.HandlerFunc)
+
+	// NotFound defines a handler to respond whenever a route could
+	// not be found.
+	NotFound(h http.HandlerFunc)
+
+	// MethodNotAllowed defines a handler to respond whenever a method is
+	// not allowed.
+	MethodNotAllowed(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the `docgen` subpackage to generation documentation for Routers.
+type Routes interface {
+	// Routes returns the routing tree in an easily traversable structure.
+	Routes() []Route
+
+	// Middlewares returns the list of middlewares in use by the router.
+	Middlewares() Middlewares
+}
+
+// Middlewares type is a slice of standard middleware handlers with methods
+// to compose middleware chains and http.Handler's.
+type Middlewares []func(http.Handler) http.Handler
--- a/vendor/github.com/pressly/chi/context.go
+++ b/vendor/github.com/pressly/chi/context.go
@@ -0,0 +1,138 @@
+package chi
+
+import (
+	"context"
+	"net"
+	"net/http"
+)
+
+var (
+	RouteCtxKey = &contextKey{"RouteContext"}
+)
+
+// Context is the default routing context set on the root node of a
+// request context to track URL parameters and an optional routing path.
+type Context struct {
+	// URL routing parameter key and values.
+	URLParams params
+
+	// Routing path override used by subrouters.
+	RoutePath string
+
+	// Routing pattern matching the path.
+	RoutePattern string
+
+	// Routing patterns throughout the lifecycle of the request,
+	// across all connected routers.
+	RoutePatterns []string
+}
+
+// NewRouteContext returns a new routing Context object.
+func NewRouteContext() *Context {
+	return &Context{}
+}
+
+// reset a routing context to its initial state.
+func (x *Context) reset() {
+	x.URLParams = x.URLParams[:0]
+	x.RoutePath = ""
+	x.RoutePattern = ""
+	x.RoutePatterns = x.RoutePatterns[:0]
+}
+
+// RouteContext returns chi's routing Context object from a
+// http.Request Context.
+func RouteContext(ctx context.Context) *Context {
+	return ctx.Value(RouteCtxKey).(*Context)
+}
+
+// URLParam returns the url parameter from a http.Request object.
+func URLParam(r *http.Request, key string) string {
+	if rctx := RouteContext(r.Context()); rctx != nil {
+		return rctx.URLParams.Get(key)
+	}
+	return ""
+}
+
+// URLParamFromCtx returns the url parameter from a http.Request Context.
+func URLParamFromCtx(ctx context.Context, key string) string {
+	if rctx := RouteContext(ctx); rctx != nil {
+		return rctx.URLParams.Get(key)
+	}
+	return ""
+}
+
+type param struct {
+	Key, Value string
+}
+
+type params []param
+
+func (ps *params) Add(key string, value string) {
+	*ps = append(*ps, param{key, value})
+}
+
+func (ps params) Get(key string) string {
+	for _, p := range ps {
+		if p.Key == key {
+			return p.Value
+		}
+	}
+	return ""
+}
+
+func (ps *params) Set(key string, value string) {
+	idx := -1
+	for i, p := range *ps {
+		if p.Key == key {
+			idx = i
+			break
+		}
+	}
+	if idx < 0 {
+		(*ps).Add(key, value)
+	} else {
+		(*ps)[idx] = param{key, value}
+	}
+}
+
+func (ps *params) Del(key string) string {
+	for i, p := range *ps {
+		if p.Key == key {
+			*ps = append((*ps)[:i], (*ps)[i+1:]...)
+			return p.Value
+		}
+	}
+	return ""
+}
+
+// ServerBaseContext wraps an http.Handler to set the request context to the
+// `baseCtx`.
+func ServerBaseContext(h http.Handler, baseCtx context.Context) http.Handler {
+	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		baseCtx := baseCtx
+
+		// Copy over default net/http server context keys
+		if v, ok := ctx.Value(http.ServerContextKey).(*http.Server); ok {
+			baseCtx = context.WithValue(baseCtx, http.ServerContextKey, v)
+		}
+		if v, ok := ctx.Value(http.LocalAddrContextKey).(net.Addr); ok {
+			baseCtx = context.WithValue(baseCtx, http.LocalAddrContextKey, v)
+		}
+
+		h.ServeHTTP(w, r.WithContext(baseCtx))
+	})
+	return fn
+}
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation. This technique
+// for defining context keys was copied from Go 1.7's new use of context in net/http.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string {
+	return "chi context value " + k.name
+}
--- a/vendor/github.com/pressly/chi/middleware/closenotify17.go
+++ b/vendor/github.com/pressly/chi/middleware/closenotify17.go
@@ -0,0 +1,42 @@
+// +build go1.7,!go1.8
+
+package middleware
+
+import (
+	"context"
+	"net/http"
+)
+
+// CloseNotify is a middleware that cancels ctx when the underlying
+// connection has gone away. It can be used to cancel long operations
+// on the server when the client disconnects before the response is ready.
+//
+// Note: this behaviour is standard in Go 1.8+, so the middleware does nothing
+// on 1.8+ and exists just for backwards compatibility.
+func CloseNotify(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		cn, ok := w.(http.CloseNotifier)
+		if !ok {
+			panic("chi/middleware: CloseNotify expects http.ResponseWriter to implement http.CloseNotifier interface")
+		}
+		closeNotifyCh := cn.CloseNotify()
+
+		ctx, cancel := context.WithCancel(r.Context())
+		defer cancel()
+
+		go func() {
+			select {
+			case <-ctx.Done():
+				return
+			case <-closeNotifyCh:
+				cancel()
+				return
+			}
+		}()
+
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
--- a/vendor/github.com/pressly/chi/middleware/closenotify18.go
+++ b/vendor/github.com/pressly/chi/middleware/closenotify18.go
@@ -0,0 +1,17 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"net/http"
+)
+
+// CloseNotify is a middleware that cancels ctx when the underlying
+// connection has gone away. It can be used to cancel long operations
+// on the server when the client disconnects before the response is ready.
+//
+// Note: this behaviour is standard in Go 1.8+, so the middleware does nothing
+// on 1.8+ and exists just for backwards compatibility.
+func CloseNotify(next http.Handler) http.Handler {
+	return next
+}
--- a/vendor/github.com/pressly/chi/middleware/compress.go
+++ b/vendor/github.com/pressly/chi/middleware/compress.go
@@ -0,0 +1,212 @@
+package middleware
+
+import (
+	"bufio"
+	"compress/flate"
+	"compress/gzip"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+)
+
+type encoding int
+
+const (
+	encodingNone encoding = iota
+	encodingGzip
+	encodingDeflate
+)
+
+var defaultContentTypes = map[string]struct{}{
+	"text/html":                struct{}{},
+	"text/css":                 struct{}{},
+	"text/plain":               struct{}{},
+	"text/javascript":          struct{}{},
+	"application/javascript":   struct{}{},
+	"application/x-javascript": struct{}{},
+	"application/json":         struct{}{},
+	"application/atom+xml":     struct{}{},
+	"application/rss+xml ":     struct{}{},
+}
+
+// DefaultCompress is a middleware that compresses response
+// body of predefined content types to a data format based
+// on Accept-Encoding request header. It uses a default
+// compression level.
+func DefaultCompress(next http.Handler) http.Handler {
+	return Compress(flate.DefaultCompression)(next)
+}
+
+// Compress is a middleware that compresses response
+// body of a given content types to a data format based
+// on Accept-Encoding request header. It uses a given
+// compression level.
+func Compress(level int, types ...string) func(next http.Handler) http.Handler {
+	contentTypes := defaultContentTypes
+	if len(types) > 0 {
+		contentTypes = make(map[string]struct{}, len(types))
+		for _, t := range types {
+			contentTypes[t] = struct{}{}
+		}
+	}
+
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			mcw := &maybeCompressResponseWriter{
+				ResponseWriter: w,
+				w:              w,
+				contentTypes:   contentTypes,
+				encoding:       selectEncoding(r.Header),
+				level:          level,
+			}
+			defer mcw.Close()
+
+			next.ServeHTTP(mcw, r)
+		}
+
+		return http.HandlerFunc(fn)
+	}
+}
+
+func selectEncoding(h http.Header) encoding {
+	enc := h.Get("Accept-Encoding")
+
+	switch {
+	// TODO:
+	// case "br":    // Brotli, experimental. Firefox 2016, to-be-in Chromium.
+	// case "lzma":  // Opera.
+	// case "sdch":  // Chrome, Android. Gzip output + dictionary header.
+
+	case strings.Contains(enc, "gzip"):
+		// TODO: Exception for old MSIE browsers that can't handle non-HTML?
+		// https://zoompf.com/blog/2012/02/lose-the-wait-http-compression
+		return encodingGzip
+
+	case strings.Contains(enc, "deflate"):
+		// HTTP 1.1 "deflate" (RFC 2616) stands for DEFLATE data (RFC 1951)
+		// wrapped with zlib (RFC 1950). The zlib wrapper uses Adler-32
+		// checksum compared to CRC-32 used in "gzip" and thus is faster.
+		//
+		// But.. some old browsers (MSIE, Safari 5.1) incorrectly expect
+		// raw DEFLATE data only, without the mentioned zlib wrapper.
+		// Because of this major confusion, most modern browsers try it
+		// both ways, first looking for zlib headers.
+		// Quote by Mark Adler: http://stackoverflow.com/a/9186091/385548
+		//
+		// The list of browsers having problems is quite big, see:
+		// http://zoompf.com/blog/2012/02/lose-the-wait-http-compression
+		// https://web.archive.org/web/20120321182910/http://www.vervestudios.co/projects/compression-tests/results
+		//
+		// That's why we prefer gzip over deflate. It's just more reliable
+		// and not significantly slower than gzip.
+		return encodingDeflate
+
+		// NOTE: Not implemented, intentionally:
+		// case "compress": // LZW. Deprecated.
+		// case "bzip2":    // Too slow on-the-fly.
+		// case "zopfli":   // Too slow on-the-fly.
+		// case "xz":       // Too slow on-the-fly.
+	}
+
+	return encodingNone
+}
+
+type maybeCompressResponseWriter struct {
+	http.ResponseWriter
+	w            io.Writer
+	encoding     encoding
+	contentTypes map[string]struct{}
+	level        int
+	wroteHeader  bool
+}
+
+func (w *maybeCompressResponseWriter) WriteHeader(code int) {
+	if w.wroteHeader {
+		return
+	}
+	w.wroteHeader = true
+	defer w.ResponseWriter.WriteHeader(code)
+
+	// Already compressed data?
+	if w.ResponseWriter.Header().Get("Content-Encoding") != "" {
+		return
+	}
+	// The content-length after compression is unknown
+	w.ResponseWriter.Header().Del("Content-Length")
+
+	// Parse the first part of the Content-Type response header.
+	contentType := ""
+	parts := strings.Split(w.ResponseWriter.Header().Get("Content-Type"), ";")
+	if len(parts) > 0 {
+		contentType = parts[0]
+	}
+
+	// Is the content type compressable?
+	if _, ok := w.contentTypes[contentType]; !ok {
+		return
+	}
+
+	// Select the compress writer.
+	switch w.encoding {
+	case encodingGzip:
+		gw, err := gzip.NewWriterLevel(w.ResponseWriter, w.level)
+		if err != nil {
+			w.w = w.ResponseWriter
+			return
+		}
+		w.w = gw
+		w.ResponseWriter.Header().Set("Content-Encoding", "gzip")
+
+	case encodingDeflate:
+		dw, err := flate.NewWriter(w.ResponseWriter, w.level)
+		if err != nil {
+			w.w = w.ResponseWriter
+			return
+		}
+		w.w = dw
+		w.ResponseWriter.Header().Set("Content-Encoding", "deflate")
+	}
+}
+
+func (w *maybeCompressResponseWriter) Write(p []byte) (int, error) {
+	if !w.wroteHeader {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	return w.w.Write(p)
+}
+
+func (w *maybeCompressResponseWriter) Flush() {
+	if f, ok := w.w.(http.Flusher); ok {
+		f.Flush()
+	}
+}
+
+func (w *maybeCompressResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hj, ok := w.w.(http.Hijacker); ok {
+		return hj.Hijack()
+	}
+	return nil, nil, errors.New("chi/middleware: http.Hijacker is unavailable on the writer")
+}
+
+func (w *maybeCompressResponseWriter) CloseNotify() <-chan bool {
+	if cn, ok := w.w.(http.CloseNotifier); ok {
+		return cn.CloseNotify()
+	}
+
+	// If the underlying writer does not implement http.CloseNotifier, return
+	// a channel that never receives a value. The semantics here is that the
+	// client never disconnnects before the request is processed by the
+	// http.Handler, which is close enough to the default behavior (when
+	// CloseNotify() is not even called).
+	return make(chan bool, 1)
+}
+
+func (w *maybeCompressResponseWriter) Close() error {
+	if c, ok := w.w.(io.WriteCloser); ok {
+		return c.Close()
+	}
+	return errors.New("chi/middleware: io.WriteCloser is unavailable on the writer")
+}
--- a/vendor/github.com/pressly/chi/middleware/compress18.go
+++ b/vendor/github.com/pressly/chi/middleware/compress18.go
@@ -0,0 +1,15 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"errors"
+	"net/http"
+)
+
+func (w *maybeCompressResponseWriter) Push(target string, opts *http.PushOptions) error {
+	if ps, ok := w.w.(http.Pusher); ok {
+		return ps.Push(target, opts)
+	}
+	return errors.New("chi/middleware: http.Pusher is unavailable on the writer")
+}
--- a/vendor/github.com/pressly/chi/middleware/heartbeat.go
+++ b/vendor/github.com/pressly/chi/middleware/heartbeat.go
@@ -0,0 +1,26 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+// Heartbeat endpoint middleware useful to setting up a path like
+// `/ping` that load balancers or uptime testing external services
+// can make a request before hitting any routes. It's also convenient
+// to place this above ACL middlewares as well.
+func Heartbeat(endpoint string) func(http.Handler) http.Handler {
+	f := func(h http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			if r.Method == "GET" && strings.EqualFold(r.URL.Path, endpoint) {
+				w.Header().Set("Content-Type", "text/plain")
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("."))
+				return
+			}
+			h.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+	return f
+}
--- a/vendor/github.com/pressly/chi/middleware/logger.go
+++ b/vendor/github.com/pressly/chi/middleware/logger.go
@@ -0,0 +1,137 @@
+package middleware
+
+import (
+	"bytes"
+	"context"
+	"log"
+	"net/http"
+	"os"
+	"time"
+)
+
+var (
+	LogEntryCtxKey = &contextKey{"LogEntry"}
+
+	DefaultLogger = RequestLogger(&DefaultLogFormatter{Logger: log.New(os.Stdout, "", log.LstdFlags)})
+)
+
+// Logger is a middleware that logs the start and end of each request, along
+// with some useful data about what was requested, what the response status was,
+// and how long it took to return. When standard output is a TTY, Logger will
+// print in color, otherwise it will print in black and white. Logger prints a
+// request ID if one is provided.
+//
+// Alternatively, look at https://github.com/pressly/lg and the `lg.RequestLogger`
+// middleware pkg.
+func Logger(next http.Handler) http.Handler {
+	return DefaultLogger(next)
+}
+
+func RequestLogger(f LogFormatter) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			entry := f.NewLogEntry(r)
+			ww := NewWrapResponseWriter(w, r.ProtoMajor)
+
+			t1 := time.Now()
+			defer func() {
+				t2 := time.Now()
+				entry.Write(ww.Status(), ww.BytesWritten(), t2.Sub(t1))
+			}()
+
+			next.ServeHTTP(ww, WithLogEntry(r, entry))
+		}
+		return http.HandlerFunc(fn)
+	}
+}
+
+type LogFormatter interface {
+	NewLogEntry(r *http.Request) LogEntry
+}
+
+type LogEntry interface {
+	Write(status, bytes int, elapsed time.Duration)
+	Panic(v interface{}, stack []byte)
+}
+
+func GetLogEntry(r *http.Request) LogEntry {
+	entry, _ := r.Context().Value(LogEntryCtxKey).(LogEntry)
+	return entry
+}
+
+func WithLogEntry(r *http.Request, entry LogEntry) *http.Request {
+	r = r.WithContext(context.WithValue(r.Context(), LogEntryCtxKey, entry))
+	return r
+}
+
+type DefaultLogFormatter struct {
+	Logger *log.Logger
+}
+
+func (l *DefaultLogFormatter) NewLogEntry(r *http.Request) LogEntry {
+	entry := &defaultLogEntry{
+		DefaultLogFormatter: l,
+		request:             r,
+		buf:                 &bytes.Buffer{},
+	}
+
+	reqID := GetReqID(r.Context())
+	if reqID != "" {
+		cW(entry.buf, nYellow, "[%s] ", reqID)
+	}
+	cW(entry.buf, nCyan, "\"")
+	cW(entry.buf, bMagenta, "%s ", r.Method)
+
+	scheme := "http"
+	if r.TLS != nil {
+		scheme = "https"
+	}
+	cW(entry.buf, nCyan, "%s://%s%s %s\" ", scheme, r.Host, r.RequestURI, r.Proto)
+
+	entry.buf.WriteString("from ")
+	entry.buf.WriteString(r.RemoteAddr)
+	entry.buf.WriteString(" - ")
+
+	return entry
+}
+
+type defaultLogEntry struct {
+	*DefaultLogFormatter
+	request *http.Request
+	buf     *bytes.Buffer
+}
+
+func (l *defaultLogEntry) Write(status, bytes int, elapsed time.Duration) {
+	switch {
+	case status < 200:
+		cW(l.buf, bBlue, "%03d", status)
+	case status < 300:
+		cW(l.buf, bGreen, "%03d", status)
+	case status < 400:
+		cW(l.buf, bCyan, "%03d", status)
+	case status < 500:
+		cW(l.buf, bYellow, "%03d", status)
+	default:
+		cW(l.buf, bRed, "%03d", status)
+	}
+
+	cW(l.buf, bBlue, " %dB", bytes)
+
+	l.buf.WriteString(" in ")
+	if elapsed < 500*time.Millisecond {
+		cW(l.buf, nGreen, "%s", elapsed)
+	} else if elapsed < 5*time.Second {
+		cW(l.buf, nYellow, "%s", elapsed)
+	} else {
+		cW(l.buf, nRed, "%s", elapsed)
+	}
+
+	l.Logger.Print(l.buf.String())
+}
+
+func (l *defaultLogEntry) Panic(v interface{}, stack []byte) {
+	panicEntry := l.NewLogEntry(l.request).(*defaultLogEntry)
+	cW(panicEntry.buf, bRed, "panic: %+v", v)
+	l.Logger.Print(panicEntry.buf.String())
+	l.Logger.Print(string(stack))
+}
--- a/vendor/github.com/pressly/chi/middleware/middleware.go
+++ b/vendor/github.com/pressly/chi/middleware/middleware.go
@@ -0,0 +1,12 @@
+package middleware
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation. This technique
+// for defining context keys was copied from Go 1.7's new use of context in net/http.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string {
+	return "chi/middleware context value " + k.name
+}
--- a/vendor/github.com/pressly/chi/middleware/nocache.go
+++ b/vendor/github.com/pressly/chi/middleware/nocache.go
@@ -0,0 +1,58 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"time"
+)
+
+// Unix epoch time
+var epoch = time.Unix(0, 0).Format(time.RFC1123)
+
+// Taken from https://github.com/mytrile/nocache
+var noCacheHeaders = map[string]string{
+	"Expires":         epoch,
+	"Cache-Control":   "no-cache, private, max-age=0",
+	"Pragma":          "no-cache",
+	"X-Accel-Expires": "0",
+}
+
+var etagHeaders = []string{
+	"ETag",
+	"If-Modified-Since",
+	"If-Match",
+	"If-None-Match",
+	"If-Range",
+	"If-Unmodified-Since",
+}
+
+// NoCache is a simple piece of middleware that sets a number of HTTP headers to prevent
+// a router (or subrouter) from being cached by an upstream proxy and/or client.
+//
+// As per http://wiki.nginx.org/HttpProxyModule - NoCache sets:
+//      Expires: Thu, 01 Jan 1970 00:00:00 UTC
+//      Cache-Control: no-cache, private, max-age=0
+//      X-Accel-Expires: 0
+//      Pragma: no-cache (for HTTP/1.0 proxies/clients)
+func NoCache(h http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+
+		// Delete any ETag headers that may have been set
+		for _, v := range etagHeaders {
+			if r.Header.Get(v) != "" {
+				r.Header.Del(v)
+			}
+		}
+
+		// Set our NoCache headers
+		for k, v := range noCacheHeaders {
+			w.Header().Set(k, v)
+		}
+
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
--- a/vendor/github.com/pressly/chi/middleware/profiler.go
+++ b/vendor/github.com/pressly/chi/middleware/profiler.go
@@ -0,0 +1,58 @@
+package middleware
+
+import (
+	"expvar"
+	"fmt"
+	"net/http"
+	"net/http/pprof"
+
+	"github.com/pressly/chi"
+)
+
+// Profiler is a convenient subrouter used for mounting net/http/pprof. ie.
+//
+//  func MyService() http.Handler {
+//    r := chi.NewRouter()
+//    // ..middlewares
+//    r.Mount("/debug", middleware.Profiler())
+//    // ..routes
+//    return r
+//  }
+func Profiler() http.Handler {
+	r := chi.NewRouter()
+	r.Use(NoCache)
+
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, r.RequestURI+"/pprof/", 301)
+	})
+	r.HandleFunc("/pprof", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, r.RequestURI+"/", 301)
+	})
+
+	r.HandleFunc("/pprof/", pprof.Index)
+	r.HandleFunc("/pprof/cmdline", pprof.Cmdline)
+	r.HandleFunc("/pprof/profile", pprof.Profile)
+	r.HandleFunc("/pprof/symbol", pprof.Symbol)
+	r.Handle("/pprof/block", pprof.Handler("block"))
+	r.Handle("/pprof/heap", pprof.Handler("heap"))
+	r.Handle("/pprof/goroutine", pprof.Handler("goroutine"))
+	r.Handle("/pprof/threadcreate", pprof.Handler("threadcreate"))
+	r.HandleFunc("/vars", expVars)
+
+	return r
+}
+
+// Replicated from expvar.go as not public.
+func expVars(w http.ResponseWriter, r *http.Request) {
+	first := true
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	fmt.Fprintf(w, "{\n")
+	expvar.Do(func(kv expvar.KeyValue) {
+		if !first {
+			fmt.Fprintf(w, ",\n")
+		}
+		first = false
+		fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
+	})
+	fmt.Fprintf(w, "\n}\n")
+}
--- a/vendor/github.com/pressly/chi/middleware/realip.go
+++ b/vendor/github.com/pressly/chi/middleware/realip.go
@@ -0,0 +1,54 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+var xForwardedFor = http.CanonicalHeaderKey("X-Forwarded-For")
+var xRealIP = http.CanonicalHeaderKey("X-Real-IP")
+
+// RealIP is a middleware that sets a http.Request's RemoteAddr to the results
+// of parsing either the X-Forwarded-For header or the X-Real-IP header (in that
+// order).
+//
+// This middleware should be inserted fairly early in the middleware stack to
+// ensure that subsequent layers (e.g., request loggers) which examine the
+// RemoteAddr will see the intended value.
+//
+// You should only use this middleware if you can trust the headers passed to
+// you (in particular, the two headers this middleware uses), for example
+// because you have placed a reverse proxy like HAProxy or nginx in front of
+// Goji. If your reverse proxies are configured to pass along arbitrary header
+// values from the client, or if you use this middleware without a reverse
+// proxy, malicious clients will be able to make you very sad (or, depending on
+// how you're using RemoteAddr, vulnerable to an attack of some sort).
+func RealIP(h http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		if rip := realIP(r); rip != "" {
+			r.RemoteAddr = rip
+		}
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
+
+func realIP(r *http.Request) string {
+	var ip string
+
+	if xff := r.Header.Get(xForwardedFor); xff != "" {
+		i := strings.Index(xff, ", ")
+		if i == -1 {
+			i = len(xff)
+		}
+		ip = xff[:i]
+	} else if xrip := r.Header.Get(xRealIP); xrip != "" {
+		ip = xrip
+	}
+
+	return ip
+}
--- a/vendor/github.com/pressly/chi/middleware/recoverer.go
+++ b/vendor/github.com/pressly/chi/middleware/recoverer.go
@@ -0,0 +1,36 @@
+package middleware
+
+// The original work was derived from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"net/http"
+	"runtime/debug"
+)
+
+// Recoverer is a middleware that recovers from panics, logs the panic (and a
+// backtrace), and returns a HTTP 500 (Internal Server Error) status if
+// possible. Recoverer prints a request ID if one is provided.
+//
+// Alternatively, look at https://github.com/pressly/lg middleware pkgs.
+func Recoverer(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if rvr := recover(); rvr != nil {
+
+				logEntry := GetLogEntry(r)
+				if logEntry != nil {
+					logEntry.Panic(rvr, debug.Stack())
+				} else {
+					debug.PrintStack()
+				}
+
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			}
+		}()
+
+		next.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
--- a/vendor/github.com/pressly/chi/middleware/request_id.go
+++ b/vendor/github.com/pressly/chi/middleware/request_id.go
@@ -0,0 +1,88 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"sync/atomic"
+)
+
+// Key to use when setting the request ID.
+type ctxKeyRequestID int
+
+// RequestIDKey is the key that holds th unique request ID in a request context.
+const RequestIDKey ctxKeyRequestID = 0
+
+var prefix string
+var reqid uint64
+
+// A quick note on the statistics here: we're trying to calculate the chance that
+// two randomly generated base62 prefixes will collide. We use the formula from
+// http://en.wikipedia.org/wiki/Birthday_problem
+//
+// P[m, n] \approx 1 - e^{-m^2/2n}
+//
+// We ballpark an upper bound for $m$ by imagining (for whatever reason) a server
+// that restarts every second over 10 years, for $m = 86400 * 365 * 10 = 315360000$
+//
+// For a $k$ character base-62 identifier, we have $n(k) = 62^k$
+//
+// Plugging this in, we find $P[m, n(10)] \approx 5.75%$, which is good enough for
+// our purposes, and is surely more than anyone would ever need in practice -- a
+// process that is rebooted a handful of times a day for a hundred years has less
+// than a millionth of a percent chance of generating two colliding IDs.
+
+func init() {
+	hostname, err := os.Hostname()
+	if hostname == "" || err != nil {
+		hostname = "localhost"
+	}
+	var buf [12]byte
+	var b64 string
+	for len(b64) < 10 {
+		rand.Read(buf[:])
+		b64 = base64.StdEncoding.EncodeToString(buf[:])
+		b64 = strings.NewReplacer("+", "", "/", "").Replace(b64)
+	}
+
+	prefix = fmt.Sprintf("%s/%s", hostname, b64[0:10])
+}
+
+// RequestID is a middleware that injects a request ID into the context of each
+// request. A request ID is a string of the form "host.example.com/random-0001",
+// where "random" is a base62 random string that uniquely identifies this go
+// process, and where the last number is an atomically incremented request
+// counter.
+func RequestID(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		myid := atomic.AddUint64(&reqid, 1)
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, RequestIDKey, fmt.Sprintf("%s-%06d", prefix, myid))
+		next.ServeHTTP(w, r.WithContext(ctx))
+	}
+	return http.HandlerFunc(fn)
+}
+
+// GetReqID returns a request ID from the given context if one is present.
+// Returns the empty string if a request ID cannot be found.
+func GetReqID(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if reqID, ok := ctx.Value(RequestIDKey).(string); ok {
+		return reqID
+	}
+	return ""
+}
+
+// NextRequestID generates the next request ID in the sequence.
+func NextRequestID() uint64 {
+	return atomic.AddUint64(&reqid, 1)
+}
--- a/vendor/github.com/pressly/chi/middleware/strip.go
+++ b/vendor/github.com/pressly/chi/middleware/strip.go
@@ -0,0 +1,48 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/pressly/chi"
+)
+
+// StripSlashes is a middleware that will match request paths with a trailing
+// slash, strip it from the path and continue routing through the mux, if a route
+// matches, then it will serve the handler.
+func StripSlashes(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		var path string
+		rctx := chi.RouteContext(r.Context())
+		if rctx.RoutePath != "" {
+			path = rctx.RoutePath
+		} else {
+			path = r.URL.Path
+		}
+		if len(path) > 1 && path[len(path)-1] == '/' {
+			rctx.RoutePath = path[:len(path)-1]
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}
+
+// RedirectSlashes is a middleware that will match request paths with a trailing
+// slash and redirect to the same path, less the trailing slash.
+func RedirectSlashes(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		var path string
+		rctx := chi.RouteContext(r.Context())
+		if rctx.RoutePath != "" {
+			path = rctx.RoutePath
+		} else {
+			path = r.URL.Path
+		}
+		if len(path) > 1 && path[len(path)-1] == '/' {
+			path = path[:len(path)-1]
+			http.Redirect(w, r, path, 301)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}
--- a/vendor/github.com/pressly/chi/middleware/terminal.go
+++ b/vendor/github.com/pressly/chi/middleware/terminal.go
@@ -0,0 +1,63 @@
+package middleware
+
+// Ported from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+var (
+	// Normal colors
+	nBlack   = []byte{'\033', '[', '3', '0', 'm'}
+	nRed     = []byte{'\033', '[', '3', '1', 'm'}
+	nGreen   = []byte{'\033', '[', '3', '2', 'm'}
+	nYellow  = []byte{'\033', '[', '3', '3', 'm'}
+	nBlue    = []byte{'\033', '[', '3', '4', 'm'}
+	nMagenta = []byte{'\033', '[', '3', '5', 'm'}
+	nCyan    = []byte{'\033', '[', '3', '6', 'm'}
+	nWhite   = []byte{'\033', '[', '3', '7', 'm'}
+	// Bright colors
+	bBlack   = []byte{'\033', '[', '3', '0', ';', '1', 'm'}
+	bRed     = []byte{'\033', '[', '3', '1', ';', '1', 'm'}
+	bGreen   = []byte{'\033', '[', '3', '2', ';', '1', 'm'}
+	bYellow  = []byte{'\033', '[', '3', '3', ';', '1', 'm'}
+	bBlue    = []byte{'\033', '[', '3', '4', ';', '1', 'm'}
+	bMagenta = []byte{'\033', '[', '3', '5', ';', '1', 'm'}
+	bCyan    = []byte{'\033', '[', '3', '6', ';', '1', 'm'}
+	bWhite   = []byte{'\033', '[', '3', '7', ';', '1', 'm'}
+
+	reset = []byte{'\033', '[', '0', 'm'}
+)
+
+var isTTY bool
+
+func init() {
+	// This is sort of cheating: if stdout is a character device, we assume
+	// that means it's a TTY. Unfortunately, there are many non-TTY
+	// character devices, but fortunately stdout is rarely set to any of
+	// them.
+	//
+	// We could solve this properly by pulling in a dependency on
+	// code.google.com/p/go.crypto/ssh/terminal, for instance, but as a
+	// heuristic for whether to print in color or in black-and-white, I'd
+	// really rather not.
+	fi, err := os.Stdout.Stat()
+	if err == nil {
+		m := os.ModeDevice | os.ModeCharDevice
+		isTTY = fi.Mode()&m == m
+	}
+}
+
+// colorWrite
+func cW(w io.Writer, color []byte, s string, args ...interface{}) {
+	if isTTY {
+		w.Write(color)
+	}
+	fmt.Fprintf(w, s, args...)
+	if isTTY {
+		w.Write(reset)
+	}
+}
--- a/vendor/github.com/pressly/chi/middleware/throttler.go
+++ b/vendor/github.com/pressly/chi/middleware/throttler.go
@@ -0,0 +1,101 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+)
+
+const (
+	errCapacityExceeded = "Server capacity exceeded."
+	errTimedOut         = "Timed out while waiting for a pending request to complete."
+	errContextCanceled  = "Context was canceled."
+)
+
+var (
+	defaultBacklogTimeout = time.Second * 60
+)
+
+// Throttle is a middleware that limits number of currently processed requests
+// at a time.
+func Throttle(limit int) func(http.Handler) http.Handler {
+	return ThrottleBacklog(limit, 0, defaultBacklogTimeout)
+}
+
+// ThrottleBacklog is a middleware that limits number of currently processed
+// requests at a time and provides a backlog for holding a finite number of
+// pending requests.
+func ThrottleBacklog(limit int, backlogLimit int, backlogTimeout time.Duration) func(http.Handler) http.Handler {
+	if limit < 1 {
+		panic("chi/middleware: Throttle expects limit > 0")
+	}
+
+	if backlogLimit < 0 {
+		panic("chi/middleware: Throttle expects backlogLimit to be positive")
+	}
+
+	t := throttler{
+		tokens:         make(chan token, limit),
+		backlogTokens:  make(chan token, limit+backlogLimit),
+		backlogTimeout: backlogTimeout,
+	}
+
+	// Filling tokens.
+	for i := 0; i < limit+backlogLimit; i++ {
+		if i < limit {
+			t.tokens <- token{}
+		}
+		t.backlogTokens <- token{}
+	}
+
+	fn := func(h http.Handler) http.Handler {
+		t.h = h
+		return &t
+	}
+
+	return fn
+}
+
+// token represents a request that is being processed.
+type token struct{}
+
+// throttler limits number of currently processed requests at a time.
+type throttler struct {
+	h              http.Handler
+	tokens         chan token
+	backlogTokens  chan token
+	backlogTimeout time.Duration
+}
+
+// ServeHTTP is the primary throttler request handler
+func (t *throttler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	select {
+	case <-ctx.Done():
+		http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
+		return
+	case btok := <-t.backlogTokens:
+		timer := time.NewTimer(t.backlogTimeout)
+
+		defer func() {
+			t.backlogTokens <- btok
+		}()
+
+		select {
+		case <-timer.C:
+			http.Error(w, errTimedOut, http.StatusServiceUnavailable)
+			return
+		case <-ctx.Done():
+			http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
+			return
+		case tok := <-t.tokens:
+			defer func() {
+				t.tokens <- tok
+			}()
+			t.h.ServeHTTP(w, r)
+		}
+		return
+	default:
+		http.Error(w, errCapacityExceeded, http.StatusServiceUnavailable)
+		return
+	}
+}
--- a/vendor/github.com/pressly/chi/middleware/timeout.go
+++ b/vendor/github.com/pressly/chi/middleware/timeout.go
@@ -0,0 +1,48 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Timeout is a middleware that cancels ctx after a given timeout and return
+// a 504 Gateway Timeout error to the client.
+//
+// It's required that you select the ctx.Done() channel to check for the signal
+// if the context has reached its deadline and return, otherwise the timeout
+// signal will be just ignored.
+//
+// ie. a route/handler may look like:
+//
+//  r.Get("/long", func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+// 	 processTime := time.Duration(rand.Intn(4)+1) * time.Second
+//
+// 	 select {
+// 	 case <-ctx.Done():
+// 	 	return
+//
+// 	 case <-time.After(processTime):
+// 	 	 // The above channel simulates some hard work.
+// 	 }
+//
+// 	 w.Write([]byte("done"))
+//  })
+//
+func Timeout(timeout time.Duration) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			ctx, cancel := context.WithTimeout(r.Context(), timeout)
+			defer func() {
+				cancel()
+				if ctx.Err() == context.DeadlineExceeded {
+					w.WriteHeader(http.StatusGatewayTimeout)
+				}
+			}()
+
+			r = r.WithContext(ctx)
+			next.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+}
--- a/vendor/github.com/pressly/chi/middleware/value.go
+++ b/vendor/github.com/pressly/chi/middleware/value.go
@@ -0,0 +1,17 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+)
+
+// WithValue is a middleware that sets a given key/value in a context chain.
+func WithValue(key interface{}, val interface{}) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			r = r.WithContext(context.WithValue(r.Context(), key, val))
+			next.ServeHTTP(w, r)
+		}
+		return http.HandlerFunc(fn)
+	}
+}
--- a/vendor/github.com/pressly/chi/middleware/wrap_writer.go
+++ b/vendor/github.com/pressly/chi/middleware/wrap_writer.go
@@ -0,0 +1,144 @@
+package middleware
+
+// The original work was derived from Goji's middleware, source:
+// https://github.com/zenazn/goji/tree/master/web/middleware
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+// WrapResponseWriter is a proxy around an http.ResponseWriter that allows you to hook
+// into various parts of the response process.
+type WrapResponseWriter interface {
+	http.ResponseWriter
+	// Status returns the HTTP status of the request, or 0 if one has not
+	// yet been sent.
+	Status() int
+	// BytesWritten returns the total number of bytes sent to the client.
+	BytesWritten() int
+	// Tee causes the response body to be written to the given io.Writer in
+	// addition to proxying the writes through. Only one io.Writer can be
+	// tee'd to at once: setting a second one will overwrite the first.
+	// Writes will be sent to the proxy before being written to this
+	// io.Writer. It is illegal for the tee'd writer to be modified
+	// concurrently with writes.
+	Tee(io.Writer)
+	// Unwrap returns the original proxied target.
+	Unwrap() http.ResponseWriter
+}
+
+// basicWriter wraps a http.ResponseWriter that implements the minimal
+// http.ResponseWriter interface.
+type basicWriter struct {
+	http.ResponseWriter
+	wroteHeader bool
+	code        int
+	bytes       int
+	tee         io.Writer
+}
+
+func (b *basicWriter) WriteHeader(code int) {
+	if !b.wroteHeader {
+		b.code = code
+		b.wroteHeader = true
+		b.ResponseWriter.WriteHeader(code)
+	}
+}
+func (b *basicWriter) Write(buf []byte) (int, error) {
+	b.WriteHeader(http.StatusOK)
+	n, err := b.ResponseWriter.Write(buf)
+	if b.tee != nil {
+		_, err2 := b.tee.Write(buf[:n])
+		// Prefer errors generated by the proxied writer.
+		if err == nil {
+			err = err2
+		}
+	}
+	b.bytes += n
+	return n, err
+}
+func (b *basicWriter) maybeWriteHeader() {
+	if !b.wroteHeader {
+		b.WriteHeader(http.StatusOK)
+	}
+}
+func (b *basicWriter) Status() int {
+	return b.code
+}
+func (b *basicWriter) BytesWritten() int {
+	return b.bytes
+}
+func (b *basicWriter) Tee(w io.Writer) {
+	b.tee = w
+}
+func (b *basicWriter) Unwrap() http.ResponseWriter {
+	return b.ResponseWriter
+}
+
+type flushWriter struct {
+	basicWriter
+}
+
+func (f *flushWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+var _ http.Flusher = &flushWriter{}
+
+// httpFancyWriter is a HTTP writer that additionally satisfies http.CloseNotifier,
+// http.Flusher, http.Hijacker, and io.ReaderFrom. It exists for the common case
+// of wrapping the http.ResponseWriter that package http gives you, in order to
+// make the proxied object support the full method set of the proxied object.
+type httpFancyWriter struct {
+	basicWriter
+}
+
+func (f *httpFancyWriter) CloseNotify() <-chan bool {
+	cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
+	return cn.CloseNotify()
+}
+func (f *httpFancyWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+func (f *httpFancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hj := f.basicWriter.ResponseWriter.(http.Hijacker)
+	return hj.Hijack()
+}
+func (f *httpFancyWriter) ReadFrom(r io.Reader) (int64, error) {
+	if f.basicWriter.tee != nil {
+		return io.Copy(&f.basicWriter, r)
+	}
+	rf := f.basicWriter.ResponseWriter.(io.ReaderFrom)
+	f.basicWriter.maybeWriteHeader()
+	return rf.ReadFrom(r)
+}
+
+var _ http.CloseNotifier = &httpFancyWriter{}
+var _ http.Flusher = &httpFancyWriter{}
+var _ http.Hijacker = &httpFancyWriter{}
+var _ io.ReaderFrom = &httpFancyWriter{}
+
+// http2FancyWriter is a HTTP2 writer that additionally satisfies http.CloseNotifier,
+// http.Flusher, and io.ReaderFrom. It exists for the common case
+// of wrapping the http.ResponseWriter that package http gives you, in order to
+// make the proxied object support the full method set of the proxied object.
+type http2FancyWriter struct {
+	basicWriter
+}
+
+func (f *http2FancyWriter) CloseNotify() <-chan bool {
+	cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
+	return cn.CloseNotify()
+}
+func (f *http2FancyWriter) Flush() {
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+var _ http.CloseNotifier = &http2FancyWriter{}
+var _ http.Flusher = &http2FancyWriter{}
--- a/vendor/github.com/pressly/chi/middleware/wrap_writer17.go
+++ b/vendor/github.com/pressly/chi/middleware/wrap_writer17.go
@@ -0,0 +1,34 @@
+// +build go1.7,!go1.8
+
+package middleware
+
+import (
+	"io"
+	"net/http"
+)
+
+// NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to
+// hook into various parts of the response process.
+func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {
+	_, cn := w.(http.CloseNotifier)
+	_, fl := w.(http.Flusher)
+
+	bw := basicWriter{ResponseWriter: w}
+
+	if protoMajor == 2 {
+		if cn && fl {
+			return &http2FancyWriter{bw}
+		}
+	} else {
+		_, hj := w.(http.Hijacker)
+		_, rf := w.(io.ReaderFrom)
+		if cn && fl && hj && rf {
+			return &httpFancyWriter{bw}
+		}
+	}
+	if fl {
+		return &flushWriter{bw}
+	}
+
+	return &bw
+}
--- a/vendor/github.com/pressly/chi/middleware/wrap_writer18.go
+++ b/vendor/github.com/pressly/chi/middleware/wrap_writer18.go
@@ -0,0 +1,41 @@
+// +build go1.8
+
+package middleware
+
+import (
+	"io"
+	"net/http"
+)
+
+// NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to
+// hook into various parts of the response process.
+func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {
+	_, cn := w.(http.CloseNotifier)
+	_, fl := w.(http.Flusher)
+
+	bw := basicWriter{ResponseWriter: w}
+
+	if protoMajor == 2 {
+		_, ps := w.(http.Pusher)
+		if cn && fl && ps {
+			return &http2FancyWriter{bw}
+		}
+	} else {
+		_, hj := w.(http.Hijacker)
+		_, rf := w.(io.ReaderFrom)
+		if cn && fl && hj && rf {
+			return &httpFancyWriter{bw}
+		}
+	}
+	if fl {
+		return &flushWriter{bw}
+	}
+
+	return &bw
+}
+
+func (f *http2FancyWriter) Push(target string, opts *http.PushOptions) error {
+	return f.basicWriter.ResponseWriter.(http.Pusher).Push(target, opts)
+}
+
+var _ http.Pusher = &http2FancyWriter{}
--- a/vendor/github.com/pressly/chi/mux.go
+++ b/vendor/github.com/pressly/chi/mux.go
@@ -0,0 +1,408 @@
+package chi
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+)
+
+var _ Router = &Mux{}
+
+// Mux is a simple HTTP route multiplexer that parses a request path,
+// records any URL params, and executes an end handler. It implements
+// the http.Handler interface and is friendly with the standard library.
+//
+// Mux is designed to be fast, minimal and offer a powerful API for building
+// modular and composable HTTP services with a large set of handlers. It's
+// particularly useful for writing large REST API services that break a handler
+// into many smaller parts composed of middlewares and end handlers.
+type Mux struct {
+	// The radix trie router
+	tree *node
+
+	// The middleware stack
+	middlewares []func(http.Handler) http.Handler
+
+	// Controls the behaviour of middleware chain generation when a mux
+	// is registered as an inline group inside another mux.
+	inline bool
+
+	// The computed mux handler made of the chained middleware stack and
+	// the tree router
+	handler http.Handler
+
+	// Routing context pool
+	pool sync.Pool
+
+	// Custom route not found handler
+	notFoundHandler http.HandlerFunc
+
+	// Custom method not allowed handler
+	methodNotAllowedHandler http.HandlerFunc
+}
+
+// NewMux returns a newly initialized Mux object that implements the Router
+// interface.
+func NewMux() *Mux {
+	mux := &Mux{tree: &node{}}
+	mux.pool.New = func() interface{} {
+		return NewRouteContext()
+	}
+	return mux
+}
+
+// ServeHTTP is the single method of the http.Handler interface that makes
+// Mux interoperable with the standard library. It uses a sync.Pool to get and
+// reuse routing contexts for each request.
+func (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Ensure the mux has some routes defined on the mux
+	if mx.handler == nil {
+		panic("chi: attempting to route to a mux with no handlers.")
+	}
+
+	// Check if a routing context already exists from a parent router.
+	rctx, _ := r.Context().Value(RouteCtxKey).(*Context)
+	if rctx != nil {
+		mx.handler.ServeHTTP(w, r)
+		return
+	}
+
+	// Fetch a RouteContext object from the sync pool, and call the computed
+	// mx.handler that is comprised of mx.middlewares + mx.routeHTTP.
+	// Once the request is finished, reset the routing context and put it back
+	// into the pool for reuse from another request.
+	rctx = mx.pool.Get().(*Context)
+	rctx.reset()
+	r = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx))
+	mx.handler.ServeHTTP(w, r)
+	mx.pool.Put(rctx)
+}
+
+// Use appends a middleware handler to the Mux middleware stack.
+//
+// The middleware stack for any Mux will execute before searching for a matching
+// route to a specific handler, which provides opportunity to respond early,
+// change the course of the request execution, or set request-scoped values for
+// the next http.Handler.
+func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
+	if mx.handler != nil {
+		panic("chi: all middlewares must be defined before routes on a mux")
+	}
+	mx.middlewares = append(mx.middlewares, middlewares...)
+}
+
+// Handle adds the route `pattern` that matches any http method to
+// execute the `handler` http.Handler.
+func (mx *Mux) Handle(pattern string, handler http.Handler) {
+	mx.handle(mALL, pattern, handler)
+}
+
+// HandleFunc adds the route `pattern` that matches any http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mALL, pattern, handlerFn)
+}
+
+// Connect adds the route `pattern` that matches a CONNECT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mCONNECT, pattern, handlerFn)
+}
+
+// Delete adds the route `pattern` that matches a DELETE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mDELETE, pattern, handlerFn)
+}
+
+// Get adds the route `pattern` that matches a GET http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mGET, pattern, handlerFn)
+}
+
+// Head adds the route `pattern` that matches a HEAD http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mHEAD, pattern, handlerFn)
+}
+
+// Options adds the route `pattern` that matches a OPTIONS http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mOPTIONS, pattern, handlerFn)
+}
+
+// Patch adds the route `pattern` that matches a PATCH http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPATCH, pattern, handlerFn)
+}
+
+// Post adds the route `pattern` that matches a POST http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPOST, pattern, handlerFn)
+}
+
+// Put adds the route `pattern` that matches a PUT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mPUT, pattern, handlerFn)
+}
+
+// Trace adds the route `pattern` that matches a TRACE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) {
+	mx.handle(mTRACE, pattern, handlerFn)
+}
+
+// NotFound sets a custom http.HandlerFunc for routing paths that could
+// not be found. The default 404 handler is `http.NotFound`.
+func (mx *Mux) NotFound(handlerFn http.HandlerFunc) {
+	mx.notFoundHandler = handlerFn
+
+	mx.updateSubRoutes(func(subMux *Mux) {
+		if subMux.notFoundHandler == nil {
+			subMux.NotFound(handlerFn)
+		}
+	})
+}
+
+// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the
+// method is unresolved. The default handler returns a 405 with an empty body.
+func (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) {
+	mx.methodNotAllowedHandler = handlerFn
+
+	mx.updateSubRoutes(func(subMux *Mux) {
+		if subMux.methodNotAllowedHandler == nil {
+			subMux.MethodNotAllowed(handlerFn)
+		}
+	})
+}
+
+// With adds inline middlewares for an endpoint handler.
+func (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router {
+	// Similarly as in handle(), we must build the mux handler once further
+	// middleware registration isn't allowed for this stack, like now.
+	if !mx.inline && mx.handler == nil {
+		mx.buildRouteHandler()
+	}
+
+	// Copy middlewares from parent inline muxs
+	var mws Middlewares
+	if mx.inline {
+		mws = make(Middlewares, len(mx.middlewares))
+		copy(mws, mx.middlewares)
+	}
+	mws = append(mws, middlewares...)
+
+	im := &Mux{inline: true, tree: mx.tree, middlewares: mws}
+	return im
+}
+
+// Group creates a new inline-Mux with a fresh middleware stack. It's useful
+// for a group of handlers along the same routing path that use an additional
+// set of middlewares. See _examples/.
+func (mx *Mux) Group(fn func(r Router)) Router {
+	im := mx.With().(*Mux)
+	if fn != nil {
+		fn(im)
+	}
+	return im
+}
+
+// Route creates a new Mux with a fresh middleware stack and mounts it
+// along the `pattern` as a subrouter. Effectively, this is a short-hand
+// call to Mount. See _examples/.
+func (mx *Mux) Route(pattern string, fn func(r Router)) Router {
+	subRouter := NewRouter()
+	if fn != nil {
+		fn(subRouter)
+	}
+	mx.Mount(pattern, subRouter)
+	return subRouter
+}
+
+// Mount attaches another http.Handler or chi Router as a subrouter along a routing
+// path. It's very useful to split up a large API as many independent routers and
+// compose them as a single service using Mount. See _examples/.
+//
+// Note that Mount() simply sets a wildcard along the `pattern` that will continue
+// routing at the `handler`, which in most cases is another chi.Router. As a result,
+// if you define two Mount() routes on the exact same pattern the mount will panic.
+func (mx *Mux) Mount(pattern string, handler http.Handler) {
+	// Provide runtime safety for ensuring a pattern isn't mounted on an existing
+	// routing pattern.
+	if mx.tree.findPattern(pattern+"*") != nil || mx.tree.findPattern(pattern+"/*") != nil {
+		panic(fmt.Sprintf("chi: attempting to Mount() a handler on an existing path, '%s'", pattern))
+	}
+
+	// Assign sub-Router's with the parent not found & method not allowed handler if not specified.
+	subr, ok := handler.(*Mux)
+	if ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil {
+		subr.NotFound(mx.notFoundHandler)
+	}
+	if ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil {
+		subr.MethodNotAllowed(mx.methodNotAllowedHandler)
+	}
+
+	// Wrap the sub-router in a handlerFunc to scope the request path for routing.
+	subHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rctx := RouteContext(r.Context())
+		rctx.RoutePath = "/" + rctx.URLParams.Del("*")
+		handler.ServeHTTP(w, r)
+	})
+
+	if pattern == "" || pattern[len(pattern)-1] != '/' {
+		mx.handle(mALL|mSTUB, pattern, subHandler)
+		mx.handle(mALL|mSTUB, pattern+"/", mx.NotFoundHandler())
+		pattern += "/"
+	}
+
+	method := mALL
+	subroutes, _ := handler.(Routes)
+	if subroutes != nil {
+		method |= mSTUB
+	}
+	n := mx.handle(method, pattern+"*", subHandler)
+
+	if subroutes != nil {
+		n.subroutes = subroutes
+	}
+}
+
+func (mx *Mux) Middlewares() Middlewares {
+	return mx.middlewares
+}
+
+func (mx *Mux) Routes() []Route {
+	return mx.tree.routes()
+}
+
+// FileServer conveniently sets up a http.FileServer handler to serve
+// static files from a http.FileSystem.
+func (mx *Mux) FileServer(path string, root http.FileSystem) {
+	if strings.ContainsAny(path, ":*") {
+		panic("chi: FileServer does not permit URL parameters.")
+	}
+
+	fs := http.StripPrefix(path, http.FileServer(root))
+
+	if path != "/" && path[len(path)-1] != '/' {
+		mx.Get(path, http.RedirectHandler(path+"/", 301).ServeHTTP)
+		path += "/"
+	}
+	path += "*"
+
+	mx.Get(path, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fs.ServeHTTP(w, r)
+	}))
+}
+
+// NotFoundHandler returns the default Mux 404 responder whenever a route
+// cannot be found.
+func (mx *Mux) NotFoundHandler() http.HandlerFunc {
+	if mx.notFoundHandler != nil {
+		return mx.notFoundHandler
+	}
+	return http.NotFound
+}
+
+// MethodNotAllowedHandler returns the default Mux 405 responder whenever
+// a method cannot be resolved for a route.
+func (mx *Mux) MethodNotAllowedHandler() http.HandlerFunc {
+	if mx.methodNotAllowedHandler != nil {
+		return mx.methodNotAllowedHandler
+	}
+	return methodNotAllowedHandler
+}
+
+// buildRouteHandler builds the single mux handler that is a chain of the middleware
+// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this
+// point, no other middlewares can be registered on this Mux's stack. But you can still
+// compose additional middlewares via Group()'s or using a chained middleware handler.
+func (mx *Mux) buildRouteHandler() {
+	mx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP))
+}
+
+// handle registers a http.Handler in the routing tree for a particular http method
+// and routing pattern.
+func (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node {
+	if len(pattern) == 0 || pattern[0] != '/' {
+		panic(fmt.Sprintf("chi: routing pattern must begin with '/' in '%s'", pattern))
+	}
+
+	// Build the final routing handler for this Mux.
+	if !mx.inline && mx.handler == nil {
+		mx.buildRouteHandler()
+	}
+
+	// Build endpoint handler with inline middlewares for the route
+	var h http.Handler
+	if mx.inline {
+		mx.handler = http.HandlerFunc(mx.routeHTTP)
+		h = Chain(mx.middlewares...).Handler(handler)
+	} else {
+		h = handler
+	}
+
+	// Add the endpoint to the tree and return the node
+	return mx.tree.InsertRoute(method, pattern, h)
+}
+
+// routeHTTP routes a http.Request through the Mux routing tree to serve
+// the matching handler for a particular http method.
+func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Grab the route context object
+	rctx := r.Context().Value(RouteCtxKey).(*Context)
+
+	// The request routing path
+	routePath := rctx.RoutePath
+	if routePath == "" {
+		routePath = r.URL.Path
+	}
+
+	// Check if method is supported by chi
+	method, ok := methodMap[r.Method]
+	if !ok {
+		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
+		return
+	}
+
+	// Find the route
+	hs := mx.tree.FindRoute(rctx, routePath)
+	if hs == nil {
+		mx.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+
+	h, ok := hs[method]
+	if !ok {
+		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
+		return
+	}
+
+	// Serve it up
+	h.ServeHTTP(w, r)
+}
+
+// Recursively update data on child routers.
+func (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) {
+	for _, r := range mx.tree.routes() {
+		subMux, ok := r.SubRoutes.(*Mux)
+		if !ok {
+			continue
+		}
+		fn(subMux)
+	}
+}
+
+// methodNotAllowedHandler is a helper function to respond with a 405,
+// method not allowed.
+func methodNotAllowedHandler(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(405)
+	w.Write(nil)
+}
--- a/vendor/github.com/pressly/chi/tree.go
+++ b/vendor/github.com/pressly/chi/tree.go
@@ -0,0 +1,535 @@
+package chi
+
+// Radix tree implementation below is a based on the original work by
+// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
+// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
+
+import (
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type methodTyp int
+
+const (
+	mCONNECT methodTyp = 1 << iota
+	mDELETE
+	mGET
+	mHEAD
+	mOPTIONS
+	mPATCH
+	mPOST
+	mPUT
+	mTRACE
+	mSTUB
+
+	mALL methodTyp = mCONNECT | mDELETE | mGET | mHEAD | mOPTIONS |
+		mPATCH | mPOST | mPUT | mTRACE
+)
+
+var methodMap = map[string]methodTyp{
+	"CONNECT": mCONNECT,
+	"DELETE":  mDELETE,
+	"GET":     mGET,
+	"HEAD":    mHEAD,
+	"OPTIONS": mOPTIONS,
+	"PATCH":   mPATCH,
+	"POST":    mPOST,
+	"PUT":     mPUT,
+	"TRACE":   mTRACE,
+}
+
+type nodeTyp uint8
+
+const (
+	ntStatic   nodeTyp = iota // /home
+	ntRegexp                  // /:id([0-9]+) or #id^[0-9]+$
+	ntParam                   // /:user
+	ntCatchAll                // /api/v1/*
+)
+
+type node struct {
+	// node type
+	typ nodeTyp
+
+	// first byte of the prefix
+	label byte
+
+	// prefix is the common prefix we ignore
+	prefix string
+
+	// pattern is the computed path of prefixes
+	pattern string
+
+	// HTTP handler on the leaf node
+	handlers methodHandlers
+
+	// chi subroutes on the leaf node
+	subroutes Routes
+
+	// Child nodes should be stored in-order for iteration,
+	// in groups of the node type.
+	children [ntCatchAll + 1]nodes
+}
+
+func (n *node) FindRoute(rctx *Context, path string) methodHandlers {
+	// Reset the context routing pattern
+	rctx.RoutePattern = ""
+
+	// Find the routing handlers for the path
+	rn := n.findRoute(rctx, path)
+	if rn == nil {
+		return nil
+	}
+
+	// Record the routing pattern in the request lifecycle
+	if rn.pattern != "" {
+		rctx.RoutePattern = rn.pattern
+		rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.RoutePattern)
+	}
+
+	return rn.handlers
+}
+
+func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {
+	var parent *node
+	search := pattern
+
+	for {
+		// Handle key exhaustion
+		if len(search) == 0 {
+			// Insert or update the node's leaf handler
+			n.setHandler(method, handler)
+			n.pattern = pattern
+			return n
+		}
+
+		// Look for the edge
+		parent = n
+		n = n.getEdge(search[0])
+
+		// No edge, create one
+		if n == nil {
+			cn := &node{label: search[0], prefix: search, pattern: pattern}
+			cn.setHandler(method, handler)
+			parent.addChild(pattern, cn)
+			return cn
+		}
+
+		if n.typ > ntStatic {
+			// We found a wildcard node, meaning search path starts with
+			// a wild prefix. Trim off the wildcard search path and continue.
+			p := strings.Index(search, "/")
+			if p < 0 {
+				p = len(search)
+			}
+			search = search[p:]
+			continue
+		}
+
+		// Static nodes fall below here.
+		// Determine longest prefix of the search key on match.
+		commonPrefix := n.longestPrefix(search, n.prefix)
+		if commonPrefix == len(n.prefix) {
+			// the common prefix is as long as the current node's prefix we're attempting to insert.
+			// keep the search going.
+			search = search[commonPrefix:]
+			continue
+		}
+
+		// Split the node
+		child := &node{
+			typ:    ntStatic,
+			prefix: search[:commonPrefix],
+		}
+		parent.replaceChild(search[0], child)
+
+		// Restore the existing node
+		n.label = n.prefix[commonPrefix]
+		n.prefix = n.prefix[commonPrefix:]
+		child.addChild(pattern, n)
+
+		// If the new key is a subset, add to to this node
+		search = search[commonPrefix:]
+		if len(search) == 0 {
+			child.setHandler(method, handler)
+			child.pattern = pattern
+			return child
+		}
+
+		// Create a new edge for the node
+		subchild := &node{
+			typ:     ntStatic,
+			label:   search[0],
+			prefix:  search,
+			pattern: pattern,
+		}
+		subchild.setHandler(method, handler)
+		child.addChild(pattern, subchild)
+		return subchild
+	}
+}
+
+func (n *node) findPattern(pattern string) *node {
+	nn := n
+	for _, nds := range nn.children {
+		if len(nds) == 0 {
+			continue
+		}
+
+		n = nn.getEdge(pattern[0])
+		if n == nil {
+			continue
+		}
+
+		idx := n.longestPrefix(pattern, n.prefix)
+		xpattern := pattern[idx:]
+
+		if len(xpattern) == 0 {
+			return n
+		} else if xpattern[0] == '/' && idx < len(n.prefix) {
+			continue
+		}
+
+		return n.findPattern(xpattern)
+	}
+	return nil
+}
+
+func (n *node) isLeaf() bool {
+	return n.handlers != nil
+}
+
+func (n *node) addChild(pattern string, child *node) {
+	search := child.prefix
+
+	// Find any wildcard segments
+	p := strings.IndexAny(search, ":*")
+
+	// Determine new node type
+	ntyp := child.typ
+	if p >= 0 {
+		switch search[p] {
+		case ':':
+			ntyp = ntParam
+		case '*':
+			ntyp = ntCatchAll
+		}
+	}
+
+	if p == 0 {
+		// Path starts with a wildcard
+
+		handlers := child.handlers
+		child.typ = ntyp
+
+		if ntyp == ntCatchAll {
+			p = -1
+		} else {
+			p = strings.IndexByte(search, '/')
+		}
+		if p < 0 {
+			p = len(search)
+		}
+		child.prefix = search[:p]
+
+		if p != len(search) {
+			// add edge for the remaining part, split the end.
+			child.handlers = nil
+
+			search = search[p:]
+
+			child.addChild(pattern, &node{
+				typ:      ntStatic,
+				label:    search[0], // this will always start with /
+				prefix:   search,
+				pattern:  pattern,
+				handlers: handlers,
+			})
+		}
+
+	} else if p > 0 {
+		// Path has some wildcard
+
+		// starts with a static segment
+		handlers := child.handlers
+		child.typ = ntStatic
+		child.prefix = search[:p]
+		child.handlers = nil
+
+		// add the wild edge node
+		search = search[p:]
+
+		child.addChild(pattern, &node{
+			typ:      ntyp,
+			label:    search[0],
+			prefix:   search,
+			pattern:  pattern,
+			handlers: handlers,
+		})
+
+	} else {
+		// Path is all static
+		child.typ = ntyp
+
+	}
+
+	n.children[child.typ] = append(n.children[child.typ], child)
+	n.children[child.typ].Sort()
+}
+
+func (n *node) replaceChild(label byte, child *node) {
+	for i := 0; i < len(n.children[child.typ]); i++ {
+		if n.children[child.typ][i].label == label {
+			n.children[child.typ][i] = child
+			n.children[child.typ][i].label = label
+			return
+		}
+	}
+
+	panic("chi: replacing missing child")
+}
+
+func (n *node) getEdge(label byte) *node {
+	for _, nds := range n.children {
+		num := len(nds)
+		for i := 0; i < num; i++ {
+			if nds[i].label == label {
+				return nds[i]
+			}
+		}
+	}
+	return nil
+}
+
+func (n *node) findEdge(ntyp nodeTyp, label byte) *node {
+	nds := n.children[ntyp]
+	num := len(nds)
+	idx := 0
+
+	switch ntyp {
+	case ntStatic:
+		i, j := 0, num-1
+		for i <= j {
+			idx = i + (j-i)/2
+			if label > nds[idx].label {
+				i = idx + 1
+			} else if label < nds[idx].label {
+				j = idx - 1
+			} else {
+				i = num // breaks cond
+			}
+		}
+		if nds[idx].label != label {
+			return nil
+		}
+		return nds[idx]
+
+	default: // wild nodes
+		// TODO: right now we match them all.. but regexp should
+		// run through regexp matcher
+		return nds[idx]
+	}
+}
+
+// Recursive edge traversal by checking all nodeTyp groups along the way.
+// It's like searching through a multi-dimensional radix trie.
+func (n *node) findRoute(rctx *Context, path string) *node {
+	nn := n
+	search := path
+
+	for t, nds := range nn.children {
+		ntyp := nodeTyp(t)
+		if len(nds) == 0 {
+			continue
+		}
+
+		// search subset of edges of the index for a matching node
+		var label byte
+		if search != "" {
+			label = search[0]
+		}
+
+		xn := nn.findEdge(ntyp, label) // next node
+		if xn == nil {
+			continue
+		}
+
+		// Prepare next search path by trimming prefix from requested path
+		xsearch := search
+		if xn.typ > ntStatic {
+			p := -1
+			if xn.typ < ntCatchAll {
+				p = strings.IndexByte(xsearch, '/')
+			}
+			if p < 0 {
+				p = len(xsearch)
+			}
+
+			if xn.typ == ntCatchAll {
+				rctx.URLParams.Add("*", xsearch)
+			} else {
+				rctx.URLParams.Add(xn.prefix[1:], xsearch[:p])
+			}
+
+			xsearch = xsearch[p:]
+		} else if strings.HasPrefix(xsearch, xn.prefix) {
+			xsearch = xsearch[len(xn.prefix):]
+		} else {
+			continue // no match
+		}
+
+		// did we find it yet?
+		if len(xsearch) == 0 {
+			if xn.isLeaf() {
+				return xn
+			}
+		}
+
+		// recursively find the next node..
+		fin := xn.findRoute(rctx, xsearch)
+		if fin != nil {
+			// found a node, return it
+			return fin
+		}
+
+		// Did not found final handler, let's remove the param here if it was set
+		if xn.typ > ntStatic {
+			if xn.typ == ntCatchAll {
+				rctx.URLParams.Del("*")
+			} else {
+				rctx.URLParams.Del(xn.prefix[1:])
+			}
+		}
+	}
+
+	return nil
+}
+
+// longestPrefix finds the length of the shared prefix
+// of two strings
+func (n *node) longestPrefix(k1, k2 string) int {
+	max := len(k1)
+	if l := len(k2); l < max {
+		max = l
+	}
+	var i int
+	for i = 0; i < max; i++ {
+		if k1[i] != k2[i] {
+			break
+		}
+	}
+	return i
+}
+
+func (n *node) setHandler(method methodTyp, handler http.Handler) {
+	if n.handlers == nil {
+		n.handlers = make(methodHandlers, 0)
+	}
+	if method&mSTUB == mSTUB {
+		n.handlers[mSTUB] = handler
+	} else {
+		n.handlers[mSTUB] = nil
+	}
+	if method&mALL == mALL {
+		n.handlers[mALL] = handler
+		for _, m := range methodMap {
+			n.handlers[m] = handler
+		}
+	} else {
+		n.handlers[method] = handler
+	}
+}
+
+func (n *node) isEmpty() bool {
+	for _, nds := range n.children {
+		if len(nds) > 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func (n *node) routes() []Route {
+	rts := []Route{}
+
+	n.walkRoutes(n.prefix, n, func(pattern string, handlers methodHandlers, subroutes Routes) bool {
+		if handlers[mSTUB] != nil && subroutes == nil {
+			return false
+		}
+
+		if subroutes != nil && len(pattern) > 2 {
+			pattern = pattern[:len(pattern)-2]
+		}
+
+		var hs = make(map[string]http.Handler, 0)
+		if handlers[mALL] != nil {
+			hs["*"] = handlers[mALL]
+		}
+		for mt, h := range handlers {
+			if h == nil {
+				continue
+			}
+			m := methodTypString(mt)
+			if m == "" {
+				continue
+			}
+			hs[m] = h
+		}
+
+		rt := Route{pattern, hs, subroutes}
+		rts = append(rts, rt)
+		return false
+	})
+
+	return rts
+}
+
+func (n *node) walkRoutes(pattern string, nd *node, fn walkFn) bool {
+	pattern = nd.pattern
+
+	// Visit the leaf values if any
+	if (nd.handlers != nil || nd.subroutes != nil) && fn(pattern, nd.handlers, nd.subroutes) {
+		return true
+	}
+
+	// Recurse on the children
+	for _, nds := range nd.children {
+		for _, nd := range nds {
+			if n.walkRoutes(pattern, nd, fn) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func methodTypString(method methodTyp) string {
+	for s, t := range methodMap {
+		if method == t {
+			return s
+		}
+	}
+	return ""
+}
+
+type walkFn func(pattern string, handlers methodHandlers, subroutes Routes) bool
+
+// methodHandlers is a mapping of http method constants to handlers
+// for a given route.
+type methodHandlers map[methodTyp]http.Handler
+
+type nodes []*node
+
+// Sort the list of nodes by label
+func (ns nodes) Len() int           { return len(ns) }
+func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
+func (ns nodes) Swap(i, j int)      { ns[i], ns[j] = ns[j], ns[i] }
+func (ns nodes) Sort()              { sort.Sort(ns) }
+
+type Route struct {
+	Pattern   string
+	Handlers  map[string]http.Handler
+	SubRoutes Routes
+}