LogDog: Fix archival Get/Tail implementations.

logdog/common/storage/memory/memory.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 memory
 
 import (
         "errors"
         "sync"
         "time"
@@ skipping 114 matching lines @@
 
         // Punt all of the records upstream. We copy the data to prevent the
         // callback from accidentally mutating it. We reuse the data buffer to try
         // and catch errors when the callback retains the data.
         for _, r := range recs {
                 var dataCopy []byte
                 if !req.KeysOnly {
                         dataCopy = make([]byte, len(r.data))
                         copy(dataCopy, r.data)
                 }
-                if !cb(r.index, dataCopy) {
+                if !cb(storage.MakeEntry(dataCopy, r.index)) {
                         break
                 }
         }
 
         return nil
 }
 
 // Tail implements storage.Storage.
-func (s *Storage) Tail(project config.ProjectName, path types.StreamPath) ([]byte, types.MessageIndex, error) {
+func (s *Storage) Tail(project config.ProjectName, path types.StreamPath) (*storage.Entry, error) {
         var r *rec
 
         // Find the latest log, then return it.
         err := s.run(func() error {
                 ls := s.getLogStreamLocked(project, path, false)
                 if ls == nil {
                         return storage.ErrDoesNotExist
                 }
 
                 r = &rec{
                         index: ls.latestIndex,
                         data:  ls.logs[ls.latestIndex],
                 }
                 return nil
         })
         if err != nil {
-                return nil, 0, err
+                return nil, err
         }
-        return r.data, r.index, nil
+        return storage.MakeEntry(r.data, r.index), nil
 }
 
 // Count returns the number of log records for the given stream.
 func (s *Storage) Count(project config.ProjectName, path types.StreamPath) (c int) {
         s.run(func() error {
                 if st := s.getLogStreamLocked(project, path, false); st != nil {
                         c = len(st.logs)
                 }
                 return nil
         })
@@ skipping 35 matching lines @@
                 }
 
                 if s.streams == nil {
                         s.streams = map[streamKey]*logStream{}
                 }
                 s.streams[key] = ls
         }
 
         return ls
 }