LogDog: Fix archival Get/Tail implementations.

logdog/common/storage/bigtable/storage_test.go

 // Copyright 2015 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 bigtable
 
 import (
         "bytes"
         "fmt"
         "strconv"
@@ skipping 131 matching lines @@
         err := t.collection().VisitItemsAscend([]byte(nil), true, func(i *gkvlite.Item) bool {
                 result[string(i.Key)] = i.Val
                 return true
         })
         if err != nil {
                 panic(err)
         }
         return result
 }
 
+func mustGetIndex(e *storage.Entry) types.MessageIndex {
+        idx, err := e.GetStreamIndex()
+        if err != nil {
+                panic(err)
+        }
+        return idx
+}
+
 func TestStorage(t *testing.T) {
         t.Parallel()
 
         Convey(`A BigTable storage instance bound to a testing BigTable instance`, t, func() {
                 bt := btTableTest{}
                 defer bt.close()
 
                 s := newBTStorage(context.Background(), Options{
                         Project:  "test-project",
                         Instance: "test-instance",
                         LogTable: "test-log-table",
                 }, nil, nil)
 
                 s.raw = &bt
                 defer s.Close()
 
                 project := config.ProjectName("test-project")
                 get := func(path string, index int, limit int, keysOnly bool) ([]string, error) {
                         req := storage.GetRequest{
                                 Project:  project,
                                 Path:     types.StreamPath(path),
                                 Index:    types.MessageIndex(index),
                                 Limit:    limit,
                                 KeysOnly: keysOnly,
                         }
                         got := []string{}
-                        err := s.Get(req, func(idx types.MessageIndex, d []byte) bool {
+                        err := s.Get(req, func(e *storage.Entry) bool {
                                 if keysOnly {
-                                        got = append(got, strconv.Itoa(int(idx)))
+                                        got = append(got, strconv.Itoa(int(mustGetIndex(e))))
                                 } else {
-                                        got = append(got, string(d))
+                                        got = append(got, string(e.D))
                                 }
                                 return true
                         })
                         return got, err
                 }
 
                 put := func(path string, index int, d ...string) error {
                         data := make([][]byte, len(d))
                         for i, v := range d {
                                 data[i] = []byte(v)
@@ skipping 127 matching lines @@
 
                                 Convey(`Will fetch B{12, 13} when index=11.`, func() {
                                         got, err := get("B", 11, 0, true)
                                         So(err, ShouldBeNil)
                                         So(got, ShouldResemble, []string{"12", "13"})
                                 })
                         })
 
                         Convey(`Testing "Tail"...`, func() {
                                 tail := func(path string) (string, error) {
-                                        got, _, err := s.Tail(project, types.StreamPath(path))
-                                        return string(got), err
+                                        e, err := s.Tail(project, types.StreamPath(path))
+                                        if err != nil {
+                                                return "", err
+                                        }
+                                        return string(e.D), nil
                                 }
 
                                 Convey(`A tail request for "A" returns A{4}.`, func() {
                                         got, err := tail("A")
                                         So(err, ShouldBeNil)
                                         So(got, ShouldEqual, "4")
                                 })
 
                                 Convey(`A tail request for "B" returns B{13}.`, func() {
                                         got, err := tail("B")
                                         So(err, ShouldBeNil)
                                         So(got, ShouldEqual, "13")
                                 })
 
                                 Convey(`A tail request for "INVALID" errors NOT FOUND.`, func() {
                                         _, err := tail("INVALID")
                                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 })
                         })
                 })
         })
 }