gitiles.Log: implement paging.

milo/git/history.go

 // Copyright 2017 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package git
 
 import (
         "bytes"
         "compress/gzip"
         "encoding/hex"
         "fmt"
         "io/ioutil"
+        "net/http"
         "regexp"
 
         "golang.org/x/net/context"
 
         "github.com/golang/protobuf/proto"
 
         "github.com/luci/gae/service/memcache"
 
         "github.com/luci/luci-go/common/api/gitiles"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
+        "github.com/luci/luci-go/server/auth"
 
         milo "github.com/luci/luci-go/milo/api/proto"
 )
 
 var gitHash = regexp.MustCompile("[0-9a-fA-F]{40}")
 
 // Resolve resolves a commitish to a git commit hash.
 //
 // This operation will assumed to be either fully local (in the case that
 // commitish is already a git-hash-looking-thing), or local to the datastore (in
@@ skipping 99 matching lines @@
 // the given url, commitish and limit.
 func GetHistory(c context.Context, url, commitish string, limit int) (*milo.ConsoleGitInfo, error) {
         commitish, useCache, err := Resolve(c, url, commitish)
         if err != nil {
                 return nil, errors.Annotate(err, "resolving %q", commitish).Err()
         }
 
         ret := &milo.ConsoleGitInfo{}
         cacheKey := fmt.Sprintf("GetHistory|%s|%s|%d", url, commitish, limit)
         err = protoCache(c, useCache, cacheKey, ret, func() error {
-                rawEntries, err := gitiles.Log(c, url, commitish, limit)
+                t, err := auth.GetRPCTransport(c, auth.AsSelf, auth.WithScopes(
+                        "https://www.googleapis.com/auth/gerritcodereview",
+                ))
+                if err != nil {
+                        return errors.Annotate(err, "getting RPC Transport").Err()
+                }
+                g := &gitiles.Client{Client: &http.Client{Transport: t}}
+                rawEntries, err := g.Log(c, url, commitish, limit)
                 if err != nil {
                         return errors.Annotate(err, "GetHistory").Err()
                 }
 
                 ret.Commits = make([]*milo.ConsoleGitInfo_Commit, len(rawEntries))
 
                 for i, e := range rawEntries {
                         commit := &milo.ConsoleGitInfo_Commit{}
                         if commit.Hash, err = hex.DecodeString(e.Commit); err != nil {
                                 return errors.Annotate(err, "commit is not hex (%q)", e.Commit).Err()
                         }
 
                         commit.AuthorName = e.Author.Name
                         commit.AuthorEmail = e.Author.Email
 
                         ts, err := e.Committer.GetTime()
                         if err != nil {
                                 return errors.Annotate(err, "commit time unparsible (%q)", e.Committer.Time).Err()
                         }
 
                         commit.CommitTime = google.NewTimestamp(ts)
                         commit.Msg = e.Message
 
                         ret.Commits[i] = commit
                 }
                 return nil
         })
         return ret, err
 }