First time chaining functions - go

Question

Suppose I want to run a logger before I run my custom mux for http server.
Part way there I can chain loggers and add a custom mux like this: https://play.golang.org/p/Edurl-Rhqb9
package main
import (
"fmt"
"net/http"
"time"
"github.com/julienschmidt/httprouter"
)
type Middleware func(http.HandlerFunc) http.HandlerFunc
func ServeHTTPIterator(h http.HandlerFunc, m ...Middleware) http.HandlerFunc {
if len(m) < 1 {
return h
}
wrapped := h
// loop in reverse to preserve middleware order
for i := len(m) - 1; i >= 0; i-- {
wrapped = m[i](wrapped)
}
return wrapped
}
func IndexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello Index!")
}
func LogFirst(h http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`First`)
h.ServeHTTP(w, r)
})
}
func LogSecond(h http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`Second`)
h.ServeHTTP(w, r)
})
}
func main() {
httpServer := &http.Server{
Addr: `my.local:8080`,
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
IdleTimeout: 5 * time.Second,
}
var Router *httprouter.Router
preMiddle := []Middleware{
LogFirst,
LogSecond,
}
http.HandleFunc("/", ServeHTTPIterator(IndexHandler, preMiddle...))
httpServer.Handler = Router
}
But now let suppose I wanted to run my mux after the loggers, in that case I figured I would do something like:
preMiddle := []Middleware{
LogFirst,
LogSecond,
Router,
}
But I'm not sure how to wrap Router to make this work or if this is even a legitimate approach. Could someone clue me in on what I am missing here?

Answer 1

Modify the code to work with http.Handler instead of http.HandlerFunc.
type Middleware func(http.Handler) http.Handler
func ServeHTTPIterator(h http.Handler, m ...Middleware) http.Handler {
if len(m) < 1 {
return h
}
wrapped := h
// loop in reverse to preserve middleware order
for i := len(m) - 1; i >= 0; i-- {
wrapped = m[i](wrapped)
}
return wrapped
}
func LogFirst(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`First`)
h.ServeHTTP(w, r)
})
}
func LogSecond(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`Second`)
h.ServeHTTP(w, r)
})
}
Create the router and register the handler with the router. Add parameters argument to IndexHandler so that the function is compatible with httprouter.
router := httprouter.New()
router.GET("/", IndexHandler)
Wrap the router using the new version of ServeHTTPIterator.
httpServer.Handler = ServeHTTPIterator(router, preMiddle...)
With these changes, the logs are written before the router is called.

Answer 2

You can achieve it by, instead of spreading the middlewares in your serveIterator func expect an slice of middlewares to be applied like: go playground
package main
import (
"fmt"
"net/http"
"time"
"github.com/julienschmidt/httprouter"
)
type Middleware func(http.HandlerFunc) http.HandlerFunc
func ServeHTTPIterator(h http.HandlerFunc, m []Middleware) http.HandlerFunc {
if len(m) < 1 {
return h
}
wrapped := h
// loop in reverse to preserve middleware order
for i := len(m) - 1; i >= 0; i-- {
wrapped = m[i](wrapped)
}
return wrapped
}
func IndexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello Index!")
}
func LogFirst(h http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`First`)
h.ServeHTTP(w, r)
})
}
func LogSecond(h http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Print(`Second`)
h.ServeHTTP(w, r)
})
}
func main() {
httpServer := &http.Server{
Addr: `my.local:8080`,
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
IdleTimeout: 5 * time.Second,
}
var Router *httprouter.Router
preMiddle := []Middleware{
LogFirst,
LogSecond,
}
http.HandleFunc("/", ServeHTTPIterator(IndexHandler, preMiddle))
httpServer.Handler = Router
}