Make HTTP middleware easier to use

server/router/router.go

+// Copyright 2016 The LUCI Authors. All rights reserved.
+// Use of this source code is governed under the Apache License, Version 2.0
+// that can be found in the LICENSE file.
+
+// Package router provides an HTTP router with support for middleware and
+// subrouters. It wraps around julienschmidt/httprouter.
+package router
+
+import (
+        "net/http"
+        "strings"
+
+        "github.com/julienschmidt/httprouter"
+        "golang.org/x/net/context"
+)
+
+// Router is the main type for the package. To create a Router, use New.
+type Router struct {
+        hrouter    *httprouter.Router
+        middleware MiddlewareChain
+        BasePath   string
+}
+
+// Context contains the context, response writer, request, and params shared
+// across Middleware and Handler functions.
+type Context struct {
+        context.Context
+        http.ResponseWriter
+
+        Request *http.Request
+        Params  httprouter.Params
+        status  int

[Vadim Sh., 2016/06/17 00:57:31]

not needed anymore

[nishanths, 2016/06/17 01:48:51]

Sorry I missed that. Done.

+}
+
+var (
+        _ http.Handler        = (*Router)(nil)
+        _ context.Context     = (*Context)(nil)
+        _ http.ResponseWriter = (*Context)(nil)
+)
+
+// New creates a Router.
+func New() *Router {
+        return &Router{
+                hrouter:  httprouter.New(),
+                BasePath: "/",
+        }
+}
+
+// Use adds middleware chains to the group. The added middleware applies to
+// all handlers registered on the router and to all handlers registered on
+// routers that may be derived from the router (using Subrouter).
+func (r *Router) Use(mc MiddlewareChain) {
+        r.middleware = append(r.middleware, mc...)
+}
+
+// Subrouter creates a new router with an updated base path.
+// The new router copies middleware and configuration from the
+// router it derives from.
+func (r *Router) Subrouter(relativePath string) *Router {
+        newRouter := &Router{
+                hrouter:  r.hrouter,
+                BasePath: makeBasePath(r.BasePath, relativePath),
+        }
+        if len(r.middleware) > 0 {
+                newRouter.middleware = make(MiddlewareChain, len(r.middleware))
+                copy(newRouter.middleware, r.middleware)
+        }
+        return newRouter
+}
+
+// GET is a shortcut for router.Handle("GET", path, mc, h)
+func (r *Router) GET(path string, mc MiddlewareChain, h Handler) {

[Vadim Sh., 2016/06/17 01:07:52]

also, what do you feel about adding a bit more magic here:

func (r *Router) GET(path string, args ...interface{}) {
  // type cast first len(args) - 1 args to Middleware or MiddlewareChain, merge
  // type cast the last one to Handler
  ...
}

r.GET("/path", Logging, Auth, handler)

?

[nishanths, 2016/06/17 01:48:51]

panic if we cannot coerce to the types we expect? (Nevertheless, the panic will
happen as soon as the server is started.) I'm open to changing if you want to,
however I prefer having the types mentioned because it is better documented and
checked at compile time.

[Vadim Sh., 2016/06/17 01:58:14]

Yeah... Explicit types are probably better than magic that saves few keystrokes.

[nodir, 2016/06/17 02:00:09]

yes
fwiw i am ok with ...interface{}
if user makes a mistake, server won't start

+        r.Handle("GET", path, mc, h)
+}
+
+// HEAD is a shortcut for router.Handle("HEAD", path, mc, h)
+func (r *Router) HEAD(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("HEAD", path, mc, h)
+}
+
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, mc, h)
+func (r *Router) OPTIONS(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("OPTIONS", path, mc, h)
+}
+
+// POST is a shortcut for router.Handle("POST", path, mc, h)
+func (r *Router) POST(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("POST", path, mc, h)
+}
+
+// PUT is a shortcut for router.Handle("PUT", path, mc, h)
+func (r *Router) PUT(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("PUT", path, mc, h)
+}
+
+// PATCH is a shortcut for router.Handle("PATCH", path, mc, h)
+func (r *Router) PATCH(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("PATCH", path, mc, h)
+}
+
+// DELETE is a shortcut for router.Handle("DELETE", path, mc, h)
+func (r *Router) DELETE(path string, mc MiddlewareChain, h Handler) {
+        r.Handle("DELETE", path, mc, h)
+}
+
+// Handle registers a middleware chain and a handler for the given method and
+// path. len(mc)==0 is allowed. See https://godoc.org/github.com/julienschmidt/httprouter
+// for documentation on how the path may be formatted.
+func (r *Router) Handle(method, path string, mc MiddlewareChain, h Handler) {
+        handle := r.adapt(mc, h)
+        r.hrouter.Handle(method, httprouter.CleanPath(r.BasePath+path), handle)
+}
+
+// ServeHTTP makes Router implement the http.Handler interface.
+func (r *Router) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+        r.hrouter.ServeHTTP(rw, req)
+}
+
+// adapt adapts given middleware chain and handler into a httprouter-style handle.
+func (r *Router) adapt(mc MiddlewareChain, h Handler) httprouter.Handle {
+        return httprouter.Handle(func(rw http.ResponseWriter, req *http.Request, p httprouter.Params) {
+                run(&Context{
+                        Context:        context.Background(),
+                        ResponseWriter: rw,
+                        Request:        req,
+                        Params:         p,
+                }, r.middleware, mc, h)
+        })
+}
+
+func makeBasePath(base, relative string) string {
+        path := httprouter.CleanPath(base + relative)
+        if !strings.HasSuffix(path, "/") {
+                path += "/"
+        }
+        return path
+}