LogDog: Fix archival Get/Tail implementations.

logdog/common/storage/archive/logdog_archive_test/main.go

 // Copyright 2016 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 main implements a simple CLI tool to load and interact with Google
 // Storage archived data.
 package main
 
 import (
         "bytes"
@@ skipping 157 matching lines @@
 
         var index logpb.LogIndex
         if err := unmarshalAndDump(c, os.Stdout, data, &index); err != nil {
                 log.WithError(err).Errorf(c, "Failed to dump index protobuf.")
                 return 1
         }
         return 0
 }
 
 func unmarshalAndDump(c context.Context, out io.Writer, data []byte, msg proto.Message) error {
-        if err := proto.Unmarshal(data, msg); err != nil {
-                log.WithError(err).Errorf(c, "Failed to unmarshal protobuf.")
-                return err
+        if data != nil {
+                if err := proto.Unmarshal(data, msg); err != nil {
+                        log.WithError(err).Errorf(c, "Failed to unmarshal protobuf.")
+                        return err
+                }
         }
+
         if err := proto.MarshalText(out, msg); err != nil {
                 log.WithError(err).Errorf(c, "Failed to dump protobuf to output.")
                 return err
         }
         return nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Subcommand: dump-stream
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 148 matching lines @@
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create storage client.")
                 return 1
         }
         defer stClient.Close()
 
         var innerErr error
         err = stClient.Get(storage.GetRequest{
                 Index: types.MessageIndex(cmd.index),
                 Limit: cmd.limit,
-        }, func(idx types.MessageIndex, data []byte) bool {
+        }, func(e *storage.Entry) bool {
+                le, err := e.GetLogEntry()
+                if err != nil {
+                        log.WithError(err).Errorf(c, "Failed to unmarshal log entry.")
+                        return false
+                }
+
                 log.Fields{
-                        "index": idx,
+                        "index": le.StreamIndex,
                 }.Infof(c, "Fetched log entry.")
 
-                var log logpb.LogEntry
-                if innerErr = unmarshalAndDump(c, os.Stdout, data, &log); innerErr != nil {
+                if innerErr = unmarshalAndDump(c, os.Stdout, nil, le); innerErr != nil {
                         return false
                 }
                 return true
         })
         switch {
         case innerErr != nil:
                 log.WithError(innerErr).Errorf(c, "Failed to process fetched log entries.")
                 return 1
 
         case err != nil:
@@ skipping 52 matching lines @@
                 IndexURL:  cmd.indexPath,
                 StreamURL: cmd.streamPath,
                 Client:    client,
         })
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create storage client.")
                 return 1
         }
         defer stClient.Close()
 
-        data, idx, err := stClient.Tail("", "")
+        e, err := stClient.Tail("", "")
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to Tail log entries.")
                 return 1
         }
 
-        if data == nil {
+        if e == nil {
                 log.Infof(c, "No log data to tail.")
                 return 0
         }
 
+        le, err := e.GetLogEntry()
+        if err != nil {
+                log.WithError(err).Errorf(c, "Failed to unmarshal log entry.")
+                return 1
+        }
+
         log.Fields{
-                "index": idx,
-                "size":  len(data),
+                "index": le.StreamIndex,
+                "size":  len(e.D),
         }.Debugf(c, "Dumping tail entry.")
-        var entry logpb.LogEntry
-        if err := unmarshalAndDump(c, os.Stdout, data, &entry); err != nil {
+        if err := unmarshalAndDump(c, os.Stdout, nil, le); err != nil {
                 log.WithError(err).Errorf(c, "Failed to dump tail entry.")
                 return 1
         }
         return 0
 }