Fix LogDog client queries without state.

logdog/client/coordinator/stream.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 coordinator
 
 import (
         "errors"
         "fmt"
         "time"
@@ skipping 49 matching lines @@
         // Path is the path of the log stream.
         Path types.StreamPath
 
         // Desc is the log stream's descriptor.
         Desc logpb.LogStreamDescriptor
 
         // State is the stream's current state.
         State StreamState
 }
 
-func loadLogStream(proj string, path types.StreamPath, s *logdog.LogStreamState, d *logpb.LogStreamDescriptor) (
-        *LogStream, error) {
-        switch {
-        case s == nil:
-                return nil, errors.New("missing required log state")
-        case d == nil:
-                return nil, errors.New("missing required descriptor")
-        }
-
+func loadLogStream(proj string, path types.StreamPath, s *logdog.LogStreamState, d *logpb.LogStreamDescriptor) *LogStream {
         ls := LogStream{
                 Project: cfgtypes.ProjectName(proj),
                 Path:    path,
-                Desc:    *d,
-                State: StreamState{
+        }
+        if d != nil {
+                ls.Desc = *d
+        }
+        if s != nil {
+                ls.State = StreamState{
                         Created:       google.TimeFromProto(s.Created),
                         TerminalIndex: types.MessageIndex(s.TerminalIndex),
                         Purged:        s.Purged,
-                },
+                }
+
+                if a := s.Archive; a != nil {
+                        ls.State.Archived = true
+                        ls.State.ArchiveIndexURL = a.IndexUrl
+                        ls.State.ArchiveStreamURL = a.StreamUrl
+                        ls.State.ArchiveDataURL = a.DataUrl
+                }
         }
-        if a := s.Archive; a != nil {
-                ls.State.Archived = true
-                ls.State.ArchiveIndexURL = a.IndexUrl
-                ls.State.ArchiveStreamURL = a.StreamUrl
-                ls.State.ArchiveDataURL = a.DataUrl
-        }
-        return &ls, nil
+        return &ls
 }
 
 // Stream is an interface to Coordinator stream-level commands. It is bound to
 // and operates on a single log stream path.
 type Stream struct {
         // c is the Coordinator instance that this Stream is bound to.
         c *Client
 
         // project is this stream's project.
         project cfgtypes.ProjectName
@@ skipping 13 matching lines @@
         resp, err := s.c.C.Get(ctx, &req)
         if err != nil {
                 return nil, normalizeError(err)
         }
 
         path := types.StreamPath(req.Path)
         if desc := resp.Desc; desc != nil {
                 path = desc.Path()
         }
 
-        st, err := loadLogStream(resp.Project, path, resp.State, resp.Desc)
-        if err != nil {
-                return nil, fmt.Errorf("failed to load stream state: %v", err)
-        }
-        return st, nil
+        return loadLogStream(resp.Project, path, resp.State, resp.Desc), nil
 }
 
 // Get retrieves log stream entries from the Coordinator. The supplied
 // parameters shape which entries are requested and what information is
 // returned.
 func (s *Stream) Get(ctx context.Context, params ...GetParam) ([]*logpb.LogEntry, error) {
         p := getParamsInst{
                 r: logdog.GetRequest{
                         Project: string(s.project),
                         Path:    string(s.path),
@@ skipping 169 matching lines @@
         if stateP == nil {
                 return nil
         }
 
         // The service should always return this when requested, but handle the case
         // where it doesn't for completeness.
         if resp.Desc == nil {
                 return errors.New("descriptor was not returned")
         }
 
-        ls, err := loadLogStream(resp.Project, resp.Desc.Path(), resp.State, resp.Desc)
-        if err != nil {
-                return fmt.Errorf("failed to load stream state: %v", err)
-        }
-
+        ls := loadLogStream(resp.Project, resp.Desc.Path(), resp.State, resp.Desc)
         *stateP = *ls
         return nil
 }