Milo: Handle missing / transient LogDog failures.

milo/appengine/swarming/html_data.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 swarming
 
 import (
         "encoding/json"
         "fmt"
         "io/ioutil"
@@ skipping 97 matching lines @@
         return &sr
 }
 
 func (tc *testCase) getSwarmingOutput() string {
         return string(tc.getContent(tc.swarmOutput))
 }
 
 func (tc *testCase) getAnnotation() *miloProto.Step {
         var step miloProto.Step
         data := tc.getContent(tc.annotations)
+        if len(data) == 0 {
+                return nil
+        }
+
         if err := proto.UnmarshalText(string(data), &step); err != nil {
                 panic(fmt.Errorf("failed to unmarshal text protobuf [%s]: %s", tc.annotations, err))
         }
         return &step
 }
 
 type debugSwarmingService struct {
         tc *testCase
 }
 
@@ skipping 48 matching lines @@
         err  error
 }
 
 func (tc *testLogDogClient) Tail(ctx context.Context, in *logdog.TailRequest, opts ...grpc.CallOption) (
         *logdog.GetResponse, error) {
 
         tc.req = in
         if tc.err != nil {
                 return nil, tc.err
         }
+        if tc.resp == nil {
+                return nil, coordinator.ErrNoSuchStream
+        }
         return tc.resp.(*logdog.GetResponse), nil
 }
 
 func logDogClientFunc(tc *testCase) func(context.Context, string) (*coordinator.Client, error) {
+        anno := tc.getAnnotation()
+        var resp interface{}
+        if anno != nil {
+                resp = datagramGetResponse("testproject", "foo/bar", tc.getAnnotation())
+        }
+
         return func(c context.Context, host string) (*coordinator.Client, error) {
                 return &coordinator.Client{
-                        Host: "example.com",
+                        Host: host,
                         C: &testLogDogClient{
-                                resp: datagramGetResponse("testproject", "foo/bar", tc.getAnnotation()),
+                                resp: resp,
                         },
                 }, nil
         }
 }
 
 func datagramGetResponse(project, prefix string, msg proto.Message) *logdog.GetResponse {
         data, err := proto.Marshal(msg)
         if err != nil {
                 panic(err)
         }
@@ skipping 48 matching lines @@
                 if err != nil {
                         panic(fmt.Errorf("Error while processing %s: %s", tc.name, err))
                 }
                 results = append(results, settings.TestBundle{
                         Description: tc.name,
                         Data:        templates.Args{"Build": build},
                 })
         }
         return results
 }