appengine, crimson: Use updated router API

go/src/infra/appengine/sheriff-o-matic/main.go

 // Copyright 2016 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 som implements HTTP server that handles requests to default module.
 package som
 
 import (
         "crypto/sha1"
         "encoding/json"
         "fmt"
         "html/template"
         "infra/monorail"
         "io/ioutil"
         "net/http"
         "strings"
 
-        "github.com/julienschmidt/httprouter"
         "golang.org/x/net/context"
         "google.golang.org/appengine"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/urlfetch"
         "github.com/luci/luci-go/appengine/gaeauth/client"
         "github.com/luci/luci-go/appengine/gaeauth/server"
         "github.com/luci/luci-go/appengine/gaemiddleware"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/identity"
-        "github.com/luci/luci-go/server/middleware"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/settings"
 )
 
 const authGroup = "sheriff-o-matic-access"
 
 var (
         mainPage         = template.Must(template.ParseFiles("./index.html"))
         accessDeniedPage = template.Must(template.ParseFiles("./access-denied.html"))
         monorailEndpoint = "https://monorail-prod.appspot.com/_ah/api/monorail/v1/"
 )
@@ skipping 127 matching lines @@
         if alertStreams, ok := values["AlertStreams"]; ok && alertStreams != "" {
                 if err := writeAlertStreams(c, alertStreams); err != nil {
                         return err
                 }
         }
 
         return nil
 }
 
 //// Handlers.
-func indexPage(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func indexPage(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
         if p.ByName("path") == "" {
                 http.Redirect(w, r, "/chromium", http.StatusFound)
                 return
         }
 
         user := auth.CurrentIdentity(c)
 
         if user.Kind() == identity.Anonymous {
                 url, err := auth.LoginURL(c, "/")
                 if err != nil {
@@ skipping 35 matching lines @@
                 "User":      user.Email(),
                 "LogoutUrl": logoutURL,
         }
 
         err = mainPage.Execute(w, data)
         if err != nil {
                 logging.Errorf(c, "while rendering index: %s", err)
         }
 }
 
-func getTreesHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func getTreesHandler(ctx *router.Context) {
+        c, w := ctx.Context, ctx.Writer
+
         if !requireGoogler(w, c) {
                 return
         }
 
         q := datastore.NewQuery("Tree")
         results := []*Tree{}
         err := datastore.Get(c).GetAll(q, &results)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         txt, err := json.Marshal(results)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         w.Header().Set("Content-Type", "application/json")
         w.Write(txt)
 }
 
-func getAlertsHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func getAlertsHandler(ctx *router.Context) {
+        c, w, p := ctx.Context, ctx.Writer, ctx.Params
+
         if !requireGoogler(w, c) {
                 return
         }
 
         ds := datastore.Get(c)
 
         tree := p.ByName("tree")
         q := datastore.NewQuery("AlertsJSON")
         q = q.Ancestor(ds.MakeKey("Tree", tree))
         q = q.Order("-Date")
@@ skipping 10 matching lines @@
                 logging.Warningf(c, "No alerts found for tree %s", tree)
                 errStatus(w, http.StatusNotFound, fmt.Sprintf("Tree \"%s\" not found", tree))
                 return
         }
 
         alertsJSON := results[0]
         w.Header().Set("Content-Type", "application/json")
         w.Write(alertsJSON.Contents)
 }
 
-func postAlertsHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func postAlertsHandler(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
+
         if !requireGoogler(w, c) {
                 return
         }
 
         tree := p.ByName("tree")
         ds := datastore.Get(c)
 
         alerts := AlertsJSON{
                 Tree: ds.MakeKey("Tree", tree),
                 Date: clock.Now(c),
@@ skipping 26 matching lines @@
         }
 
         alerts.Contents = data
         err = datastore.Get(c).Put(&alerts)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 }
 
-func getAnnotationsHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func getAnnotationsHandler(ctx *router.Context) {
+        c, w := ctx.Context, ctx.Writer
+
         if !requireGoogler(w, c) {
                 return
         }
 
         q := datastore.NewQuery("Annotation")
         results := []*Annotation{}
         datastore.Get(c).GetAll(q, &results)
 
         data, err := json.Marshal(results)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         w.Header().Set("Content-Type", "application/json")
         w.Write(data)
 }
 
-func postAnnotationsHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func postAnnotationsHandler(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
+
         if !requireGoogler(w, c) {
                 return
         }
 
         annKey := p.ByName("annKey")
         action := p.ByName("action")
         ds := datastore.Get(c)
 
         if !(action == "add" || action == "remove") {
                 errStatus(w, http.StatusNotFound, "Invalid action")
@@ skipping 38 matching lines @@
         data, err := json.Marshal(annotation)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         w.Header().Set("Content-Type", "application/json")
         w.Write(data)
 }
 
-func getBugQueueHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func getBugQueueHandler(ctx *router.Context) {
+        c, w, p := ctx.Context, ctx.Writer, ctx.Params
+
         c = client.UseServiceAccountTransport(c, nil, nil)
         mr := monorail.NewEndpointsClient(&http.Client{Transport: urlfetch.Get(c)}, monorailEndpoint)
         tree := p.ByName("tree")
 
         // TODO(martiniss): make this look up request info based on Tree datastore
         // object
         req := &monorail.IssuesListRequest{
                 ProjectId: tree,
                 Can:       monorail.IssuesListRequest_OPEN,
                 Q:         fmt.Sprintf("label:Sheriff-%s", tree),
@@ skipping 33 matching lines @@
 
         m := map[string]string{}
         err = json.Unmarshal(body, &m)
         if err != nil {
                 return nil, err
         }
 
         return m, nil
 }
 
-func getRevRangeHandler(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func getRevRangeHandler(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
+
         start := p.ByName("start")
         end := p.ByName("end")
         if start == "" || end == "" {
                 errStatus(w, http.StatusBadRequest, "Start and end parameters must be set.")
                 return
         }
 
         startRev, err := getCrRevJSON(c, start)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         endRev, err := getCrRevJSON(c, end)
         if err != nil {
                 errStatus(w, http.StatusInternalServerError, err.Error())
                 return
         }
 
         // TODO(seanmccullough): some sanity checking of the rev json (same repo etc)
 
         gitilesURL := fmt.Sprintf("https://chromium.googlesource.com/chromium/src/+log/%s^..%s?format=JSON",
                 startRev["git_sha"], endRev["git_sha"])
 
         http.Redirect(w, r, gitilesURL, 301)
 }
 
 // base is the root of the middleware chain.
-func base(h middleware.Handler) httprouter.Handle {
+func base() router.MiddlewareChain {
         methods := auth.Authenticator{
                 &server.OAuth2Method{Scopes: []string{server.EmailScope}},
                 server.CookieAuth,
                 &server.InboundAppIDAuthMethod{},
         }
-        h = auth.Use(h, methods)
-        if !appengine.IsDevAppServer() {
-                h = middleware.WithPanicCatcher(h)
-        }
-        return gaemiddleware.BaseProd(h)
+        return append(
+                gaemiddleware.BaseProd(),
+                auth.Use(methods),
+        )
 }
 
 //// Routes.
 func init() {
         settings.RegisterUIPage(settingsKey, settingsUIPage{})
 
-        router := httprouter.New()
-        gaemiddleware.InstallHandlers(router, base)
-        router.GET("/api/v1/trees/", base(auth.Authenticate(getTreesHandler)))
-        router.GET("/api/v1/alerts/:tree", base(auth.Authenticate(getAlertsHandler)))
-        router.POST("/api/v1/alerts/:tree", base(auth.Authenticate(postAlertsHandler)))
-        router.GET("/api/v1/annotations/", base(auth.Authenticate(getAnnotationsHandler)))
-        router.POST("/api/v1/annotations/:annKey/:action", base(auth.Authenticate(postAnnotationsHandler)))
-        router.GET("/api/v1/bugqueue/:tree", base(auth.Authenticate(getBugQueueHandler)))
-        router.GET("/api/v1/revrange/:start/:end", base(getRevRangeHandler))
+        r := router.New()
+        basemw := base()
+        authmw := append(basemw, auth.Authenticate)
 
-        rootRouter := httprouter.New()
-        rootRouter.GET("/*path", base(auth.Authenticate(indexPage)))
+        gaemiddleware.InstallHandlers(r, basemw)
+        r.GET("/api/v1/trees/", authmw, getTreesHandler)
+        r.GET("/api/v1/alerts/:tree", authmw, getAlertsHandler)
+        r.POST("/api/v1/alerts/:tree", authmw, postAlertsHandler)
+        r.GET("/api/v1/annotations/", authmw, getAnnotationsHandler)
+        r.POST("/api/v1/annotations/:annKey/:action", authmw, postAnnotationsHandler)
+        r.GET("/api/v1/bugqueue/:tree", authmw, getBugQueueHandler)
+        r.GET("/api/v1/revrange/:start/:end", basemw, getRevRangeHandler)
 
-        http.DefaultServeMux.Handle("/api/", router)
-        http.DefaultServeMux.Handle("/admin/", router)
-        http.DefaultServeMux.Handle("/auth/", router)
-        http.DefaultServeMux.Handle("/_ah/", router)
+        rootRouter := router.New()
+        rootRouter.GET("/*path", authmw, indexPage)
+
+        http.DefaultServeMux.Handle("/api/", r)
+        http.DefaultServeMux.Handle("/admin/", r)
+        http.DefaultServeMux.Handle("/auth/", r)
+        http.DefaultServeMux.Handle("/_ah/", r)
         http.DefaultServeMux.Handle("/", rootRouter)
 }