Make HTTP middleware easier to use

appengine/cmd/milo/buildbot/pubsub.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 buildbot
 
 import (
         "bytes"
         "compress/gzip"
         "encoding/base64"
         "encoding/json"
-        "net/http"
         "time"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/iotools"
         log "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/server/router"
 
-        "github.com/julienschmidt/httprouter"
         "golang.org/x/net/context"
 )
 
 var (
         // subName is the name of the pubsub subscription that milo is expecting.
         // TODO(hinoka): This should be read from luci-config.
         subName = "projects/luci-milo/subscriptions/buildbot-public"
 )
 
 type pubSubMessage struct {
@@ skipping 101 matching lines @@
                         bm.Builds = append(bm.Builds, build)
                         slave.RunningbuildsMap[build.Buildername] = append(
                                 slave.RunningbuildsMap[build.Buildername], build.Number)
                 }
                 slave.Runningbuilds = nil
         }
         return bm.Builds, bm.Master, nil
 }
 
 // PubSubHandler is a webhook that stores the builds coming in from pubsub.
-func PubSubHandler(
-        c context.Context, h http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func PubSubHandler(ctx *router.Context) {
+        c, h, r := ctx.Context, ctx.Writer, ctx.Request
+        defer r.Body.Close()
         msg := pubSubSubscription{}
-        defer r.Body.Close()
         dec := json.NewDecoder(r.Body)
         if err := dec.Decode(&msg); err != nil {
                 log.WithError(err).Errorf(
                         c, "Could not decode message.  %s", err)
                 h.WriteHeader(200) // This is a hard failure, we don't want PubSub to retry.
+                ctx.Abort()
                 return
         }
         if msg.Subscription != subName {
                 log.Errorf(
                         c, "Subscription name %s does not match %s", msg.Subscription, subName)
                 h.WriteHeader(200)
+                ctx.Abort()
                 return
         }
         bbMsg, err := msg.GetData()
         if err != nil {
                 log.WithError(err).Errorf(c, "Could not decode message %s", err)
                 h.WriteHeader(200)
+                ctx.Abort()
                 return
         }
         builds, master, err := unmarshal(c, bbMsg)
         if err != nil {
                 log.WithError(err).Errorf(c, "Could not unmarshal message %s", err)
                 h.WriteHeader(200)
+                ctx.Abort()
                 return
         }
         log.Infof(c, "There are %d builds and master %s", len(builds), master.Name)
         ds := datastore.Get(c)
         // Do not use PutMulti because we might hit the 1MB limit.
         for _, build := range builds {
                 log.Debugf(
                         c, "Checking for build %s/%s/%d", build.Master, build.Buildername, build.Number)
                 if build.Master == "" {
                         log.Errorf(c, "Invalid message, missing master name")
                         h.WriteHeader(200)
+                        ctx.Abort()
                         return
                 }
                 existingBuild := &buildbotBuild{
                         Master:      build.Master,
                         Buildername: build.Buildername,
                         Number:      build.Number,
                 }
                 if err := ds.Get(existingBuild); err == nil {
                         if existingBuild.Times[1] != nil && build.Times[1] == nil {
                                 // Never replace a completed build with a pending build.
                                 continue
                         }
                 }
                 err = ds.Put(&build)
                 if err != nil {
                         log.WithError(err).Errorf(c, "Could not save build in datastore %s", err)
                         // This is transient, we do want PubSub to retry.
                         h.WriteHeader(500)
+                        ctx.Abort()
                         return
                 }
         }
         if master != nil {
                 // TODO(hinoka): Internal builds.
                 err = putDSMasterJSON(c, master, false)
                 if err != nil {
                         log.WithError(err).Errorf(
                                 c, "Could not save master in datastore %s", err)
                         // This is transient, we do want PubSub to retry.
                         h.WriteHeader(500)
+                        ctx.Abort()
                         return
                 }
         }
         h.WriteHeader(200)

[iannucci, 2016/06/13 19:23:28]

missed one?

 }