LogDog: Add log rendering view.

server/logdog/storage/bigtable/bigtable.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package bigtable
 
 import (
         "fmt"
 
         "github.com/luci/luci-go/common/errors"
@@ skipping 28 matching lines @@
         // getLogData retrieves rows belonging to the supplied stream record, starting
         // with the first index owned by that record. The supplied callback is invoked
         // once per retrieved row.
         //
         // rk is the starting row key.
         //
         // If the supplied limit is nonzero, no more than limit rows will be
         // retrieved.
         //
         // If keysOnly is true, then the callback will return nil row data.
-        getLogData(c context.Context, rk *rowKey, limit int, keysOnly bool, cb btGetCallback) error
+        getLogData(c context.Context, rk *rowKey, limit int64, keysOnly bool, cb btGetCallback) error
 
         // deleteRow deletes the log data associated with a given row.
         deleteRow(context.Context, *rowKey) error
 }
 
 // btTableProd is an implementation of the btTable interface that uses a real
 // production BigTable connection.
 type btTableProd struct {
         *bigtable.Table
 }
 
 func (t *btTableProd) putLogData(c context.Context, rk *rowKey, data []byte) error {
         m := bigtable.NewMutation()
         m.Set("log", "data", bigtable.ServerTime, data)
         cm := bigtable.NewCondMutation(bigtable.RowKeyFilter(rk.encode()), nil, m)
 
         rowExists := false
         err := t.Apply(c, rk.encode(), cm, bigtable.GetCondMutationResult(&rowExists))
         if err != nil {
                 return wrapTransient(err)
         }
         if rowExists {
                 return storage.ErrExists
         }
         return nil
 }
 
-func (t *btTableProd) getLogData(c context.Context, rk *rowKey, limit int, keysOnly bool, cb btGetCallback) error {
+func (t *btTableProd) getLogData(c context.Context, rk *rowKey, limit int64, keysOnly bool, cb btGetCallback) error {
         // Construct read options based on Get request.
         ropts := []bigtable.ReadOption{
                 bigtable.RowFilter(bigtable.FamilyFilter("log")),
                 bigtable.RowFilter(bigtable.ColumnFilter("data")),
                 nil,
                 nil,
         }[:2]
         if keysOnly {
                 ropts = append(ropts, bigtable.RowFilter(bigtable.StripValueFilter()))
         }
         if limit > 0 {
-                ropts = append(ropts, bigtable.LimitRows(int64(limit)))
+                ropts = append(ropts, bigtable.LimitRows(limit))
         }
 
         // This will limit the range to the immediate row key ("ASDF~INDEX") to
         // immediately after the row key ("ASDF~~"). See rowKey for more information.
         rng := bigtable.NewRange(rk.encode(), rk.pathPrefixUpperBound())
 
         innerErr := error(nil)
         err := t.ReadRows(c, rng, func(row bigtable.Row) bool {
                 data := []byte(nil)
                 if !keysOnly {
@@ skipping 74 matching lines @@
 
         // Get the specific ReadItem for our column
         colName := fmt.Sprintf("%s:%s", family, column)
         for _, item := range items {
                 if item.Column == colName {
                         return &item
                 }
         }
         return nil
 }