diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
new file mode 100644
index 0000000..fdf19dc
--- /dev/null
+++ b/Godeps/Godeps.json
@@ -0,0 +1,35 @@
+{
+ "ImportPath": "github.com/adnanh/webhook",
+ "GoVersion": "go1.9",
+ "GodepVersion": "v79",
+ "Deps": [
+ {
+ "ImportPath": "github.com/codegangsta/negroni",
+ "Comment": "v0.2.0-151-g5bc66cf",
+ "Rev": "5bc66cf1ad89af58511e07e108a31f219ed61012"
+ },
+ {
+ "ImportPath": "github.com/ghodss/yaml",
+ "Comment": "v1.0.0",
+ "Rev": "0ca9ea5df5451ffdf184b4428c902747c2c11cd7"
+ },
+ {
+ "ImportPath": "github.com/gorilla/mux",
+ "Comment": "v1.5.0-2-gbdd5a5a",
+ "Rev": "bdd5a5a1b0b489d297b73eb62b5f6328df198bfc"
+ },
+ {
+ "ImportPath": "golang.org/x/sys/unix",
+ "Rev": "ebfc5b4631820b793c9010c87fd8fef0f39eb082"
+ },
+ {
+ "ImportPath": "gopkg.in/fsnotify.v1",
+ "Comment": "v1.4.2",
+ "Rev": "629574ca2a5df945712d3079857300b5e4da0236"
+ },
+ {
+ "ImportPath": "gopkg.in/yaml.v2",
+ "Rev": "eb3733d160e74a9c7e442f435eb3bea458e1d19f"
+ }
+ ]
+}
diff --git a/Godeps/Readme b/Godeps/Readme
new file mode 100644
index 0000000..4cdaa53
--- /dev/null
+++ b/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
diff --git a/vendor/github.com/codegangsta/negroni/.gitignore b/vendor/github.com/codegangsta/negroni/.gitignore
new file mode 100644
index 0000000..3f2bc47
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/.gitignore
@@ -0,0 +1 @@
+/coverage.txt
diff --git a/vendor/github.com/codegangsta/negroni/.travis.yml b/vendor/github.com/codegangsta/negroni/.travis.yml
new file mode 100644
index 0000000..1810433
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/.travis.yml
@@ -0,0 +1,27 @@
+language: go
+
+sudo: false
+dist: trusty
+
+go:
+- 1.x
+- 1.2.x
+- 1.3.x
+- 1.4.x
+- 1.5.x
+- 1.6.x
+- 1.7.x
+- 1.8.x
+- master
+
+before_install:
+- find "${GOPATH%%:*}" -name '*.a' -delete
+- rm -rf "${GOPATH%%:*}/src/golang.org"
+- go get golang.org/x/tools/cover
+- go get golang.org/x/tools/cmd/cover
+
+script:
+- go test -race -coverprofile=coverage.txt -covermode=atomic
+
+after_success:
+- bash <(curl -s "https://codecov.io/bash")
diff --git a/vendor/github.com/codegangsta/negroni/CHANGELOG.md b/vendor/github.com/codegangsta/negroni/CHANGELOG.md
new file mode 100644
index 0000000..1b757d0
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/CHANGELOG.md
@@ -0,0 +1,37 @@
+# Change Log
+
+**ATTN**: This project uses [semantic versioning](http://semver.org/).
+
+## [Unreleased]
+### Added
+- `Recovery.ErrorHandlerFunc` for custom error handling during recovery
+- `With()` helper for building a new `Negroni` struct chaining handlers from
+ existing `Negroni` structs
+
+### Fixed
+- `Written()` correct returns `false` if no response header has been written
+
+### Changed
+- Set default status to `0` in the case that no handler writes status -- was
+ previously `200` (in 0.2.0, before that it was `0` so this reestablishes that
+ behavior)
+- Catch `panic`s thrown by callbacks provided to the `Recovery` handler
+
+## [0.2.0] - 2016-05-10
+### Added
+- Support for variadic handlers in `New()`
+- Added `Negroni.Handlers()` to fetch all of the handlers for a given chain
+- Allowed size in `Recovery` handler was bumped to 8k
+- `Negroni.UseFunc` to push another handler onto the chain
+
+### Changed
+- Set the status before calling `beforeFuncs` so the information is available to them
+- Set default status to `200` in the case that no handler writes status -- was previously `0`
+- Panic if `nil` handler is given to `negroni.Use`
+
+## 0.1.0 - 2013-07-22
+### Added
+- Initial implementation.
+
+[Unreleased]: https://github.com/urfave/negroni/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/urfave/negroni/compare/v0.1.0...v0.2.0
diff --git a/vendor/github.com/codegangsta/negroni/LICENSE b/vendor/github.com/codegangsta/negroni/LICENSE
new file mode 100644
index 0000000..08b5e20
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jeremy Saenz
+
+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.
diff --git a/vendor/github.com/codegangsta/negroni/README.md b/vendor/github.com/codegangsta/negroni/README.md
new file mode 100644
index 0000000..997acbd
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/README.md
@@ -0,0 +1,546 @@
+# Negroni
+[](http://godoc.org/github.com/urfave/negroni)
+[](https://travis-ci.org/urfave/negroni)
+[](https://codebeat.co/projects/github-com-urfave-negroni)
+[](https://codecov.io/gh/urfave/negroni)
+
+**Notice:** This is the library formerly known as
+`github.com/codegangsta/negroni` -- Github will automatically redirect requests
+to this repository, but we recommend updating your references for clarity.
+
+Negroni is an idiomatic approach to web middleware in Go. It is tiny,
+non-intrusive, and encourages use of `net/http` Handlers.
+
+If you like the idea of [Martini](https://github.com/go-martini/martini), but
+you think it contains too much magic, then Negroni is a great fit.
+
+Language Translations:
+* [Deutsch (de_DE)](translations/README_de_de.md)
+* [Português Brasileiro (pt_BR)](translations/README_pt_br.md)
+* [简体中文 (zh_cn)](translations/README_zh_cn.md)
+* [繁體中文 (zh_tw)](translations/README_zh_tw.md)
+* [日本語 (ja_JP)](translations/README_ja_JP.md)
+* [Français (fr_FR)](translations/README_fr_FR.md)
+
+## Getting Started
+
+After installing Go and setting up your
+[GOPATH](http://golang.org/doc/code.html#GOPATH), create your first `.go` file.
+We'll call it `server.go`.
+
+
+``` go
+package main
+
+import (
+ "fmt"
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ fmt.Fprintf(w, "Welcome to the home page!")
+ })
+
+ n := negroni.Classic() // Includes some default middlewares
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3000", n)
+}
+```
+
+Then install the Negroni package (**NOTE**: >= **go 1.1** is required):
+
+```
+go get github.com/urfave/negroni
+```
+
+Then run your server:
+
+```
+go run server.go
+```
+
+You will now have a Go `net/http` webserver running on `localhost:3000`.
+
+### Packaging
+
+If you are on Debian, `negroni` is also available as [a
+package](https://packages.debian.org/sid/golang-github-urfave-negroni-dev) that
+you can install via `apt install golang-github-urfave-negroni-dev` (at the time
+of writing, it is in the `sid` repositories).
+
+## Is Negroni a Framework?
+
+Negroni is **not** a framework. It is a middleware-focused library that is
+designed to work directly with `net/http`.
+
+## Routing?
+
+Negroni is BYOR (Bring your own Router). The Go community already has a number
+of great http routers available, and Negroni tries to play well with all of them
+by fully supporting `net/http`. For instance, integrating with [Gorilla Mux]
+looks like so:
+
+``` go
+router := mux.NewRouter()
+router.HandleFunc("/", HomeHandler)
+
+n := negroni.New(Middleware1, Middleware2)
+// Or use a middleware with the Use() function
+n.Use(Middleware3)
+// router goes last
+n.UseHandler(router)
+
+http.ListenAndServe(":3001", n)
+```
+
+## `negroni.Classic()`
+
+`negroni.Classic()` provides some default middleware that is useful for most
+applications:
+
+* [`negroni.Recovery`](#recovery) - Panic Recovery Middleware.
+* [`negroni.Logger`](#logger) - Request/Response Logger Middleware.
+* [`negroni.Static`](#static) - Static File serving under the "public"
+ directory.
+
+This makes it really easy to get started with some useful features from Negroni.
+
+## Handlers
+
+Negroni provides a bidirectional middleware flow. This is done through the
+`negroni.Handler` interface:
+
+``` go
+type Handler interface {
+ ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
+}
+```
+
+If a middleware hasn't already written to the `ResponseWriter`, it should call
+the next `http.HandlerFunc` in the chain to yield to the next middleware
+handler. This can be used for great good:
+
+``` go
+func MyMiddleware(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ // do some stuff before
+ next(rw, r)
+ // do some stuff after
+}
+```
+
+And you can map it to the handler chain with the `Use` function:
+
+``` go
+n := negroni.New()
+n.Use(negroni.HandlerFunc(MyMiddleware))
+```
+
+You can also map plain old `http.Handler`s:
+
+``` go
+n := negroni.New()
+
+mux := http.NewServeMux()
+// map your routes
+
+n.UseHandler(mux)
+
+http.ListenAndServe(":3000", n)
+```
+
+## `With()`
+
+Negroni has a convenience function called `With`. `With` takes one or more
+`Handler` instances and returns a new `Negroni` with the combination of the
+receiver's handlers and the new handlers.
+
+```go
+// middleware we want to reuse
+common := negroni.New()
+common.Use(MyMiddleware1)
+common.Use(MyMiddleware2)
+
+// `specific` is a new negroni with the handlers from `common` combined with the
+// the handlers passed in
+specific := common.With(
+ SpecificMiddleware1,
+ SpecificMiddleware2
+)
+```
+
+## `Run()`
+
+Negroni has a convenience function called `Run`. `Run` takes an addr string
+identical to [`http.ListenAndServe`](https://godoc.org/net/http#ListenAndServe).
+
+
+``` go
+package main
+
+import (
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ n := negroni.Classic()
+ n.Run(":8080")
+}
+```
+If no address is provided, the `PORT` environment variable is used instead.
+If the `PORT` environment variable is not defined, the default address will be used.
+See [Run](https://godoc.org/github.com/urfave/negroni#Negroni.Run) for a complete description.
+
+In general, you will want to use `net/http` methods and pass `negroni` as a
+`Handler`, as this is more flexible, e.g.:
+
+
+``` go
+package main
+
+import (
+ "fmt"
+ "log"
+ "net/http"
+ "time"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ fmt.Fprintf(w, "Welcome to the home page!")
+ })
+
+ n := negroni.Classic() // Includes some default middlewares
+ n.UseHandler(mux)
+
+ s := &http.Server{
+ Addr: ":8080",
+ Handler: n,
+ ReadTimeout: 10 * time.Second,
+ WriteTimeout: 10 * time.Second,
+ MaxHeaderBytes: 1 << 20,
+ }
+ log.Fatal(s.ListenAndServe())
+}
+```
+
+## Route Specific Middleware
+
+If you have a route group of routes that need specific middleware to be
+executed, you can simply create a new Negroni instance and use it as your route
+handler.
+
+``` go
+router := mux.NewRouter()
+adminRoutes := mux.NewRouter()
+// add admin routes here
+
+// Create a new negroni for the admin middleware
+router.PathPrefix("/admin").Handler(negroni.New(
+ Middleware1,
+ Middleware2,
+ negroni.Wrap(adminRoutes),
+))
+```
+
+If you are using [Gorilla Mux], here is an example using a subrouter:
+
+``` go
+router := mux.NewRouter()
+subRouter := mux.NewRouter().PathPrefix("/subpath").Subrouter().StrictSlash(true)
+subRouter.HandleFunc("/", someSubpathHandler) // "/subpath/"
+subRouter.HandleFunc("/:id", someSubpathHandler) // "/subpath/:id"
+
+// "/subpath" is necessary to ensure the subRouter and main router linkup
+router.PathPrefix("/subpath").Handler(negroni.New(
+ Middleware1,
+ Middleware2,
+ negroni.Wrap(subRouter),
+))
+```
+
+`With()` can be used to eliminate redundancy for middlewares shared across
+routes.
+
+``` go
+router := mux.NewRouter()
+apiRoutes := mux.NewRouter()
+// add api routes here
+webRoutes := mux.NewRouter()
+// add web routes here
+
+// create common middleware to be shared across routes
+common := negroni.New(
+ Middleware1,
+ Middleware2,
+)
+
+// create a new negroni for the api middleware
+// using the common middleware as a base
+router.PathPrefix("/api").Handler(common.With(
+ APIMiddleware1,
+ negroni.Wrap(apiRoutes),
+))
+// create a new negroni for the web middleware
+// using the common middleware as a base
+router.PathPrefix("/web").Handler(common.With(
+ WebMiddleware1,
+ negroni.Wrap(webRoutes),
+))
+```
+
+## Bundled Middleware
+
+### Static
+
+This middleware will serve files on the filesystem. If the files do not exist,
+it proxies the request to the next middleware. If you want the requests for
+non-existent files to return a `404 File Not Found` to the user you should look
+at using [http.FileServer](https://golang.org/pkg/net/http/#FileServer) as
+a handler.
+
+Example:
+
+
+``` go
+package main
+
+import (
+ "fmt"
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ fmt.Fprintf(w, "Welcome to the home page!")
+ })
+
+ // Example of using a http.FileServer if you want "server-like" rather than "middleware" behavior
+ // mux.Handle("/public", http.FileServer(http.Dir("/home/public")))
+
+ n := negroni.New()
+ n.Use(negroni.NewStatic(http.Dir("/tmp")))
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3002", n)
+}
+```
+
+Will serve files from the `/tmp` directory first, but proxy calls to the next
+handler if the request does not match a file on the filesystem.
+
+### Recovery
+
+This middleware catches `panic`s and responds with a `500` response code. If
+any other middleware has written a response code or body, this middleware will
+fail to properly send a 500 to the client, as the client has already received
+the HTTP response code. Additionally, an `ErrorHandlerFunc` can be attached
+to report 500's to an error reporting service such as Sentry or Airbrake.
+
+Example:
+
+
+``` go
+package main
+
+import (
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ panic("oh no")
+ })
+
+ n := negroni.New()
+ n.Use(negroni.NewRecovery())
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3003", n)
+}
+```
+
+Will return a `500 Internal Server Error` to each request. It will also log the
+stack traces as well as print the stack trace to the requester if `PrintStack`
+is set to `true` (the default).
+
+Example with error handler:
+
+``` go
+package main
+
+import (
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ panic("oh no")
+ })
+
+ n := negroni.New()
+ recovery := negroni.NewRecovery()
+ recovery.ErrorHandlerFunc = reportToSentry
+ n.Use(recovery)
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3003", n)
+}
+
+func reportToSentry(error interface{}) {
+ // write code here to report error to Sentry
+}
+```
+
+The middleware simply output the informations on STDOUT by default.
+You can customize the output process by using the `SetFormatter()` function.
+
+You can use also the `HTMLPanicFormatter` to display a pretty HTML when a crash occurs.
+
+
+``` go
+package main
+
+import (
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ panic("oh no")
+ })
+
+ n := negroni.New()
+ recovery := negroni.NewRecovery()
+ recovery.Formatter = &negroni.HTMLPanicFormatter{}
+ n.Use(recovery)
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3003", n)
+}
+```
+
+## Logger
+
+This middleware logs each incoming request and response.
+
+Example:
+
+
+``` go
+package main
+
+import (
+ "fmt"
+ "net/http"
+
+ "github.com/urfave/negroni"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+ fmt.Fprintf(w, "Welcome to the home page!")
+ })
+
+ n := negroni.New()
+ n.Use(negroni.NewLogger())
+ n.UseHandler(mux)
+
+ http.ListenAndServe(":3004", n)
+}
+```
+
+Will print a log similar to:
+
+```
+[negroni] 2017-10-04T14:56:25+02:00 | 200 | 378µs | localhost:3004 | GET /
+```
+
+on each request.
+
+You can also set your own log format by calling the `SetFormat` function. The format is a template string with fields as mentioned in the `LoggerEntry` struct. So, as an example -
+
+```go
+l.SetFormat("[{{.Status}} {{.Duration}}] - {{.Request.UserAgent}}")
+```
+
+will show something like - `[200 18.263µs] - Go-User-Agent/1.1 `
+
+## Third Party Middleware
+
+Here is a current list of Negroni compatible middlware. Feel free to put up a PR
+linking your middleware if you have built one:
+
+| Middleware | Author | Description |
+| -----------|--------|-------------|
+| [authz](https://github.com/casbin/negroni-authz) | [Yang Luo](https://github.com/hsluoyz) | ACL, RBAC, ABAC Authorization middlware based on [Casbin](https://github.com/casbin/casbin) |
+| [binding](https://github.com/mholt/binding) | [Matt Holt](https://github.com/mholt) | Data binding from HTTP requests into structs |
+| [cloudwatch](https://github.com/cvillecsteele/negroni-cloudwatch) | [Colin Steele](https://github.com/cvillecsteele) | AWS cloudwatch metrics middleware |
+| [cors](https://github.com/rs/cors) | [Olivier Poitrey](https://github.com/rs) | [Cross Origin Resource Sharing](http://www.w3.org/TR/cors/) (CORS) support |
+| [csp](https://github.com/awakenetworks/csp) | [Awake Networks](https://github.com/awakenetworks) | [Content Security Policy](https://www.w3.org/TR/CSP2/) (CSP) support |
+| [delay](https://github.com/jeffbmartinez/delay) | [Jeff Martinez](https://github.com/jeffbmartinez) | Add delays/latency to endpoints. Useful when testing effects of high latency |
+| [New Relic Go Agent](https://github.com/yadvendar/negroni-newrelic-go-agent) | [Yadvendar Champawat](https://github.com/yadvendar) | Official [New Relic Go Agent](https://github.com/newrelic/go-agent) (currently in beta) |
+| [gorelic](https://github.com/jingweno/negroni-gorelic) | [Jingwen Owen Ou](https://github.com/jingweno) | New Relic agent for Go runtime |
+| [Graceful](https://github.com/tylerb/graceful) | [Tyler Bunnell](https://github.com/tylerb) | Graceful HTTP Shutdown |
+| [gzip](https://github.com/phyber/negroni-gzip) | [phyber](https://github.com/phyber) | GZIP response compression |
+| [JWT Middleware](https://github.com/auth0/go-jwt-middleware) | [Auth0](https://github.com/auth0) | Middleware checks for a JWT on the `Authorization` header on incoming requests and decodes it|
+| [logrus](https://github.com/meatballhat/negroni-logrus) | [Dan Buch](https://github.com/meatballhat) | Logrus-based logger |
+| [oauth2](https://github.com/goincremental/negroni-oauth2) | [David Bochenski](https://github.com/bochenski) | oAuth2 middleware |
+| [onthefly](https://github.com/xyproto/onthefly) | [Alexander Rødseth](https://github.com/xyproto) | Generate TinySVG, HTML and CSS on the fly |
+| [permissions2](https://github.com/xyproto/permissions2) | [Alexander Rødseth](https://github.com/xyproto) | Cookies, users and permissions |
+| [prometheus](https://github.com/zbindenren/negroni-prometheus) | [Rene Zbinden](https://github.com/zbindenren) | Easily create metrics endpoint for the [prometheus](http://prometheus.io) instrumentation tool |
+| [render](https://github.com/unrolled/render) | [Cory Jacobsen](https://github.com/unrolled) | Render JSON, XML and HTML templates |
+| [RestGate](https://github.com/pjebs/restgate) | [Prasanga Siripala](https://github.com/pjebs) | Secure authentication for REST API endpoints |
+| [secure](https://github.com/unrolled/secure) | [Cory Jacobsen](https://github.com/unrolled) | Middleware that implements a few quick security wins |
+| [sessions](https://github.com/goincremental/negroni-sessions) | [David Bochenski](https://github.com/bochenski) | Session Management |
+| [stats](https://github.com/thoas/stats) | [Florent Messa](https://github.com/thoas) | Store information about your web application (response time, etc.) |
+| [VanGoH](https://github.com/auroratechnologies/vangoh) | [Taylor Wrobel](https://github.com/twrobel3) | Configurable [AWS-Style](http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html) HMAC authentication middleware |
+| [xrequestid](https://github.com/pilu/xrequestid) | [Andrea Franz](https://github.com/pilu) | Middleware that assigns a random X-Request-Id header to each request |
+| [mgo session](https://github.com/joeljames/nigroni-mgo-session) | [Joel James](https://github.com/joeljames) | Middleware that handles creating and closing mgo sessions per request |
+| [digits](https://github.com/bamarni/digits) | [Bilal Amarni](https://github.com/bamarni) | Middleware that handles [Twitter Digits](https://get.digits.com/) authentication |
+
+## Examples
+
+[Alexander Rødseth](https://github.com/xyproto) created
+[mooseware](https://github.com/xyproto/mooseware), a skeleton for writing a
+Negroni middleware handler.
+
+[Prasanga Siripala](https://github.com/pjebs) created an effective skeleton structure for web-based Go/Negroni projects: [Go-Skeleton](https://github.com/pjebs/go-skeleton)
+
+## Live code reload?
+
+[gin](https://github.com/codegangsta/gin) and
+[fresh](https://github.com/pilu/fresh) both live reload negroni apps.
+
+## Essential Reading for Beginners of Go & Negroni
+
+* [Using a Context to pass information from middleware to end handler](http://elithrar.github.io/article/map-string-interface/)
+* [Understanding middleware](https://mattstauffer.co/blog/laravel-5.0-middleware-filter-style)
+
+## About
+
+Negroni is obsessively designed by none other than the [Code
+Gangsta](https://codegangsta.io/)
+
+[Gorilla Mux]: https://github.com/gorilla/mux
+[`http.FileSystem`]: https://godoc.org/net/http#FileSystem
diff --git a/vendor/github.com/codegangsta/negroni/doc.go b/vendor/github.com/codegangsta/negroni/doc.go
new file mode 100644
index 0000000..add1ed9
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/doc.go
@@ -0,0 +1,25 @@
+// Package negroni is an idiomatic approach to web middleware in Go. It is tiny, non-intrusive, and encourages use of net/http Handlers.
+//
+// If you like the idea of Martini, but you think it contains too much magic, then Negroni is a great fit.
+//
+// For a full guide visit http://github.com/urfave/negroni
+//
+// package main
+//
+// import (
+// "github.com/urfave/negroni"
+// "net/http"
+// "fmt"
+// )
+//
+// func main() {
+// mux := http.NewServeMux()
+// mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+// fmt.Fprintf(w, "Welcome to the home page!")
+// })
+//
+// n := negroni.Classic()
+// n.UseHandler(mux)
+// n.Run(":3000")
+// }
+package negroni
diff --git a/vendor/github.com/codegangsta/negroni/logger.go b/vendor/github.com/codegangsta/negroni/logger.go
new file mode 100644
index 0000000..5bf7731
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/logger.go
@@ -0,0 +1,82 @@
+package negroni
+
+import (
+ "bytes"
+
+ "log"
+ "net/http"
+ "os"
+ "text/template"
+ "time"
+)
+
+// LoggerEntry is the structure
+// passed to the template.
+type LoggerEntry struct {
+ StartTime string
+ Status int
+ Duration time.Duration
+ Hostname string
+ Method string
+ Path string
+ Request *http.Request
+}
+
+// LoggerDefaultFormat is the format
+// logged used by the default Logger instance.
+var LoggerDefaultFormat = "{{.StartTime}} | {{.Status}} | \t {{.Duration}} | {{.Hostname}} | {{.Method}} {{.Path}} \n"
+
+// LoggerDefaultDateFormat is the
+// format used for date by the
+// default Logger instance.
+var LoggerDefaultDateFormat = time.RFC3339
+
+// ALogger interface
+type ALogger interface {
+ Println(v ...interface{})
+ Printf(format string, v ...interface{})
+}
+
+// Logger is a middleware handler that logs the request as it goes in and the response as it goes out.
+type Logger struct {
+ // ALogger implements just enough log.Logger interface to be compatible with other implementations
+ ALogger
+ dateFormat string
+ template *template.Template
+}
+
+// NewLogger returns a new Logger instance
+func NewLogger() *Logger {
+ logger := &Logger{ALogger: log.New(os.Stdout, "[negroni] ", 0), dateFormat: LoggerDefaultDateFormat}
+ logger.SetFormat(LoggerDefaultFormat)
+ return logger
+}
+
+func (l *Logger) SetFormat(format string) {
+ l.template = template.Must(template.New("negroni_parser").Parse(format))
+}
+
+func (l *Logger) SetDateFormat(format string) {
+ l.dateFormat = format
+}
+
+func (l *Logger) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ start := time.Now()
+
+ next(rw, r)
+
+ res := rw.(ResponseWriter)
+ log := LoggerEntry{
+ StartTime: start.Format(l.dateFormat),
+ Status: res.Status(),
+ Duration: time.Since(start),
+ Hostname: r.Host,
+ Method: r.Method,
+ Path: r.URL.Path,
+ Request: r,
+ }
+
+ buff := &bytes.Buffer{}
+ l.template.Execute(buff, log)
+ l.Printf(buff.String())
+}
diff --git a/vendor/github.com/codegangsta/negroni/negroni.go b/vendor/github.com/codegangsta/negroni/negroni.go
new file mode 100644
index 0000000..d1d7782
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/negroni.go
@@ -0,0 +1,169 @@
+package negroni
+
+import (
+ "log"
+ "net/http"
+ "os"
+)
+
+const (
+ // DefaultAddress is used if no other is specified.
+ DefaultAddress = ":8080"
+)
+
+// Handler handler is an interface that objects can implement to be registered to serve as middleware
+// in the Negroni middleware stack.
+// ServeHTTP should yield to the next middleware in the chain by invoking the next http.HandlerFunc
+// passed in.
+//
+// If the Handler writes to the ResponseWriter, the next http.HandlerFunc should not be invoked.
+type Handler interface {
+ ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
+}
+
+// HandlerFunc is an adapter to allow the use of ordinary functions as Negroni handlers.
+// If f is a function with the appropriate signature, HandlerFunc(f) is a Handler object that calls f.
+type HandlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
+
+func (h HandlerFunc) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ h(rw, r, next)
+}
+
+type middleware struct {
+ handler Handler
+ next *middleware
+}
+
+func (m middleware) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ m.handler.ServeHTTP(rw, r, m.next.ServeHTTP)
+}
+
+// Wrap converts a http.Handler into a negroni.Handler so it can be used as a Negroni
+// middleware. The next http.HandlerFunc is automatically called after the Handler
+// is executed.
+func Wrap(handler http.Handler) Handler {
+ return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ handler.ServeHTTP(rw, r)
+ next(rw, r)
+ })
+}
+
+// WrapFunc converts a http.HandlerFunc into a negroni.Handler so it can be used as a Negroni
+// middleware. The next http.HandlerFunc is automatically called after the Handler
+// is executed.
+func WrapFunc(handlerFunc http.HandlerFunc) Handler {
+ return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ handlerFunc(rw, r)
+ next(rw, r)
+ })
+}
+
+// Negroni is a stack of Middleware Handlers that can be invoked as an http.Handler.
+// Negroni middleware is evaluated in the order that they are added to the stack using
+// the Use and UseHandler methods.
+type Negroni struct {
+ middleware middleware
+ handlers []Handler
+}
+
+// New returns a new Negroni instance with no middleware preconfigured.
+func New(handlers ...Handler) *Negroni {
+ return &Negroni{
+ handlers: handlers,
+ middleware: build(handlers),
+ }
+}
+
+// With returns a new Negroni instance that is a combination of the negroni
+// receiver's handlers and the provided handlers.
+func (n *Negroni) With(handlers ...Handler) *Negroni {
+ return New(
+ append(n.handlers, handlers...)...,
+ )
+}
+
+// Classic returns a new Negroni instance with the default middleware already
+// in the stack.
+//
+// Recovery - Panic Recovery Middleware
+// Logger - Request/Response Logging
+// Static - Static File Serving
+func Classic() *Negroni {
+ return New(NewRecovery(), NewLogger(), NewStatic(http.Dir("public")))
+}
+
+func (n *Negroni) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ n.middleware.ServeHTTP(NewResponseWriter(rw), r)
+}
+
+// Use adds a Handler onto the middleware stack. Handlers are invoked in the order they are added to a Negroni.
+func (n *Negroni) Use(handler Handler) {
+ if handler == nil {
+ panic("handler cannot be nil")
+ }
+
+ n.handlers = append(n.handlers, handler)
+ n.middleware = build(n.handlers)
+}
+
+// UseFunc adds a Negroni-style handler function onto the middleware stack.
+func (n *Negroni) UseFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)) {
+ n.Use(HandlerFunc(handlerFunc))
+}
+
+// UseHandler adds a http.Handler onto the middleware stack. Handlers are invoked in the order they are added to a Negroni.
+func (n *Negroni) UseHandler(handler http.Handler) {
+ n.Use(Wrap(handler))
+}
+
+// UseHandlerFunc adds a http.HandlerFunc-style handler function onto the middleware stack.
+func (n *Negroni) UseHandlerFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request)) {
+ n.UseHandler(http.HandlerFunc(handlerFunc))
+}
+
+// Run is a convenience function that runs the negroni stack as an HTTP
+// server. The addr string, if provided, takes the same format as http.ListenAndServe.
+// If no address is provided but the PORT environment variable is set, the PORT value is used.
+// If neither is provided, the address' value will equal the DefaultAddress constant.
+func (n *Negroni) Run(addr ...string) {
+ l := log.New(os.Stdout, "[negroni] ", 0)
+ finalAddr := detectAddress(addr...)
+ l.Printf("listening on %s", finalAddr)
+ l.Fatal(http.ListenAndServe(finalAddr, n))
+}
+
+func detectAddress(addr ...string) string {
+ if len(addr) > 0 {
+ return addr[0]
+ }
+ if port := os.Getenv("PORT"); port != "" {
+ return ":" + port
+ }
+ return DefaultAddress
+}
+
+// Returns a list of all the handlers in the current Negroni middleware chain.
+func (n *Negroni) Handlers() []Handler {
+ return n.handlers
+}
+
+func build(handlers []Handler) middleware {
+ var next middleware
+
+ if len(handlers) == 0 {
+ return voidMiddleware()
+ } else if len(handlers) > 1 {
+ next = build(handlers[1:])
+ } else {
+ next = voidMiddleware()
+ }
+
+ return middleware{handlers[0], &next}
+}
+
+func voidMiddleware() middleware {
+ return middleware{
+ HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {}),
+ &middleware{},
+ }
+}
diff --git a/vendor/github.com/codegangsta/negroni/recovery.go b/vendor/github.com/codegangsta/negroni/recovery.go
new file mode 100644
index 0000000..1a6570e
--- /dev/null
+++ b/vendor/github.com/codegangsta/negroni/recovery.go
@@ -0,0 +1,179 @@
+package negroni
+
+import (
+ "fmt"
+ "log"
+ "net/http"
+ "os"
+ "runtime"
+ "runtime/debug"
+ "text/template"
+)
+
+const (
+ panicText = "PANIC: %s\n%s"
+ panicHTML = `
+PANIC: {{.RecoveredPanic}}
+
+
+Negroni - PANIC
+
+
+
{{.RequestDescription}}
+ Runtime error: {{.RecoveredPanic}}
+
+
+{{ if .Stack }}
+
+
Runtime Stack
+
{{.StackAsString}}
+