Add initial middleware package.

appengine/middleware/context.go

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package middleware
+
+import (
+        "net/http"
+
+        "github.com/julienschmidt/httprouter"
+        "github.com/luci/gae/impl/memory"
+        "github.com/luci/gae/impl/prod"
+        "github.com/luci/luci-go/appengine/gaelogger"
+        "github.com/luci/luci-go/common/logging/memlogger"
+        "golang.org/x/net/context"
+)
+
+// Handler is the type for all middleware handlers. Of particular note, it's the
+// same has httprouder.Handle, except that it also has a context parameter.

[Vadim Sh., 2015/10/13 01:29:14]

typo: same as?

[iannucci, 2015/10/13 01:37:17]

yup

+type Handler func(context.Context, http.ResponseWriter, *http.Request, httprouter.Params)
+
+// Base adapts a middleware-style handler to a httprouter.Handle. It passes
+// a new, empty context to `h`.
+func Base(h Handler) httprouter.Handle {

[dnj, 2015/10/13 01:44:49]

Make this take context.Context. context.Background is easy enough to supply, and
this lets a user define their own prod/etc. stack.

[iannucci, 2015/10/13 01:56:34]

I think you misunderstand the point of this. This is to adapt middleware style
functions to be accepted by httprouter.

[dnj, 2015/10/13 04:39:10]

Context generation shouldn't have to start at the middleware layer. I would much
prefer:
router.GET(middleware.Base(context.Background(), h)

For example, maybe I want to do:
ctx := log.SetField(context.Background(), "apiVersion", "1")
router.GET(middleware.BaseProd(ctx, ...))

The setup right now basically says, "if you use middleware, you must use more
middleware handlers to generate the actual context." That's fine, I guess; I
just prefer the option of supplying my own.

[iannucci, 2015/10/13 04:52:29]

Ah, ah, ok... I misunderstood you.

The amount of context construction you can do in init() is extremely limited
though. Note that you could also do:

myBase := func(h middleware.Handler) httprouter.Handle {
  return middleware.Base(func(c, rw, req, p) {
    // add lots of default stuff to c, but realistically using req and p
    h(c, rw, req, p)
  })
}

I'm not sure what the benefit of doing it at the Base layer is, except that it
forces the majority users (who will not want to put init()-static stuff in the
context) to have an extra empty parameter (context.Background())?

One thing that COULD be useful would be that you could add a memory logger to
the context... but then if you use BaseTest, it would be overwritten because
context is dumb :) (I guess we could add UseIfNotSet methods to all the service
packages... ugh). This is solved pretty easily in the tests, however, by just
capturing it in a middleware closure though :)

+        return func(rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+                h(context.Background(), rw, r, p)
+        }
+}
+
+// BaseProd adapts a middleware-style handler to a httprouter.Handle. It passes
+// a new context to `h` with the following services installed:
+//   * github.com/luci/gae/impl/prod (production appengine services)
+//   * github.com/luci/luci-go/appengine/gaelogger (appengine logging service)
+func BaseProd(h Handler) httprouter.Handle {
+        return func(rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+                h(gaelogger.Use(prod.UseRequest(r)), rw, r, p)
+        }
+}
+
+// BaseTest adapts a middleware-style handler to a httprouter.Handle. It passes
+// a new context to `h` with the following services installed:
+//   * github.com/luci/gae/impl/memory (in-memory appengine services)
+//   * github.com/luci/luci-go/common/logging/memlogger (in-memory logging service)
+func BaseTest(h Handler) httprouter.Handle {
+        return func(rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+                h(memlogger.Use(memory.Use(context.Background())), rw, r, p)
+        }
+}