通过golang中的多个HTTP处理程序包含上下文对象

Question

I just read this blog post about creating a function type and implementing the .ServeHTTP() method on that function to be able to handle errors. For example:

type appError struct {
    Error   error
    Message string
    Code    int
}

type appHandler func(http.ResponseWriter, *http.Request) *appError

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if e := fn(w, r); e != nil { // e is *appError, not os.Error.
        http.Error(w, e.Message, e.Code)
    }
}

func init() {
    http.Handle("/view", appHandler(viewRecord)) //viewRecord is an appHandler function
}

I like this approach but I can't conceptually figure out how to include a context object through handler layers. For example:

func init() {
    http.Handle("/view", AuthHandler(appHandler(viewRecord))) 
}

AuthHandler would likely create a &SessionToken{User: user} object and set that in a context.Context object for each request. I can't work out how to get that to the viewRecord handler though. Ideas?

Answer 1

I can think of a couple of approaches to do this.

Passing the context

first you can change the signature to accept context

type appHandler func(http.ResponseWriter, *http.Request, context.Context) *appError

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        if e := fn(w, r, nil); e != nil { // e is *appError, not os.Error.
                http.Error(w, e.Message, e.Code)
        }
}

Now I assume the AuthHandler has to do with authentication and setup the user in the context object.

What you could do is create another type handler which setup the context. like this

type authHandler func(http.ResponseWriter, *http.Request, context.Context) *appError

func (fn authHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {           
    // setup authentication here                                                    
    uid := 1                                                                        

    // setup the context the way you want                                           
    parent := context.TODO()                                                        
    ctx := context.WithValue(parent, userIdKey, uid)                                
    if e := fn(w, r, ctx); e != nil { // e is *appError, not os.Error.              
        http.Error(w, e.Message, e.Code)                                            
    }                                                                               
}

This way you can use it in the following way

func init() {                                                                         
    http.Handle("/view", appHandler(viewRecord))      // don't require authentication 
    http.Handle("/viewAuth", authHandler(viewRecord)) // require authentication       
}                                                                                     

This is the complete code

package main

import (
        "fmt"
        "net/http"

        "code.google.com/p/go.net/context"
)

type appError struct {
        Error   error
        Message string
        Code    int
}

type key int

const userIdKey key = 0

type appHandler func(http.ResponseWriter, *http.Request, context.Context) *appError

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        if e := fn(w, r, nil); e != nil { // e is *appError, not os.Error.
                http.Error(w, e.Message, e.Code)
        }
}

type authHandler func(http.ResponseWriter, *http.Request, context.Context) *appError

func (fn authHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        // setup authentication here
        uid := 1

        // setup the context the way you want
        parent := context.TODO()
        ctx := context.WithValue(parent, userIdKey, uid)
        if e := fn(w, r, ctx); e != nil { // e is *appError, not os.Error.
                http.Error(w, e.Message, e.Code)
        }
}

func viewRecord(w http.ResponseWriter, r *http.Request, c context.Context) *appError {

        if c == nil {
                fmt.Fprintf(w, "User are not logged in")
        } else {
                uid := c.Value(userIdKey)
                fmt.Fprintf(w, "User logged in with uid: %d", uid)
        }

        return nil
}

func init() {
        http.Handle("/view", appHandler(viewRecord))      // viewRecord is an appHandler function
        http.Handle("/viewAuth", authHandler(viewRecord)) // viewRecord is an authHandler function
}

func main() {
        http.ListenAndServe(":8080", nil)
}

create map context

Instead of passing the context, you create

var contexts map[*http.Request]context.Context

and get the context in view with contexts[r].

But because of map is not thread safe, access to the map must be protected with mutex.

And guess what, this is what gorilla context is doing for you, and I think it's better approach

https://github.com/gorilla/context/blob/master/context.go#l20-28

this is the full code

package main

import (
        "fmt"
        "net/http"

        "github.com/gorilla/context"
)

type appError struct {
        Error   error
        Message string
        Code    int
}

type key int

const userIdKey key = 0

type appHandler func(http.ResponseWriter, *http.Request) *appError

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        if e := fn(w, r); e != nil { // e is *appError, not os.Error.
                http.Error(w, e.Message, e.Code)
        }
}

type authHandler func(http.ResponseWriter, *http.Request) *appError

func (fn authHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        // setup authentication here
        uid := 1

        context.Set(r, userIdKey, uid)
        if e := fn(w, r); e != nil { // e is *appError, not os.Error.
                http.Error(w, e.Message, e.Code)
        }
}

func viewRecord(w http.ResponseWriter, r *http.Request) *appError {

        if uid, ok := context.GetOk(r, userIdKey); !ok {
                fmt.Fprintf(w, "User are not logged in")
        } else {
                fmt.Fprintf(w, "User logged in with uid: %d", uid)
        }

        return nil
}

func init() {
        http.Handle("/view", appHandler(viewRecord))      // don't require authentication
        http.Handle("/viewAuth", authHandler(viewRecord)) // require authentication
}

func main() {
        http.ListenAndServe(":8080", nil)
}

you can also opt for wrapper function instead of type function for auth

func AuthHandler(h appHandler) appHandler {                                   
    return func(w http.ResponseWriter, r *http.Request) *appError {
        // setup authentication here                                          
        uid := 1                                                              

        context.Set(r, userIdKey, uid)                                        
        return h(w, r)                                                        
    }                                                                        
}  

func init() {                                                                                    
    http.Handle("/view", appHandler(viewRecord))                  // don't require authentication
    http.Handle("/viewAuth", appHandler(AuthHandler(viewRecord))) // require authentication      
}