Net/http and the http.handler interface

net/http and the
http.Handler interface
(or simply put, building web servers in Go)

Who am I?
● Work at
● Go developer since 2013
● Currently building cloud based energy
optimization system for commercial buildings
(using Go)
● Joakim Gustin

Agenda
● The basics
● Routing
● Middleware
● Accessing “globals”
● Testing
● Tips and tricks

HTTP in Go
● Built in web server (net/http)
● Core piece of the Go standard library
● Can be run facing clients (even Cloudflare does)
● Handles TLS
● Automatic support for HTTP/2

net/http - ListenAndServe(this blue means
official GoDoc)

The http.Handler interface
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
type ResponseWriter interface {
Header() Header
WriteHeader(statusCode int)
Write([]byte) (int, error)
}
type Request struct {
Method string
URL *url.URL
Body io.ReadCloser
// … rest omitted
}

The naive approach
import “net/http”
type myServer struct {}
func (ms *myServer) ServeHTTP(rw ResponseWriter, req *Request) {
if req.method == “GET” {
rw.Write([]byte(“hello, Go West”)
}
}
func main() {
http.ListenAndServe(":8080", myServer)
}

How about some routing?
rw.Write([]byte(“hello, Go West”)
}
}
func main() {
http.Handle("/hello", myHandler)
http.ListenAndServe(":8080", nil) // nil, wut?
}

The http.ServeMux
type myHandler struct {}
func (mh *myHandler) ServeHTTP(rw ResponseWriter, req *Request) {
rw.Write([]byte(“hello”)
}
}
func main() {
mux := http.NewServeMux()
mux.Handle("/hello", myHandler)
http.ListenAndServe(":8080", mux) // phew, much better
}

Can we make this part simpler?
// implementing the http.Handler interface
}
}

Revisiting the go type system
type myServer struct {} // Define a type
func (s myServer) DoSomething() {} // Define a method on it
type serverList []myServer // A type can be many things
func (sl serverList) DoSomething() {} // yep, valid
// wait a minute, functions are first class citizens in Go, right?
type mathFunc func(int) int
func (mf mathFunc) DoSomething() {} // OMG, yes it’s valid

A function implementing an interface?!
type HandlerFunc func(http.ResponseWriter, *http.Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}

Revisiting our example
// Look ma, no struct!
func myHandler(rw ResponseWriter, req *Request) {
}
}
func main() {
mux.Handle("/hello", http.HandlerFunc(myHandler))
log.Fatal(http.ListenAndServe(":8080", mux))
}

Revisiting our example
func main() {
mux.HandleFunc("/hello", myHandler)
log.Fatal(http.ListenAndServe(":8080", mux))}
}

Routing the std lib way
func editHandler(w http.ResponseWriter, r *http.Request) {
title := r.URL.Path[len("/edit/"):]
}
func main() {
mux.HandleFunc("/edit/", editHandler)
http.ListenAndServe(":8080", mux)
}
$ curl localhost:8080/edit/my-page
$ # yeah, alright, but what about
$ curl localhost:8080/edit/my-page/revision/2

Third party to the rescue!
title := chi.URLParam(r, “title”)
}
func main() {
mux := chi.NewRouter()
mux.Get("/edit/{title}", editHandler)
mux.Patch("/{month}-{day}-{year}/update", fancyPatchHandler)
}
$ go get github.com/go-chi/chi

Third party to the rescue!
title := r.URL.Path[len("/edit/"):]
}
func main() {
mux.Get("/edit/", editHandler)
mux.Patch("/{month}-{day}-{year}/update", fancyPatchHandler)
}
$ go get github.com/go-chi/chi

Net/http and the http.handler interface

type middleware func(next http.Handler) http.Handler
The middleware signature

Simple logging middleware
func logger(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Println("Before")
h.ServeHTTP(w, r) // call wrapped handler
log.Println("After")
})
}
func main() {
mux.Get("/edit/", logger(editHandler))
}

Control flow
func authenticated(h http.Handler) http.Handler {
if (isAuthenticated) { // Perform application auth
h.ServeHTTP(w, r) // call wrapped handler
} else {
w.WriteHeader(http.StatusUnauthorized)
}
})
}
func main() {
mux.Get("/edit/", authenticated(editHandler))
}

In go-chi
func main() {
// Base middleware
mux.use(logger)
mux.use(rateLimiter)
// Instead of logger(ratelimiter(editHandler))
mux.Get("/edit/", editHandler)
r.Route("/admin", func(r chi.Router) {
r.use(authenticated)
// Instead of logger(ratelimiter(authenticated(adminHandler))
r.Get(“/”, adminHandler)
}
}

Please no package level variables
var (
db *sql.DB
cache redis.Client
)
func updateHandler(w http.ResponseWriter, r *http.Request) {
lastSeen := time.Now()
db.Query(`UPDATE users SET last_seen = ? WHERE id = ?`, lastSeen, 1)
cache.Set(fmt.Sprintf(“%d_last_seen”, 1), lastSeen)
}
func main() {
mux.Get(“/users/update”, updateHandler)
}

Inject the dependencies instead!
type HTTPEnv struct {
db *sql.DB
cache redis.Client
logger log.Logger
}
func makeUpdateHandler(env *HTTPEnv) http.Handler {
lastSeen := time.Now()
env.db.Query(`UPDATE users SET last_seen = ? WHERE id = ?`, lastSeen, 1)
env.cache.Set(fmt.Sprintf(“%d_last_seen”, 1), lastSeen)
})
}
func main() {
env := HTTPEnv{} // Setup a global env here
mux.Get(“/users/update”, makeUpdateHandler(env))
}

Creating an HTTP request
req, err := http.NewRequest(“GET”, “localhost:3000/my-route”, nil)

Testing an individual handler
import “net/http/httptest”
func TestMyHandler(t *testing.T) {
req := httptest.NewRequest("GET", "/2018-03-07", nil)
w := httptest.NewRecorder()
updateHandler(w, req)
// Assert stuff on w
}

Testing an entire server
import “net/http/httptest”
func TestMyHandler(t *testing.T) {
mux := myapp.NewRootMux() // Let’s pretend this exists
// Now you will get the entire chain of middleware etc
ts := httptest.NewServer(mux)
defer ts.Close()
res, _:= http.Get(ts.URL + “/edit/2018-03-07”)
// Assert stuff on res
}

Anonymous struct
type userRequest struct {
username string
password string
}
func createUserHandler(rw http.ResponseWriter, r *http.Request) {
var user userRequest
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
w.write([]byte(“an error occured”))
}
data := struct {
Message string
Username string
}{
Message: “Success!”,
Username: user.username,
}
json.NewEncoder(rw).Encode(data)
}

A small gotcha...
func createUserHandler(rw http.ResponseWriter, r *http.Request) {
w.write([]byte(“an error occured”))
// forgot to return, panic!
}
data := struct {
Message string
Username string
}{
Message: “Success!”,
Username: user.username,
}
json.NewEncoder(rw).Encode(data)
}

An altered (better?) interface
type HandlerFunc func(http.ResponseWriter, *http.Request) error

Clearer now?
func createUserHandler(w http.ResponseWriter, r *http.Request) error {
return errors.New(“an error occured!”)
}
data := struct {
Message string
Token string
}{
title,
users,
}
json.NewEncoder(w).Encode(data)
return nil
}

Pluggin’ it in
type ErrorHandlerFunc func(http.ResponseWriter, *http.Request) error
func ErrorHandler(h ErrorHandlerFunc) http.Handler {
if err := f(w, r); err != nil {
// bonus, centralized http error handling
w.Write([]byte(“an error occured”)
}
})
}
func main() {
mux.Get(“/users/update”, ErrorHandler(updateHandler))
}

What about HTTP status codes?
type HTTPError struct {
err error // The actual error
statusCode int
}
func (h HTTPError) Error() string {
return h.err.Error() // Just pass along the original errors message
}
type error interface {
Error() string
}

Handling HTTP Error
type ErrorHandlerFunc func(http.ResponseWriter, *http.Request) error
func ErrorHandler(h ErrorHandlerFunc) http.Handler {
if err := f(w, r); err != nil { // an error occurred
switch e := err.(type) {
case *HTTPError:
w.WriteHeader(e.statusCode)
default:
w.WriteHeader(http.StatusInternalServerError) // aka 500
}
}
})
}

Net/http and the http.handler interface

More Related Content

What's hot (14)

Similar to Net/http and the http.handler interface (20)

Recently uploaded (20)

Net/http and the http.handler interface