Dealing with middleware that requires access to the database in Go - go

Question

I am having an issue with creating a middleware that will be chained to other routes and requires access to the database and am not sure how to approach this problem.
I store all of my app context, including the database in a struct called AppContext. I want to create a function handler that looks something like this:
func SomeHandler(appC *AppContext, next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
// Access the database using appC.db
// Logic that requires access to the database.
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
}
}
In main.go, I have tried:
someHandler := middleware.SomeHandler(&appC)
However, I get the error not enough arguments in call to middleware.SomeHandler. What would be the best way to approach this problem?

Answer 1

The error you're getting is due to not providing the second argument, next http.Handler.
In the case of how to go about the middleware, I recommend taking a look at the implementation of the http.ServeMux https://golang.org/src/net/http/server.go?s=57308:57433#L1890 it essentially does what you're trying to do (and then some) for routing though. So using a http.Handler struct might be more easy here than using a Handler function, this way the Handler(s) you'd have as the next http.Handler argument in your function are just a field within the struct that the parent handler can call from within its ServeHTTP().
So to wrap up my point, you might want to use a struct that implements the http.Handler interface. That way it can have child handlers and the DB access. That way you don't have to keep passing this AppContext either.

Answer 2

I'd not do a premature setup of the context. It is specifically there to be request scoped.
I'd rather create a small and dedicated middleware for passing a database session out of the pool into the context and retrieve said session created for the request in the main handler.
func DBSession(sess *mgo.Session, next http.Handler) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
// Create a new session for the scope of the request
s := sess.Copy()
// Make it close when exiting scope
defer s.Close()
// Add the new session (actually a pointer to it)
// acessible via the name "_sess"
ctx = context.WithValue(r.Context(), "_sess", s)
// execute the next handler
next(w, r.WithContext(ctx))
})
}
Now you can use this middleware in you main.go
package main
import (
"net/http"
"gopkg.in/mgo.v2"
)
func sayHello(w http.ResponseWriter, r *http.Request) http.Handler{
return http.HandlerFunc(
func (w http.ResponseWriter, r *http.Request) {
s := r.Context().Value("_sess").(*mgo.Session)
// Do something with your database here.
}
)
}
func main() {
// Ignoring err for brevity
sess, _ := mgo.Dial("localhost:27017")
// Magic happens here: the sayHello Handler is wrapped in the
// DBSession middleware, which makes the session available
// as context param _sess and closes the session after sayHello
// executed. No clutter in your controller for setting up and tearing down
// the session, no way you can forget to close it.
http.Handle("/", middleware.DBSession(sess, sayHello))
}