[som] Add bugqueue handler to fetch Sheriff-* issues from monorail.

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/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/"
 )
 
 var errStatus = func(w http.ResponseWriter, status int, msg string) {
         w.WriteHeader(status)
         w.Write([]byte(msg))
 }
 
 var requireGoogler = func(w http.ResponseWriter, c context.Context) bool {
         if appengine.IsDevAppServer() {
                 return true
@@ skipping 315 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) {
+        c = client.UseServiceAccountTransport(c, nil, nil)
+        mr := monorail.NewEndpointsClient(&http.Client{Transport: urlfetch.Get(c)}, monorailEndpoint)
+        tree := p.ByName("tree")
+        req := &monorail.IssuesListRequest{
+                ProjectId: tree,
+                Can:       monorail.IssuesListRequest_OPEN,
+                Q:         fmt.Sprintf("label:Sheriff-%s", tree),
+        }
+
+        res, err := mr.IssuesList(c, req)
+        if err != nil {
+                errStatus(w, http.StatusInternalServerError, err.Error())
+                return
+        }
+
+        bytes, err := json.Marshal(res)
+        if err != nil {
+                errStatus(w, http.StatusInternalServerError, err.Error())
+                return
+        }
+
+        w.Header().Set("Content-Type", "application/json")
+        w.Write(bytes)
+}
+
 // base is the root of the middleware chain.
 func base(h middleware.Handler) httprouter.Handle {
         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)
 }
 
 //// 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)))
 
         rootRouter := httprouter.New()
         rootRouter.GET("/*path", base(auth.Authenticate(indexPage)))
 
         http.DefaultServeMux.Handle("/api/", router)
         http.DefaultServeMux.Handle("/admin/", router)
         http.DefaultServeMux.Handle("/auth/", router)
         http.DefaultServeMux.Handle("/_ah/", router)
         http.DefaultServeMux.Handle("/", rootRouter)
 }