Gorilla mux custom middleware

Question

I am using gorilla mux for manage routing. What I am missing is to integrate a middleware between every request.

For example

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "strconv"
)

func HomeHandler(response http.ResponseWriter, request *http.Request) {

    fmt.Fprintf(response, "Hello home")
}

func main() {

    port := 3000
    portstring := strconv.Itoa(port)

    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    http.Handle("/", r)

    log.Print("Listening on port " + portstring + " ... ")
    err := http.ListenAndServe(":"+portstring, nil)
    if err != nil {
        log.Fatal("ListenAndServe error: ", err)
    }
}

Every incoming request should pass through the middleware. How can I integrate here a midleware?

Update

I will use it in combination with gorilla/sessions, and they say:

Important Note: If you aren't using gorilla/mux, you need to wrap your handlers with context.ClearHandler as or else you will leak memory! An easy way to do this is to wrap the top-level mux when calling http.ListenAndServe:

How can I prevent this scenario?

Hazel

For those who landed here: gorilla/mux now has inbuilt middleware handling: github.com/gorilla/mux#middleware – Cook

Answer 1

Just create a wrapper, it's rather easy in Go:

func HomeHandler(response http.ResponseWriter, request *http.Request) {

    fmt.Fprintf(response, "Hello home")
}

func Middleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println("middleware", r.URL)
        h.ServeHTTP(w, r)
    })
}
func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    http.Handle("/", Middleware(r))
}

Acne

Thanks for this, h.ServeHTTP(w, r) this part is what I was missing. They don't make it very clear how to directly call a Handler. – Greig

You can also use r.Use(Middleware) to register middleware. – Keli

Answer 2

Mux has an official way of doing it look on this example

// a regular middleware
func Middleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // do stuff before the handlers
        h.ServeHTTP(w, r)
        // do stuff after the hadlers

    })
}

// if you want to pass data into the middleware 
func Middleware2(s string) mux.MiddlewareFunc {
    return func(h http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // do stuff
            fmt.Println(s)
            h.ServeHTTP(w, r)
        })
    }
}

func main() {
    router := mux.NewRouter()


    router.Use(Middleware)
    //you can apply it to a sub-router too
    subRouter := router.PathPrefix("/sub_router/").Subrouter()
    subRouter.Use(Middleware2("somePrams"))
    // Add more middleware if you need, call router.Use Again
    router.Use(Middleware3, Middleware4, Middleware5)

    _ = http.ListenAndServe(":80", router)
}

the official doc on the mux website

Cuprite

Answer 3

I'm not sure why @OneOfOne chose to chain router into the Middleware, I think this is slight better approach:

func main() {
    r.Handle("/",Middleware(http.HandlerFunc(homeHandler)))
    http.Handle("/", r)
}

func Middleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    h.ServeHTTP(w, r)
})}

Vermination

This approach was exactly what I was looking for — a nested Handle with middleware. Thank you! – Wording

This is pretty much the same thing as @OneOfOne's answer – Ephedrine

Answer 4

If you want to apply a middleware chain to all routes of a router or subrouter you can use a fork of Gorilla mux https://github.com/bezrukovspb/mux

subRouter := router.PathPrefix("/use-a-b").Subrouter().Use(middlewareA, middlewareB)
subRouter.Path("/hello").HandlerFunc(requestHandlerFunc)

Shadshadberry

Thanks dude! This express.js middleware style was exactly what I was looking for – Bordiuk

Middleware Use is builtin now in gorilla mux – Hairsplitting

@ozy you mean router.Use(), but it's good to use a subrouter, so that middleware can be applied different places. – Ephedrine

Answer 5

You might consider a middleware package such as negroni.

Mavis

When I would use it gorilla/sessions, it would not happen memory leak? – Hazel

I can't edit since Suggested edit queue is full. The link does not exist anymore. I want to replace it with a new one negroni – Reckon