Milo: Add ?limit= support to builders

milo/appengine/buildbot/builder.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 (
         "encoding/json"
         "fmt"
         "sort"
@@ skipping 45 matching lines @@
                         Duration: duration,
                 },
                 Text:     b.Text,
                 Blame:    blame(b),
                 Revision: b.Sourcestamp.Revision,
         }
 }
 
 // getBuilds fetches all of the recent builds from the .  Note that
 // getBuilds() does not perform ACL checks.
-func getBuilds(c context.Context, masterName, builderName string, finished bool) ([]*resp.BuildSummary, error) {
+func getBuilds(
+        c context.Context, masterName, builderName string, finished bool, limit int) (
+        []*resp.BuildSummary, error) {
+
         // TODO(hinoka): Builder specific structs.
         result := []*resp.BuildSummary{}
         q := ds.NewQuery("buildbotBuild")
         q = q.Eq("finished", finished)
         q = q.Eq("master", masterName)
         q = q.Eq("builder", builderName)
-        q = q.Limit(25) // TODO(hinoka): This should be adjustable
+        q = q.Limit(int32(limit))
         q = q.Order("-number")
         buildbots := []*buildbotBuild{}
         err := ds.GetAll(c, q, &buildbots)
         if err != nil {
                 return nil, err
         }
         for _, b := range buildbots {
                 result = append(result, getBuildSummary(b))
         }
         return result, nil
@@ skipping 22 matching lines @@
                         results = append(results, cb)
                 }
         }
         return results
 }
 
 // builderImpl is the implementation for getting a milo builder page from buildbot.
 // This gets:
 // * Current Builds from querying the master json from the datastore.
 // * Recent Builds from a cron job that backfills the recent builds.
-func builderImpl(c context.Context, masterName, builderName string) (*resp.Builder, error) {
+func builderImpl(c context.Context, masterName, builderName string, limit int) (*resp.Builder, error) {
         result := &resp.Builder{}
         master, t, err := getMasterJSON(c, masterName)
         switch {
         case err == ds.ErrNoSuchEntity:
                 return nil, errMasterNotFound
         case err != nil:
                 return nil, err
         }
         if clock.Now(c).Sub(t) > 2*time.Minute {
                 warning := fmt.Sprintf(
@@ skipping 32 matching lines @@
                 }
                 result.PendingBuilds[i].Blame = make([]*resp.Commit, len(pb.Source.Changes))
                 for j, cm := range pb.Source.Changes {
                         result.PendingBuilds[i].Blame[j] = &resp.Commit{
                                 AuthorEmail: cm.Who,
                                 CommitURL:   cm.Revlink,
                         }
                 }
         }
 
-        recentBuilds, err := getBuilds(c, masterName, builderName, true)
+        recentBuilds, err := getBuilds(c, masterName, builderName, true, limit)
         if err != nil {
                 return nil, err
         }
         currentBuilds, err := getBuilds(c, masterName, builderName, false)
         if err != nil {
                 return nil, err
         }
         logging.Debugf(c, "Number of current builds: %d", len(currentBuilds))
         // TODO(hinoka): This works, but there's a lot of junk data from
         // masters with unclean shutdown.  Need to implement a cleanup
         // procedure of some sort. Once that is done, set:
         // result.CurrentBuilds = currentBuilds
 
         for _, fb := range recentBuilds {
                 // Yes recent builds is synonymous with finished builds.
                 // TODO(hinoka): Implement limits.
                 if fb != nil {
                         result.FinishedBuilds = append(result.FinishedBuilds, fb)
                 }
         }
         return result, nil
 }