Milo: Pubsub pending build fixes.

milo/appengine/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"
         "compress/zlib"
@@ skipping 57 matching lines @@
         // Internal
         Internal bool
         // Data is the json serialzed and gzipped blob of the master data.
         Data []byte `gae:",noindex"`
         // Modified is when this entry was last modified.
         Modified time.Time
 }
 
 func putDSMasterJSON(
         c context.Context, master *buildbotMaster, internal bool) error {
-        // Trim pending build states.  These things are large and we can't really
-        // store more than 25 of them.  If this becomes an issue again, we'll have
-        // to trim out things from the pending build state such as the changed
-        // file list, commit comments, etc.
         for _, builder := range master.Builders {
-                if len(builder.PendingBuildStates) > 25 {
-                        builder.PendingBuildStates = builder.PendingBuildStates[0:25]
+                // Trim out extra info in the "Changes" portion of the pending build state,
+                // we don't actually need comments, files, and properties
+                for _, pbs := range builder.PendingBuildStates {
+                        for i := range pbs.Source.Changes {
+                                pbs.Source.Changes[i].Comments = ""
+                                pbs.Source.Changes[i].Files = nil
+                                pbs.Source.Changes[i].Properties = nil
+                        }
                 }
         }
         entry := buildbotMasterEntry{
                 Name:     master.Name,
                 Internal: internal,
                 Modified: clock.Now(c).UTC(),
         }
         gzbs := bytes.Buffer{}
         gsw := gzip.NewWriter(&gzbs)
         cw := iotools.CountingWriter{Writer: gsw}
@@ skipping 135 matching lines @@
                 builder, ok := master.Builders[b.Buildername]
                 if !ok {
                         // Mark this build due to builder being removed.
                         logging.Infof(c, "Expiring %s/%s/%d due to builder being removed",
                                 master.Name, b.Buildername, b.Number)
                         err = expireBuild(c, b)
                         if err != nil {
                                 logging.WithError(err).Errorf(c, "Could not expire build")
                                 return 500
                         }
+                        continue
                 }
 
                 found := false
                 for _, bnum := range builder.CurrentBuilds {
                         if b.Number == bnum {
                                 found = true
                                 break
                         }
                 }
                 if !found {
                         // Mark this build due to build not current anymore.
                         logging.Infof(c, "Expiring %s/%s/%d due to build not current",
                                 master.Name, b.Buildername, b.Number)
                         err = expireBuild(c, b)
                         if err != nil {
                                 logging.WithError(err).Errorf(c, "Could not expire build")
                                 return 500
                         }
                 }
         }
         return 0
 }
 
 // PubSubHandler is a webhook that stores the builds coming in from pubsub.
 func PubSubHandler(ctx *router.Context) {
         c, h, r := ctx.Context, ctx.Writer, ctx.Request
 
         msg := pubSubSubscription{}
         defer r.Body.Close()
+        logging.Infof(c, "Message is %d bytes long", r.ContentLength)
         dec := json.NewDecoder(r.Body)
         if err := dec.Decode(&msg); err != nil {
                 logging.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.
                 return
         }
         internal := true
         switch msg.Subscription {
         case publicSubName:
@@ skipping 22 matching lines @@
         logging.Infof(c, "There are %d builds", len(builds))
         if master != nil {
                 logging.Infof(c, "The master name is %s", master.Name)
         } else {
                 logging.Infof(c, "No master in this message")
         }
         // This is used to cache the master used for extracting OS information.
         cachedMaster := buildbotMaster{}
         // Do not use PutMulti because we might hit the 1MB limit.
         for _, build := range builds {
-                logging.Debugf(
-                        c, "Checking for build %s/%s/%d", build.Master, build.Buildername, build.Number)
                 if build.Master == "" {
                         logging.Errorf(c, "Invalid message, missing master name")
                         h.WriteHeader(200)
                         return
                 }
                 existingBuild := &buildbotBuild{
                         Master:      build.Master,
                         Buildername: build.Buildername,
                         Number:      build.Number,
                 }
                 buildExists := false
                 if err := ds.Get(c, existingBuild); err == nil {
                         if existingBuild.Finished {
                                 // Never replace a completed build.
                                 buildCounter.Add(
                                         c, 1, false, build.Master, build.Buildername, false, "Rejected")
-                                logging.Debugf(
-                                        c, "Found build %s/%s/%d and it's finished, skipping", build.Master, build.Buildername, build.Number)
                                 continue
                         }
                         buildExists = true
                 }
                 // Also set the finished and internal bit.
                 build.Finished = false
                 if len(build.Times) == 2 && build.Times[1] != nil {
                         build.Finished = true
                 }
                 build.Internal = internal
                 // Try to get the OS information on a best-effort basis.  This assumes that all
                 // builds come from one master.
                 build.OSFamily, build.OSVersion = getOSInfo(c, build, &cachedMaster)
                 err = ds.Put(c, build)
                 if err != nil {
                         if _, ok := err.(errTooBig); ok {
                                 // This will never work, we don't want PubSub to retry.
                                 logging.WithError(err).Errorf(
                                         c, "Could not save build to datastore, failing permanently")
                                 h.WriteHeader(200)
                         } else {
                                 // This is transient, we do want PubSub to retry.
                                 logging.WithError(err).Errorf(c, "Could not save build in datastore")
                                 h.WriteHeader(500)
                         }
                         return
                 }
-                logging.Debugf(
-                        c, "Saved build %s/%s/%d, it is %s",
-                        build.Master, build.Buildername, build.Number, build.Finished)
                 if buildExists {
                         buildCounter.Add(
                                 c, 1, false, build.Master, build.Buildername, build.Finished, "Replaced")
                 } else {
                         buildCounter.Add(
                                 c, 1, false, build.Master, build.Buildername, build.Finished, "New")
                 }
 
         }
         if master != nil {
                 code := doMaster(c, master, internal)
                 if code != 0 {
                         h.WriteHeader(code)
                         return
                 }
         }
         h.WriteHeader(200)
 }