Skip to content

GitLab

Commit 45ce8b86 authored by ale's avatar ale
Browse files
Options

Merge branch 'renovate/github.com-gorilla-mux-1.x' into 'master' 

Update module gorilla/mux to v1.8.0

See merge request !5
parents 13e3d50f 182176b1
Pipeline #11538 passed with stages
          in 1 minute and 14 seconds
          Hide whitespace changes
          Inline Side-by-side
          Showing with 446 additions and 294 deletions
          go.mod
          View file @ 45ce8b86
          ......@@ -9,7 +9,7 @@ require (
          github.com/golang/protobuf v1.4.3 // indirect
          github.com/golang/snappy v0.0.2 // indirect
          github.com/google/subcommands v1.2.0
          github.com/gorilla/mux v1.6.3-0.20181030152528-3d80bc801bb0
          github.com/gorilla/mux v1.8.0
          github.com/meskio/epubgo v0.0.0-20160213181628-90dd5d78197f
          github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
          github.com/syndtr/goleveldb v1.0.1-0.20190625010220-02440ea7a285
          ......
          vendor/github.com/gorilla/mux/.travis.yml deleted 100644 → 0
          View file @ 13e3d50f
          language: go
          sudo: false
          matrix:
          include:
          - go: 1.7.x
          - go: 1.8.x
          - go: 1.9.x
          - go: 1.10.x
          - go: 1.11.x
          - go: 1.x
          env: LATEST=true
          - go: tip
          allow_failures:
          - go: tip
          install:
          - # Skip
          script:
          - go get -t -v ./...
          - diff -u <(echo -n) <(gofmt -d .)
          - if [[ "$LATEST" = true ]]; then go tool vet .; fi
          - go test -v -race ./...
          vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md deleted 100644 → 0
          View file @ 13e3d50f
          **What version of Go are you running?** (Paste the output of `go version`)
          **What version of gorilla/mux are you at?** (Paste the output of `git rev-parse HEAD` inside `$GOPATH/src/github.com/gorilla/mux`)
          **Describe your problem** (and what you have tried so far)
          **Paste a minimal, runnable, reproduction of your issue below** (use backticks to format it)
          vendor/github.com/gorilla/mux/README.md
          View file @ 45ce8b86
          # gorilla/mux
          [![GoDoc](https://godoc.org/github.com/gorilla/mux?status.svg)](https://godoc.org/github.com/gorilla/mux)
          [![Build Status](https://travis-ci.org/gorilla/mux.svg?branch=master)](https://travis-ci.org/gorilla/mux)
          [![CircleCI](https://circleci.com/gh/gorilla/mux.svg?style=svg)](https://circleci.com/gh/gorilla/mux)
          [![Sourcegraph](https://sourcegraph.com/github.com/gorilla/mux/-/badge.svg)](https://sourcegraph.com/github.com/gorilla/mux?badge)
          ![Gorilla Logo](http://www.gorillatoolkit.org/static/images/gorilla-icon-64.png)
          ![Gorilla Logo](https://cloud-cdn.questionable.services/gorilla-icon-64.png)
          https://www.gorillatoolkit.org/pkg/mux
          ......@@ -25,10 +25,12 @@ The name mux stands for "HTTP request multiplexer". Like the standard `http.Serv
          * [Examples](#examples)
          * [Matching Routes](#matching-routes)
          * [Static Files](#static-files)
          * [Serving Single Page Applications](#serving-single-page-applications) (e.g. React, Vue, Ember.js, etc.)
          * [Registered URLs](#registered-urls)
          * [Walking Routes](#walking-routes)
          * [Graceful Shutdown](#graceful-shutdown)
          * [Middleware](#middleware)
          * [Handling CORS Requests](#handling-cors-requests)
          * [Testing Handlers](#testing-handlers)
          * [Full Example](#full-example)
          ......@@ -88,7 +90,7 @@ r := mux.NewRouter()
          // Only matches if domain is "www.example.com".
          r.Host("www.example.com")
          // Matches a dynamic subdomain.
          r.Host("{subdomain:[a-z]+}.domain.com")
          r.Host("{subdomain:[a-z]+}.example.com")
          ```
          There are several other matchers that can be added. To match path prefixes:
          ......@@ -210,6 +212,93 @@ func main() {
          }
          ```
          ### Serving Single Page Applications
          Most of the time it makes sense to serve your SPA on a separate web server from your API,
          but sometimes it's desirable to serve them both from one place. It's possible to write a simple
          handler for serving your SPA (for use with React Router's [BrowserRouter](https://reacttraining.com/react-router/web/api/BrowserRouter) for example), and leverage
          mux's powerful routing for your API endpoints.
          ```go
          package main
          import (
          "encoding/json"
          "log"
          "net/http"
          "os"
          "path/filepath"
          "time"
          "github.com/gorilla/mux"
          )
          // spaHandler implements the http.Handler interface, so we can use it
          // to respond to HTTP requests. The path to the static directory and
          // path to the index file within that static directory are used to
          // serve the SPA in the given static directory.
          type spaHandler struct {
          staticPath string
          indexPath string
          }
          // ServeHTTP inspects the URL path to locate a file within the static dir
          // on the SPA handler. If a file is found, it will be served. If not, the
          // file located at the index path on the SPA handler will be served. This
          // is suitable behavior for serving an SPA (single page application).
          func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
          // get the absolute path to prevent directory traversal
          path, err := filepath.Abs(r.URL.Path)
          if err != nil {
          // if we failed to get the absolute path respond with a 400 bad request
          // and stop
          http.Error(w, err.Error(), http.StatusBadRequest)
          return
          }
          // prepend the path with the path to the static directory
          path = filepath.Join(h.staticPath, path)
          // check whether a file exists at the given path
          _, err = os.Stat(path)
          if os.IsNotExist(err) {
          // file does not exist, serve index.html
          http.ServeFile(w, r, filepath.Join(h.staticPath, h.indexPath))
          return
          } else if err != nil {
          // if we got an error (that wasn't that the file doesn't exist) stating the
          // file, return a 500 internal server error and stop
          http.Error(w, err.Error(), http.StatusInternalServerError)
          return
          }
          // otherwise, use http.FileServer to serve the static dir
          http.FileServer(http.Dir(h.staticPath)).ServeHTTP(w, r)
          }
          func main() {
          router := mux.NewRouter()
          router.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
          // an example API handler
          json.NewEncoder(w).Encode(map[string]bool{"ok": true})
          })
          spa := spaHandler{staticPath: "build", indexPath: "index.html"}
          router.PathPrefix("/").Handler(spa)
          srv := &http.Server{
          Handler: router,
          Addr: "127.0.0.1:8000",
          // Good practice: enforce timeouts for servers you create!
          WriteTimeout: 15 * time.Second,
          ReadTimeout: 15 * time.Second,
          }
          log.Fatal(srv.ListenAndServe())
          }
          ```
          ### Registered URLs
          Now let's see how to build registered URLs.
          ......@@ -238,13 +327,13 @@ This also works for host and query value variables:
          ```go
          r := mux.NewRouter()
          r.Host("{subdomain}.domain.com").
          r.Host("{subdomain}.example.com").
          Path("/articles/{category}/{id:[0-9]+}").
          Queries("filter", "{filter}").
          HandlerFunc(ArticleHandler).
          Name("article")
          // url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla"
          // url.String() will be "http://news.example.com/articles/technology/42?filter=gorilla"
          url, err := r.Get("article").URL("subdomain", "news",
          "category", "technology",
          "id", "42",
          ......@@ -264,7 +353,7 @@ r.HeadersRegexp("Content-Type", "application/(text|json)")
          There's also a way to build only the URL host or path for a route: use the methods `URLHost()` or `URLPath()` instead. For the previous route, we would do:
          ```go
          // "http://news.domain.com/"
          // "http://news.example.com/"
          host, err := r.Get("article").URLHost("subdomain", "news")
          // "/articles/technology/42"
          ......@@ -275,12 +364,12 @@ And if you use subrouters, host and path defined separately can be built as well
          ```go
          r := mux.NewRouter()
          s := r.Host("{subdomain}.domain.com").Subrouter()
          s := r.Host("{subdomain}.example.com").Subrouter()
          s.Path("/articles/{category}/{id:[0-9]+}").
          HandlerFunc(ArticleHandler).
          Name("article")
          // "http://news.domain.com/articles/technology/42"
          // "http://news.example.com/articles/technology/42"
          url, err := r.Get("article").URL("subdomain", "news",
          "category", "technology",
          "id", "42")
          ......@@ -491,6 +580,73 @@ r.Use(amw.Middleware)
          Note: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to. Middlewares _should_ write to `ResponseWriter` if they _are_ going to terminate the request, and they _should not_ write to `ResponseWriter` if they _are not_ going to terminate it.
          ### Handling CORS Requests
          [CORSMethodMiddleware](https://godoc.org/github.com/gorilla/mux#CORSMethodMiddleware) intends to make it easier to strictly set the `Access-Control-Allow-Methods` response header.
          * You will still need to use your own CORS handler to set the other CORS headers such as `Access-Control-Allow-Origin`
          * The middleware will set the `Access-Control-Allow-Methods` header to all the method matchers (e.g. `r.Methods(http.MethodGet, http.MethodPut, http.MethodOptions)` -> `Access-Control-Allow-Methods: GET,PUT,OPTIONS`) on a route
          * If you do not specify any methods, then:
          > _Important_: there must be an `OPTIONS` method matcher for the middleware to set the headers.
          Here is an example of using `CORSMethodMiddleware` along with a custom `OPTIONS` handler to set all the required CORS headers:
          ```go
          package main
          import (
          "net/http"
          "github.com/gorilla/mux"
          )
          func main() {
          r := mux.NewRouter()
          // IMPORTANT: you must specify an OPTIONS method matcher for the middleware to set CORS headers
          r.HandleFunc("/foo", fooHandler).Methods(http.MethodGet, http.MethodPut, http.MethodPatch, http.MethodOptions)
          r.Use(mux.CORSMethodMiddleware(r))
          http.ListenAndServe(":8080", r)
          }
          func fooHandler(w http.ResponseWriter, r *http.Request) {
          w.Header().Set("Access-Control-Allow-Origin", "*")
          if r.Method == http.MethodOptions {
          return
          }
          w.Write([]byte("foo"))
          }
          ```
          And an request to `/foo` using something like:
          ```bash
          curl localhost:8080/foo -v
          ```
          Would look like:
          ```bash
          * Trying ::1...
          * TCP_NODELAY set
          * Connected to localhost (::1) port 8080 (#0)
          > GET /foo HTTP/1.1
          > Host: localhost:8080
          > User-Agent: curl/7.59.0
          > Accept: */*
          >
          < HTTP/1.1 200 OK
          < Access-Control-Allow-Methods: GET,PUT,PATCH,OPTIONS
          < Access-Control-Allow-Origin: *
          < Date: Fri, 28 Jun 2019 20:13:30 GMT
          < Content-Length: 3
          < Content-Type: text/plain; charset=utf-8
          <
          * Connection #0 to host localhost left intact
          foo
          ```
          ### Testing Handlers
          Testing handlers in a Go web application is straightforward, and _mux_ doesn't complicate this any further. Given two files: `endpoints.go` and `endpoints_test.go`, here's how we'd test an application using _mux_.
          ......@@ -503,8 +659,8 @@ package main
          func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {
          // A very simple health check.
          w.WriteHeader(http.StatusOK)
          w.Header().Set("Content-Type", "application/json")
          w.WriteHeader(http.StatusOK)
          // In the future we could report back on the status of our DB, or our cache
          // (e.g. Redis) by performing a simple PING, and include them in the response.
          ......
          vendor/github.com/gorilla/mux/context.go deleted 100644 → 0
          View file @ 13e3d50f
          package mux
          import (
          "context"
          "net/http"
          )
          func contextGet(r *http.Request, key interface{}) interface{} {
          return r.Context().Value(key)
          }
          func contextSet(r *http.Request, key, val interface{}) *http.Request {
          if val == nil {
          return r
          }
          return r.WithContext(context.WithValue(r.Context(), key, val))
          }
          func contextClear(r *http.Request) {
          return
          }
          vendor/github.com/gorilla/mux/doc.go
          View file @ 45ce8b86
          ......@@ -295,7 +295,7 @@ A more complex authentication middleware, which maps session token to users, cou
          r := mux.NewRouter()
          r.HandleFunc("/", handler)
          amw := authenticationMiddleware{}
          amw := authenticationMiddleware{tokenUsers: make(map[string]string)}
          amw.Populate()
          r.Use(amw.Middleware)
          ......
          vendor/github.com/gorilla/mux/middleware.go
          View file @ 45ce8b86
          ......@@ -32,37 +32,19 @@ func (r *Router) useInterface(mw middleware) {
          r.middlewares = append(r.middlewares, mw)
          }
          // CORSMethodMiddleware sets the Access-Control-Allow-Methods response header
          // on a request, by matching routes based only on paths. It also handles
          // OPTIONS requests, by settings Access-Control-Allow-Methods, and then
          // returning without calling the next http handler.
          // CORSMethodMiddleware automatically sets the Access-Control-Allow-Methods response header
          // on requests for routes that have an OPTIONS method matcher to all the method matchers on
          // the route. Routes that do not explicitly handle OPTIONS requests will not be processed
          // by the middleware. See examples for usage.
          func CORSMethodMiddleware(r *Router) MiddlewareFunc {
          return func(next http.Handler) http.Handler {
          return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
          var allMethods []string
          err := r.Walk(func(route *Route, _ *Router, _ []*Route) error {
          for _, m := range route.matchers {
          if _, ok := m.(*routeRegexp); ok {
          if m.Match(req, &RouteMatch{}) {
          methods, err := route.GetMethods()
          if err != nil {
          return err
          }
          allMethods = append(allMethods, methods...)
          }
          break
          }
          }
          return nil
          })
          allMethods, err := getAllMethodsForRoute(r, req)
          if err == nil {
          w.Header().Set("Access-Control-Allow-Methods", strings.Join(append(allMethods, "OPTIONS"), ","))
          if req.Method == "OPTIONS" {
          return
          for _, v := range allMethods {
          if v == http.MethodOptions {
          w.Header().Set("Access-Control-Allow-Methods", strings.Join(allMethods, ","))
          }
          }
          }
          ......@@ -70,3 +52,23 @@ func CORSMethodMiddleware(r *Router) MiddlewareFunc {
          })
          }
          }
          // getAllMethodsForRoute returns all the methods from method matchers matching a given
          // request.
          func getAllMethodsForRoute(r *Router, req *http.Request) ([]string, error) {
          var allMethods []string
          for _, route := range r.routes {
          var match RouteMatch
          if route.Match(req, &match) || match.MatchErr == ErrMethodMismatch {
          methods, err := route.GetMethods()
          if err != nil {
          return nil, err
          }
          allMethods = append(allMethods, methods...)
          }
          }
          return allMethods, nil
          }
          vendor/github.com/gorilla/mux/mux.go
          View file @ 45ce8b86
          ......@@ -5,6 +5,7 @@
          package mux
          import (
          "context"
          "errors"
          "fmt"
          "net/http"
          ......@@ -22,7 +23,7 @@ var (
          // NewRouter returns a new router instance.
          func NewRouter() *Router {
          return &Router{namedRoutes: make(map[string]*Route), KeepContext: false}
          return &Router{namedRoutes: make(map[string]*Route)}
          }
          // Router registers routes to be matched and dispatches a handler.
          ......@@ -50,24 +51,75 @@ type Router struct {
          // Configurable Handler to be used when the request method does not match the route.
          MethodNotAllowedHandler http.Handler
          // Parent route, if this is a subrouter.
          parent parentRoute
          // Routes to be matched, in order.
          routes []*Route
          // Routes by name for URL building.
          namedRoutes map[string]*Route
          // See Router.StrictSlash(). This defines the flag for new routes.
          strictSlash bool
          // See Router.SkipClean(). This defines the flag for new routes.
          skipClean bool
          // If true, do not clear the request context after handling the request.
          // This has no effect when go1.7+ is used, since the context is stored
          // on the request itself.
          //
          // Deprecated: No effect, since the context is stored on the request itself.
          KeepContext bool
          // see Router.UseEncodedPath(). This defines a flag for all routes.
          useEncodedPath bool
          // Slice of middlewares to be called after a match is found
          middlewares []middleware
          // configuration shared with `Route`
          routeConf
          }
          // common route configuration shared between `Router` and `Route`
          type routeConf struct {
          // If true, "/path/foo%2Fbar/to" will match the path "/path/{var}/to"
          useEncodedPath bool
          // If true, when the path pattern is "/path/", accessing "/path" will
          // redirect to the former and vice versa.
          strictSlash bool
          // If true, when the path pattern is "/path//to", accessing "/path//to"
          // will not redirect
          skipClean bool
          // Manager for the variables from host and path.
          regexp routeRegexpGroup
          // List of matchers.
          matchers []matcher
          // The scheme used when building URLs.
          buildScheme string
          buildVarsFunc BuildVarsFunc
          }
          // returns an effective deep copy of `routeConf`
          func copyRouteConf(r routeConf) routeConf {
          c := r
          if r.regexp.path != nil {
          c.regexp.path = copyRouteRegexp(r.regexp.path)
          }
          if r.regexp.host != nil {
          c.regexp.host = copyRouteRegexp(r.regexp.host)
          }
          c.regexp.queries = make([]*routeRegexp, 0, len(r.regexp.queries))
          for _, q := range r.regexp.queries {
          c.regexp.queries = append(c.regexp.queries, copyRouteRegexp(q))
          }
          c.matchers = make([]matcher, len(r.matchers))
          copy(c.matchers, r.matchers)
          return c
          }
          func copyRouteRegexp(r *routeRegexp) *routeRegexp {
          c := *r
          return &c
          }
          // Match attempts to match the given request against the router's registered routes.
          ......@@ -143,8 +195,8 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
          var handler http.Handler
          if r.Match(req, &match) {
          handler = match.Handler
          req = setVars(req, match.Vars)
          req = setCurrentRoute(req, match.Route)
          req = requestWithVars(req, match.Vars)
          req = requestWithRoute(req, match.Route)
          }
          if handler == nil && match.MatchErr == ErrMethodMismatch {
          ......@@ -155,22 +207,18 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
          handler = http.NotFoundHandler()
          }
          if !r.KeepContext {
          defer contextClear(req)
          }
          handler.ServeHTTP(w, req)
          }
          // Get returns a route registered with the given name.
          func (r *Router) Get(name string) *Route {
          return r.getNamedRoutes()[name]
          return r.namedRoutes[name]
          }
          // GetRoute returns a route registered with the given name. This method
          // was renamed to Get() and remains here for backwards compatibility.
          func (r *Router) GetRoute(name string) *Route {
          return r.getNamedRoutes()[name]
          return r.namedRoutes[name]
          }
          // StrictSlash defines the trailing slash behavior for new routes. The initial
          ......@@ -221,55 +269,24 @@ func (r *Router) UseEncodedPath() *Router {
          return r
          }
          // ----------------------------------------------------------------------------
          // parentRoute
          // ----------------------------------------------------------------------------
          func (r *Router) getBuildScheme() string {
          if r.parent != nil {
          return r.parent.getBuildScheme()
          }
          return ""
          }
          // getNamedRoutes returns the map where named routes are registered.
          func (r *Router) getNamedRoutes() map[string]*Route {
          if r.namedRoutes == nil {
          if r.parent != nil {
          r.namedRoutes = r.parent.getNamedRoutes()
          } else {
          r.namedRoutes = make(map[string]*Route)
          }
          }
          return r.namedRoutes
          }
          // getRegexpGroup returns regexp definitions from the parent route, if any.
          func (r *Router) getRegexpGroup() *routeRegexpGroup {
          if r.parent != nil {
          return r.parent.getRegexpGroup()
          }
          return nil
          }
          func (r *Router) buildVars(m map[string]string) map[string]string {
          if r.parent != nil {
          m = r.parent.buildVars(m)
          }
          return m
          }
          // ----------------------------------------------------------------------------
          // Route factories
          // ----------------------------------------------------------------------------
          // NewRoute registers an empty route.
          func (r *Router) NewRoute() *Route {
          route := &Route{parent: r, strictSlash: r.strictSlash, skipClean: r.skipClean, useEncodedPath: r.useEncodedPath}
          // initialize a route with a copy of the parent router's configuration
          route := &Route{routeConf: copyRouteConf(r.routeConf), namedRoutes: r.namedRoutes}
          r.routes = append(r.routes, route)
          return route
          }
          // Name registers a new route with a name.
          // See Route.Name().
          func (r *Router)