Use a datastore batcher for build queries.

milo/appengine/buildbot/master.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/json"
@@ skipping 31 matching lines @@
 // User logged in, master found, master internal: nil
 // User logged in, master not found: 404
 // User logged in, master found, master internal: 404
 // Other error: 500
 func checkAccess(c context.Context, err error, internal bool) error {
         cu := auth.CurrentUser(c)
         switch {
         case err == ds.ErrNoSuchEntity:
                 if cu.Identity == identity.AnonymousIdentity {
                         return errNotAuth
-                } else {
-                        return errMasterNotFound
                 }
+                return errMasterNotFound
         case err != nil:
                 return err
         }
 
         // Do the ACL check if the entry is internal.
         if internal {
                 allowed, err := settings.IsAllowedInternal(c)
                 if err != nil {
                         return err
                 }
                 if !allowed {
                         if cu.Identity == identity.AnonymousIdentity {
                                 return errNotAuth
-                        } else {
-                                return errMasterNotFound
                         }
+                        return errMasterNotFound
                 }
         }
 
         return nil
 }
 
 // getMasterEntry feches the named master and does an ACL check on the
 // current user.
 // It returns:
 func getMasterEntry(c context.Context, name string) (*buildbotMasterEntry, error) {
@@ skipping 19 matching lines @@
 }
 
 // GetAllBuilders returns a resp.Module object containing all known masters
 // and builders.
 func GetAllBuilders(c context.Context) (*resp.Module, error) {
         result := &resp.Module{Name: "Buildbot"}
         // Fetch all Master entries from datastore
         q := ds.NewQuery("buildbotMasterEntry")
         // TODO(hinoka): Maybe don't look past like a month or so?
         entries := []*buildbotMasterEntry{}
-        err := ds.GetAll(c, q, &entries)
+        err := (&ds.Batcher{}).GetAll(c, q, &entries)
         if err != nil {
                 return nil, err
         }
 
         // Add each builder from each master entry into the result.
         // TODO(hinoka): FanInOut this?
         for _, entry := range entries {
                 if entry.Internal {
                         // Bypass the master if it's an internal master and the user is not
                         // part of the buildbot-private project.
@@ skipping 24 matching lines @@
                                 Label: bn,
                                 // Go templates escapes this for us, and also
                                 // slashes are not allowed in builder names.
                                 URL: fmt.Sprintf("/buildbot/%s/%s", entry.Name, bn),
                         })
                 }
                 result.Masters = append(result.Masters, ml)
         }
         return result, nil
 }