LogDog: BigTable batching schema.

appengine/logdog/coordinator/endpoints/logs/get_test.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 logs
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 237 matching lines @@
                 } {
                         is := "is"
                         if !v {
                                 is += " not"
                         }
 
                         Convey(fmt.Sprintf(`When the log %s archived`, is), func() {
                                 if !v {
                                         // Add the logs to the in-memory temporary storage.
                                         for _, le := range entries {
-                                                err := ms.Put(&storage.PutRequest{
-                                                        Path:  ls.Path(),
-                                                        Index: types.MessageIndex(le.StreamIndex),
-                                                        Value: protobufs[le.StreamIndex],
+                                                err := ms.Put(storage.PutRequest{
+                                                        Path:   ls.Path(),
+                                                        Index:  types.MessageIndex(le.StreamIndex),
+                                                        Values: [][]byte{protobufs[le.StreamIndex]},
                                                 })
                                                 if err != nil {
                                                         panic(fmt.Errorf("failed to Put() LogEntry: %v", err))
                                                 }
                                         }
                                 } else {
                                         // Archive this log stream. We will generate one index entry for every
                                         // 2 log entries.
                                         src := staticArchiveSource(entries)
                                         var lbuf, ibuf bytes.Buffer
@@ skipping 162 matching lines @@
                                         })
 
                                         Convey(`Will return Internal if the protobuf log entry data is corrupt.`, func() {
                                                 if v {
                                                         // Corrupt the archive datastream.
                                                         stream := gsc.get("testbucket", "stream")
                                                         zeroRecords(stream)
                                                 } else {
                                                         // Add corrupted entry to Storage. Create a new entry here, since
                                                         // the storage will reject a duplicate/overwrite.
-                                                        err := ms.Put(&storage.PutRequest{
-                                                                Path:  types.StreamPath(req.Path),
-                                                                Index: 666,
-                                                                Value: []byte{0x00}, // Invalid protobuf, zero tag.
+                                                        err := ms.Put(storage.PutRequest{
+                                                                Path:   types.StreamPath(req.Path),
+                                                                Index:  666,
+                                                                Values: [][]byte{{0x00}}, // Invalid protobuf, zero tag.
                                                         })
                                                         if err != nil {
                                                                 panic(err)
                                                         }
                                                         req.Index = 666
                                                 }
 
                                                 _, err := s.Get(c, &req)
                                                 So(err, ShouldBeRPCInternal)
                                         })
@@ skipping 111 matching lines @@
                                                 resp, err := s.Tail(c, &req)
                                                 So(err, ShouldBeRPCOK)
                                                 So(resp, shouldHaveLogs, 7)
                                                 So(resp.State, ShouldResemble, loadLogStreamState(ls))
                                         })
                                 })
                         })
                 }
         })
 }