Pass context from controller of web request to database layer

I have REST services:

each request has a header with JWT token
each controller get parameters from request (variables, body..) and pass them to data layer

I need to pass JWT token from header of each request into corresponding data layer method like this:

func (a *App) UpdateOrder(_ http.ResponseWriter, r *http.Request) (interface{}, error) {

    bodyData := new(models.Order)
    err = json.NewDecoder(r.Body).Decode(&bodyData)
    if err != nil {
       return nil, err
    }

    user, err := a.Saga.GetUserByToken(r.Header.Get("Authorization"))  // here
    // error handling ...

    a.DbLayer.UpdateOrder(id, bodyData, user)  // and there
}

In this case I must write the same code for each controller to get the user by token, and pass this user to database layer explicitly.

Is there a way to pass this user for each request without writing this code in each controller ?

I know about middleware and I can get user by token in my middleware. But how can I pass this user from middleware to corresponding database level method ?

May be I am looking for something like "global variables" for goroutine ? I can get user in my middleware and set it to something like "global variable". I can get the value of this "global variable" in the database layer. But it must be "global variable" for the current web request and concurrent web requests mustn't affect to each other.

Is there a some mechanism in Go, http module or gorilla\mux to implement what I have called "global variables" ?

Solution

You are describing contexts.

Originally there was the gorilla context package, which provides a pseudoglobal context object - essentially a map[interface{}]interface{} with a reference intrinsicly available to all players in the middleware/controller/datalayer stack.

See this except from an excellent guide to the package (all credit to the author, Matt Silverlock).

type contextKey int

// Define keys that support equality.
const csrfKey contextKey = 0
const userKey contextKey = 1

var ErrCSRFTokenNotPresent = errors.New("CSRF token not present in the request context.")

// We'll need a helper function like this for every key:type
// combination we store in our context map else we repeat this
// in every middleware/handler that needs to access the value.
func GetCSRFToken(r *http.Request) (string, error) {
    val, ok := context.GetOk(r, csrfKey)
    if !ok {
        return "", ErrCSRFTokenNotPresent
    }

    token, ok := val.(string)
    if !ok {
        return "", ErrCSRFTokenNotPresent
    }

    return token, nil
}

// A bare-bones example
func CSRFMiddleware(h http.Handler) http.Handler {
    return func(w http.ResponseWriter, r *http.Request) {
        token, err := GetCSRFToken(r)
        if err != nil {
            http.Error(w, "No good!", http.StatusInternalServerError)
            return
        }

        // The map is global, so we just call the Set function
        context.Set(r, csrfKey, token)

        h.ServeHTTP(w, r)
    }
}

After the gorilla package's inception, a context package was added to the standard library. It's slightly different, in that contexts are no longer pseudoglobal, but instead passed from method to method. Under this, the context comes attached to the initial request - available via request.Context. Layers below the handler can accept a context value as a part of their signature, and read values from it.

Here's a simplified example:

type contextKey string

var (
    aPreSharedKey = contextKey("a-preshared-key")
)

func someHandler(w http.ResponseWriter, req *http.Request) {
    ctx := context.WithValue(req.Context, aPreSharedKey, req.Header.Get("required-header"))
    data, err := someDataLayerFunction(ctx)
    if err != nil {
        fmt.Fprintf(w, "uhoh", http.StatusBadRequest)
        return
    }
    fmt.Fprintf(w, data, http.StatusOK)
}

func someDataLayerFunction(ctx context.Context) (string, error) {
    val, ok := ctx.Value(aPreSharedKey).(string)
    if !ok {
        return nil, errors.New("required context value missing")
    }
    return val
}

For more details and a less contrived example, check out google's excellent blog on the context package's use.