Горилла / мукс промежуточное ПО не пострадало

Question

Я нахожусь на go version go1.10.4 linux/amd64

Я регистрирую промежуточное ПО, но, похоже, что оно не работает.

package main

import (
    "encoding/json"
    "fmt"
    "github.com/dgrijalva/jwt-go"
    "github.com/gorilla/context"
    "github.com/mitchellh/mapstructure"
    "huru/migrations"
    "huru/models"
    "huru/models/person"
    "huru/routes"
    "net/http"
    "os"

    "github.com/gorilla/mux"
    _ "github.com/lib/pq"
    log "github.com/sirupsen/logrus"
)

func loggingMiddleware(next http.Handler) http.Handler {

    log.Println("logging middleware registered");

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Do stuff here
        log.Println("Here is the request URI:",r.RequestURI)
        // Call the next handler, which can be another middleware in the chain, or the final handler.
        next.ServeHTTP(w, r)
    })
}

type Exception struct {
    Message string `json:"message"`
}

func authMiddleware(next http.Handler) http.Handler {

    log.Println("auth middleware registered");

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

        params := r.URL.Query()
        fmt.Println("the params are:", params);

        token, _ := jwt.Parse(params["token"][0], func(token *jwt.Token) (interface{}, error) {
            if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, fmt.Errorf("there was an error")
            }
            return []byte("secret"), nil
        })
        claims, ok := token.Claims.(jwt.MapClaims)

        if ! (ok && token.Valid) {
            json.NewEncoder(w).Encode(Exception{Message: "Invalid authorization token"})
            return;
        }

        var user person.Model
        mapstructure.Decode(claims, &user)
        context.Set(r, "logged_in_user", user)
        next.ServeHTTP(w, r)
    })
}

func errorMiddleware(next http.Handler) http.Handler {

    log.Println("error handling middleware registered");

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {

                log.Error("Caught error in defer/recover middleware: ", err)
                originalError := err.(struct{ OriginalError error }).OriginalError

                if originalError != nil {
                    log.Error("Original error in defer/recover middleware: ", originalError)
                }

                statusCode := err.(struct{ StatusCode int }).StatusCode

                if statusCode != 0 {
                    w.WriteHeader(statusCode)
                } else {
                    w.WriteHeader(http.StatusInternalServerError)
                }

                message := err.(struct{ Message string }).Message

                if message == "" {
                    message = "Unknown error message."
                }

                json.NewEncoder(w).Encode(struct {
                    ID string
                }{
                    message,
                })
            }
        }()
        next.ServeHTTP(w, r)
    })
}

func main() {

    routerParent := mux.NewRouter()
    routerParent.Use(loggingMiddleware)
    routerParent.Use(errorMiddleware)
    routerParent.Use(authMiddleware)

    router := routerParent.PathPrefix("/api/v1").Subrouter();
    router.Use(loggingMiddleware)
    router.Use(errorMiddleware)
    router.Use(authMiddleware)


    // register and login
    {
        handler := routes.LoginHandler{}
        subRouter := router.PathPrefix("/").Subrouter()
        handler.Mount(subRouter, struct{}{});
    }

    {

        handler := routes.RegisterHandler{}
        subRouter := router.PathPrefix("/").Subrouter()
        handler.Mount(subRouter, struct{}{})
    }

    {
        // people
        handler := routes.PersonHandler{}
        subRouter := router.PathPrefix("/").Subrouter()
        subRouter.Use(authMiddleware)
        handler.Mount(subRouter, routes.PersonInjection{People: models.PersonInit()})
    }

     // ...
}

ни один из них не зарегистрирован:

log.Println("error handling middleware registered");
log.Println("auth middleware registered");
log.Println("logging middleware registered");

и во время выполнения ни один из промежуточных программных маршрутов, похоже, не пострадал, там ничего не зарегистрировано.Кто-нибудь знает, почему это может быть?

Обратите внимание, что я не ожидаю, что все это понадобится:

    routerParent := mux.NewRouter()
    routerParent.Use(loggingMiddleware)
    routerParent.Use(errorMiddleware)
    routerParent.Use(authMiddleware)

    router := routerParent.PathPrefix("/api/v1").Subrouter();
    router.Use(loggingMiddleware)
    router.Use(errorMiddleware)
    router.Use(authMiddleware)

на самом деле, я, вероятно, просто хочу:

    routerParent := mux.NewRouter()
    router := routerParent.PathPrefix("/api/v1").Subrouter();
    router.Use(loggingMiddleware)
    router.Use(errorMiddleware)
    router.Use(authMiddleware)

но это просто, чтобы доказать, чточто-то не такВ конце основной функции у меня есть это, чтобы запустить сервер:

host := os.Getenv("huru_api_host")
port := os.Getenv("huru_api_port")

if host == "" {
    host = "localhost"
}

if port == "" {
    port = "80"
}

log.Info(fmt.Sprintf("Huru API server listening on port %s", port))
path := fmt.Sprintf("%s:%s", host, port)
log.Fatal(http.ListenAndServe(path, routerParent))