Archivist asserts completeness through keys scan.

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"
         "time"
 
-        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/grpcutil"
         "github.com/luci/luci-go/server/logdog/storage"
         "golang.org/x/net/context"
         "google.golang.org/cloud/bigtable"
 )
 
 const (
         logColumnFamily = "log"
 
         // The data column stores raw low row data (RecordIO blob).
@@ skipping 47 matching lines @@
         *btStorage
 }
 
 func (t *btTableProd) putLogData(c context.Context, rk *rowKey, data []byte) error {
         m := bigtable.NewMutation()
         m.Set(logColumnFamily, logColumn, bigtable.ServerTime, data)
         cm := bigtable.NewCondMutation(bigtable.RowKeyFilter(rk.encode()), nil, m)
 
         rowExists := false
         if err := t.logTable.Apply(c, rk.encode(), cm, bigtable.GetCondMutationResult(&rowExists)); err != nil {
-                return wrapTransient(err)
+                return grpcutil.WrapIfTransient(err)
         }
         if rowExists {
                 return storage.ErrExists
         }
         return nil
 }
 
 func (t *btTableProd) getLogData(c context.Context, rk *rowKey, limit int, keysOnly bool, cb btGetCallback) error {
         // Construct read options based on Get request.
         ropts := []bigtable.ReadOption{
@@ skipping 25 matching lines @@
                         innerErr = err
                         return false
                 }
 
                 if err := cb(drk, data); err != nil {
                         innerErr = err
                         return false
                 }
                 return true
         }, ropts...)
-        if err == nil {
-                err = innerErr
+        if err != nil {
+                return grpcutil.WrapIfTransient(err)
         }
-        return wrapTransient(err)
+        if innerErr != nil {
+                return innerErr
+        }
+        return nil
 }
 
 func (t *btTableProd) setMaxLogAge(c context.Context, d time.Duration) error {
         var logGCPolicy bigtable.GCPolicy
         if d > 0 {
                 logGCPolicy = bigtable.MaxAgePolicy(d)
         }
         if err := t.adminClient.SetGCPolicy(c, t.LogTable, logColumnFamily, logGCPolicy); err != nil {
-                return wrapTransient(err)
+                return grpcutil.WrapIfTransient(err)
         }
         return nil
 }
 
-// wrapTransient wraps the supplied error in an errors.TransientError if it is
-// transient.
-func wrapTransient(err error) error {
-        if isTransient(err) {
-                err = errors.WrapTransient(err)
-        }
-        return err
-}
-
-// isTransient tests if a BigTable SDK error is transient.
-//
-// Since the BigTable API doesn't give us this information, we will identify
-// transient errors by parsing their error string :(
-func isTransient(err error) bool {
-        return (err != errStop) && grpcutil.IsTransient(err)
-}
-
 // getLogRowData loads the []byte contents of the supplied log row.
 //
 // If the row doesn't exist, storage.ErrDoesNotExist will be returned.
 func getLogRowData(row bigtable.Row) (data []byte, err error) {
         items, ok := row[logColumnFamily]
         if !ok {
                 err = storage.ErrDoesNotExist
                 return
         }
 
@@ skipping 20 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
 }