Make HTTP middleware easier to use

server/auth/openid/method.go

 // Copyright 2015 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 openid
 
 import (
         "fmt"
         "net/http"
         "net/url"
         "time"
 
-        "github.com/julienschmidt/httprouter"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/server/auth"
-        "github.com/luci/luci-go/server/middleware"
+        "github.com/luci/luci-go/server/router"
 )
 
 // These are installed into a HTTP router by AuthMethod.InstallHandlers(...).
 const (
         loginURL    = "/auth/openid/login"
         logoutURL   = "/auth/openid/logout"
         callbackURL = "/auth/openid/callback"
 )
 
 // AuthMethod implements auth.Method and auth.UsersAPI and can be used as
@@ skipping 14 matching lines @@
         Insecure bool
 
         // IncompatibleCookies is a list of cookies to remove when setting or clearing
         // session cookie. It is useful to get rid of GAE cookies when OpenID cookies
         // are being used. Having both is very confusing.
         IncompatibleCookies []string
 }
 
 // InstallHandlers installs HTTP handlers used in OpenID protocol. Must be
 // installed in server HTTP router for OpenID authentication flow to work.
-func (m *AuthMethod) InstallHandlers(r *httprouter.Router, base middleware.Base) {
-        r.GET(loginURL, base(m.loginHandler))
-        r.GET(logoutURL, base(m.logoutHandler))
-        r.GET(callbackURL, base(m.callbackHandler))
+func (m *AuthMethod) InstallHandlers(r *router.Router, base router.MiddlewareChain) {
+        r.GET(loginURL, base, m.loginHandler)
+        r.GET(logoutURL, base, m.logoutHandler)
+        r.GET(callbackURL, base, m.callbackHandler)
 }
 
 // Warmup prepares local caches. It's optional.
 func (m *AuthMethod) Warmup(c context.Context) error {
         cfg, err := fetchCachedSettings(c)
         if err != nil {
                 return err
         }
         _, err = fetchDiscoveryDoc(c, cfg.DiscoveryURL)
         return err
@@ skipping 42 matching lines @@
 func (m *AuthMethod) LogoutURL(c context.Context, dest string) (string, error) {
         if m.SessionStore == nil {
                 return "", ErrNotConfigured
         }
         return makeRedirectURL(logoutURL, dest)
 }
 
 ////
 
 // loginHandler initiates login flow by redirecting user to OpenID login page.
-func (m *AuthMethod) loginHandler(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func (m *AuthMethod) loginHandler(ctx *router.Context) {
+        c, rw, r := ctx.Context, ctx.Writer, ctx.Request
+
         dest, err := normalizeURL(r.URL.Query().Get("r"))
         if err != nil {
                 replyError(c, rw, err, "Bad redirect URI (%q) - %s", dest, err)
                 return
         }
 
         cfg, err := fetchCachedSettings(c)
         if err != nil {
                 replyError(c, rw, err, "Can't load OpenID settings - %s", err)
                 return
         }
 
         // `state` will be propagated by OpenID backend and will eventually show up
         // in callback URI handler. See callbackHandler.
         state := map[string]string{
                 "dest_url": dest,
                 "host_url": r.Host,
         }
         authURI, err := authenticationURI(c, cfg, state)
         if err != nil {
                 replyError(c, rw, err, "Can't generate authentication URI - %s", err)
                 return
         }
         http.Redirect(rw, r, authURI, http.StatusFound)
 }
 
 // logoutHandler nukes active session and redirect back to destination URL.
-func (m *AuthMethod) logoutHandler(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func (m *AuthMethod) logoutHandler(ctx *router.Context) {
+        c, rw, r := ctx.Context, ctx.Writer, ctx.Request
+
         dest, err := normalizeURL(r.URL.Query().Get("r"))
         if err != nil {
                 replyError(c, rw, err, "Bad redirect URI (%q) - %s", dest, err)
                 return
         }
 
         // Close a session if there's one.
         sid, err := decodeSessionCookie(c, r)
         if err != nil {
                 replyError(c, rw, err, "Error when decoding session cookie - %s", err)
                 return
         }
         if sid != "" {
                 if err = m.SessionStore.CloseSession(c, sid); err != nil {
                         replyError(c, rw, err, "Error when closing the session - %s", err)
                         return
                 }
         }
 
         // Nuke all session cookies to get to a completely clean state.
         removeCookie(rw, r, sessionCookieName)
         m.removeIncompatibleCookies(rw, r)
 
         // Redirect to the final destination.
         http.Redirect(rw, r, dest, http.StatusFound)
 }
 
 // callbackHandler handles redirect from OpenID backend. Parameters contain
 // authorization code that can be exchanged for user profile.
-func (m *AuthMethod) callbackHandler(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func (m *AuthMethod) callbackHandler(ctx *router.Context) {
+        c, rw, r := ctx.Context, ctx.Writer, ctx.Request
+
         // This code path is hit when user clicks "Deny" on consent page.
         q := r.URL.Query()
         errorMsg := q.Get("error")
         if errorMsg != "" {
                 replyError(c, rw, errors.New("login error"), "OpenID login error: %s", errorMsg)
                 return
         }
 
         // Validate inputs.
         code := q.Get("code")
@@ skipping 140 matching lines @@
 // HTTP 400 on fatal errors (that can happen only on bad requests).
 func replyError(c context.Context, rw http.ResponseWriter, err error, msg string, args ...interface{}) {
         code := http.StatusBadRequest
         if errors.IsTransient(err) {
                 code = http.StatusInternalServerError
         }
         msg = fmt.Sprintf(msg, args...)
         logging.Errorf(c, "HTTP %d: %s", code, msg)
         http.Error(rw, msg, code)
 }