Milo buildbot builder page: Add pagnation with cursors.

milo/appengine/buildbot/grpc.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"
 
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
         "github.com/golang/protobuf/ptypes/timestamp"
-        ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/iotools"
         "github.com/luci/luci-go/common/logging"
         milo "github.com/luci/luci-go/milo/api/proto"
         "github.com/luci/luci-go/server/auth"
 )
 
 // Service is a service implementation that displays BuildBot builds.
 type Service struct{}
 
 var errNotFoundGRPC = grpc.Errorf(codes.NotFound, "Master Not Found")
@@ skipping 43 matching lines @@
         if req.Builder == "" {
                 return nil, grpc.Errorf(codes.InvalidArgument, "No builder specified")
         }
 
         limit := req.Limit
         if limit == 0 {
                 limit = 20
         }
 
         cu := auth.CurrentUser(c)
-        logging.Debugf(c, "%s is requesting %s/%s (limit %d)",
-                cu.Identity, req.Master, req.Builder, limit)
+        logging.Debugf(c, "%s is requesting %s/%s (limit %d, cursor %s)",
+                cu.Identity, req.Master, req.Builder, limit, req.Cursor)
 
         // Perform an ACL check by fetching the master.
         _, err := getMasterEntry(c, req.Master)
         switch {
         case err == errMasterNotFound:
                 return nil, grpc.Errorf(codes.NotFound, "Master not found")
         case err == errNotAuth:
                 return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
         case err != nil:
                 return nil, err
         }
 
-        q := ds.NewQuery("buildbotBuild")
+        q := datastore.NewQuery("buildbotBuild")
         q = q.Eq("master", req.Master).
                 Eq("builder", req.Builder).
                 Limit(limit).
                 Order("-number")
         if req.IncludeCurrent == false {
                 q = q.Eq("finished", true)
         }
-        builds := []*buildbotBuild{}
-        err = getBuildQueryBatcher(c).GetAll(c, q, &builds)
+        // Insert the cursor or offset.
+        if req.Cursor != "" {
+                cursor, err := datastore.DecodeCursor(c, req.Cursor)
+                if err != nil {
+                        return nil, grpc.Errorf(codes.InvalidArgument, "Invalid cursor: %s", err.Error())
+                }
+                q = q.Start(cursor)
+        }
+        builds, nextCursor, err := runBuildsQuery(c, q, int32(req.Limit))
         if err != nil {
                 return nil, err
         }
 
         results := make([]*milo.BuildbotBuildJSON, len(builds))
         for i, b := range builds {
                 updatePostProcessBuild(b)
 
                 // In theory we could do this in parallel, but it doesn't actually go faster
                 // since AppEngine is single-cored.
                 bs, err := json.Marshal(b)
                 if err != nil {
                         return nil, err
                 }
                 results[i] = &milo.BuildbotBuildJSON{Data: bs}
         }
-        return &milo.BuildbotBuildsJSON{
+        buildsJSON := &milo.BuildbotBuildsJSON{
                 Builds: results,
-        }, nil
+        }
+        if nextCursor != nil {
+                buildsJSON.Cursor = (*nextCursor).String()
+        }
+        return buildsJSON, nil
 }
 
 // GetCompressedMasterJSON assembles a CompressedMasterJSON object from the
 // provided MasterRequest.
 func (s *Service) GetCompressedMasterJSON(c context.Context, req *milo.MasterRequest) (
         *milo.CompressedMasterJSON, error) {
 
         if req.Name == "" {
                 return nil, grpc.Errorf(codes.InvalidArgument, "No master specified")
         }
@@ skipping 23 matching lines @@
                 slave.Runningbuilds = make([]*buildbotBuild, 0, numBuilds)
                 for builderName, builds := range slave.RunningbuildsMap {
                         for _, buildNum := range builds {
                                 slave.Runningbuilds = append(slave.Runningbuilds, &buildbotBuild{
                                         Master:      req.Name,
                                         Buildername: builderName,
                                         Number:      buildNum,
                                 })
                         }
                 }
-                if err := ds.Get(c, slave.Runningbuilds); err != nil {
+                if err := datastore.Get(c, slave.Runningbuilds); err != nil {
                         logging.WithError(err).Errorf(c,
                                 "Encountered error while trying to fetch running builds for %s: %v",
                                 master.Name, slave.Runningbuilds)
                         return nil, err
                 }
 
                 for _, b := range slave.Runningbuilds {
                         updatePostProcessBuild(b)
                 }
         }
 
         // Also inject cached builds information.
         for builderName, builder := range master.Builders {
                 // Get the most recent 50 buildNums on the builder to simulate what the
                 // cachedBuilds field looks like from the real buildbot master json.
-                q := ds.NewQuery("buildbotBuild").
+                q := datastore.NewQuery("buildbotBuild").
                         Eq("finished", true).
                         Eq("master", req.Name).
                         Eq("builder", builderName).
                         Limit(50).
                         Order("-number").
                         KeysOnly(true)
                 var builds []*buildbotBuild
                 err := getBuildQueryBatcher(c).GetAll(c, q, &builds)
                 if err != nil {
                         return nil, err
@@ skipping 19 matching lines @@
 
         return &milo.CompressedMasterJSON{
                 Internal: entry.Internal,
                 Modified: &timestamp.Timestamp{
                         Seconds: entry.Modified.Unix(),
                         Nanos:   int32(entry.Modified.Nanosecond()),
                 },
                 Data: gzbs.Bytes(),
         }, nil
 }