Make HTTP middleware easier to use

appengine/cmd/cron/ui/job.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 ui
 
 import (
         "crypto/sha1"
         "encoding/base64"
         "fmt"
         "net/http"
         "time"
 
         "github.com/julienschmidt/httprouter"
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/memcache"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/server/auth"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/templates"
 )
 
-func jobPage(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func jobPage(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
+
         projectID := p.ByName("ProjectID")
         jobID := p.ByName("JobID")
         cursor := r.URL.Query().Get("c")
 
         // Grab the job from the datastore.
         job, err := config(c).Engine.GetCronJob(c, projectID+"/"+jobID)
         if err != nil {
                 panic(err)
         }
         if job == nil {
                 http.Error(w, "No such job", http.StatusNotFound)
+                ctx.Abort()
                 return
         }
 
         // Grab latest invocations from the datastore.
         invs, nextCursor, err := config(c).Engine.ListInvocations(c, job.JobID, 50, cursor)
         if err != nil {
                 panic(err)
         }
 
         // memcacheKey hashes cursor to reduce its length, since full cursor doesn't
@@ skipping 31 matching lines @@
                 "Job":         makeCronJob(job, now),
                 "Invocations": convertToInvocations(job.ProjectID, job.JobID, invs, now),
                 "PrevCursor":  prevCursor,
                 "NextCursor":  nextCursor,
         })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Actions.
 
-func runJobAction(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func runJobAction(ctx *router.Context) {
+        c, w, r, p := ctx.Context, ctx.Writer, ctx.Request, ctx.Params
+
         projectID := p.ByName("ProjectID")
         jobID := p.ByName("JobID")
         if !isJobOwner(c, projectID, jobID) {
                 http.Error(w, "Forbidden", 403)
+                ctx.Abort()
                 return
         }
 
         // genericReply renders "we did something (or we failed to do something)"
         // page, shown on error or if invocation is starting for too long.
         genericReply := func(err error) {
                 templates.MustRender(c, w, "pages/run_job_result.html", map[string]interface{}{
                         "ProjectID": projectID,
                         "JobID":     jobID,
                         "Error":     err,
                 })
         }
 
         // Enqueue new invocation request, and wait for corresponding invocation to
         // appear. Give up if task queue or datastore indexes are lagging too much.
         e := config(c).Engine
         fullJobID := projectID + "/" + jobID
         invNonce, err := e.TriggerInvocation(c, fullJobID, auth.CurrentIdentity(c))
         if err != nil {
                 genericReply(err)
+                ctx.Abort()
                 return
         }
 
         invID := int64(0)
         deadline := clock.Now(c).Add(10 * time.Second)
         for invID == 0 && deadline.Sub(clock.Now(c)) > 0 {
                 // Asking for invocation immediately after triggering it never works,
                 // so sleep a bit first.
                 if tr := clock.Sleep(c, 600*time.Millisecond); tr.Incomplete() {
                         // The Context was canceled before the Sleep completed. Terminate the
@@ skipping 12 matching lines @@
                 }
         }
 
         if invID != 0 {
                 http.Redirect(w, r, fmt.Sprintf("/jobs/%s/%s/%d", projectID, jobID, invID), http.StatusFound)
         } else {
                 genericReply(nil) // deadline
         }
 }
 
-func pauseJobAction(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-        handleJobAction(c, w, r, p, func(jobID string) error {
-                who := auth.CurrentIdentity(c)
-                return config(c).Engine.PauseJob(c, jobID, who)
+func pauseJobAction(c *router.Context) {
+        handleJobAction(c.Context, c.Writer, c.Request, c.Params, func(jobID string) error {
+                who := auth.CurrentIdentity(c.Context)
+                return config(c.Context).Engine.PauseJob(c.Context, jobID, who)
         })
 }
 
-func resumeJobAction(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-        handleJobAction(c, w, r, p, func(jobID string) error {
-                who := auth.CurrentIdentity(c)
-                return config(c).Engine.ResumeJob(c, jobID, who)
+func resumeJobAction(c *router.Context) {
+        handleJobAction(c.Context, c.Writer, c.Request, c.Params, func(jobID string) error {
+                who := auth.CurrentIdentity(c.Context)
+                return config(c.Context).Engine.ResumeJob(c.Context, jobID, who)
         })
 }
 
 func handleJobAction(c context.Context, w http.ResponseWriter, r *http.Request, p httprouter.Params, cb func(string) error) {
         projectID := p.ByName("ProjectID")
         jobID := p.ByName("JobID")
         if !isJobOwner(c, projectID, jobID) {
                 http.Error(w, "Forbidden", 403)
                 return
         }
         if err := cb(projectID + "/" + jobID); err != nil {
                 panic(err)
         }
         http.Redirect(w, r, fmt.Sprintf("/jobs/%s/%s", projectID, jobID), http.StatusFound)
 }