Milo: Prefetch logs that are failures

milo/appengine/swarming/build.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 (
         "bytes"
         "encoding/json"
         "fmt"
@@ skipping 379 matching lines @@
         }
         // If this ever has more than one stream then memoryClient needs to become
         // goroutine safe
         if err := p.RunStreams([]*annotee.Stream{&is}); err != nil {
                 return nil, err
         }
         p.Finish()
         return c.ToLogDogStreams()
 }
 
-func swarmingBuildImpl(c context.Context, linkBase, server, taskID string) (*resp.MiloBuild, error) {
+// swarmingBuildImpl fetches a swarming task from a swarming server, parses
+// the logs via Annotee, and returns a build response, along with a list of
+// URLs to prefetch.

[agable, 2016/08/18 21:44:11]

Any reason the list of urls isn't part of an "interestingURLs" parameter on the
MiloBuild object, or something like that? Maybe that wouldn't be very Go-ish, I
dunno, just figured I'd ask.

[Ryan Tseng, 2016/08/18 22:09:45]

Originally the thought was that this would manifest itself differently in the
html version and the grpc version, so an html-only hack was good enough.  After
thinking about it a little more, it makes more sense to mark each URL as
interesting or not interesting, and have the templates take care of adding the
prefetch hints.

The downside is the go template engine isn't powerful enough to stop at some
predefined number, so all failures will now be prefetched.  But that's probably
fine too, because they're hints after all.  If everything were failures, then
they're probably all interesting, and it's up to the web browser to decide
wither or not to follow those hints.

+func swarmingBuildImpl(c context.Context, linkBase, server, taskID string) (*resp.MiloBuild, []string, error) {
         // Fetch the data from Swarming
         sr, body, err := getSwarming(c, server, taskID)
         if err != nil {
-                return nil, err
+                return nil, nil, err
         }
 
         allowMilo := false
         for _, t := range sr.Tags {
                 if t == "allow_milo:1" {
                         allowMilo = true
                         break
                 }
         }
         if !allowMilo {
-                return nil, fmt.Errorf("Not A Milo Job")
+                return nil, nil, fmt.Errorf("Not A Milo Job")
         }
 
         var build resp.MiloBuild
 
         // Decode the data using annotee. The logdog stream returned here is assumed
         // to be consistent, which is why the following block of code are not
         // expected to ever err out.
         if body != "" {
                 lds, err := streamsFromAnnotatedLog(c, body)
                 if err != nil {
                         build.Components = []*resp.BuildComponent{{
                                 Type:   resp.Summary,
                                 Label:  "Milo annotation parser",
                                 Text:   []string{err.Error()},
                                 Status: resp.InfraFailure,
                                 SubLink: []*resp.Link{{
                                         Label: "swarming task",
                                         URL:   taskPageURL(server, taskID),
                                 }},
                         }}
                 } else {
                         if lds.MainStream == nil || lds.MainStream.Data == nil {
                                 panic("no main build step stream")
                         }
 
                         if err := addTaskToMiloStep(c, server, sr, lds.MainStream.Data); err != nil {
-                                return nil, err
+                                return nil, nil, err
                         }
                         logdog.AddLogDogToBuild(c, swarmingURLBuilder(linkBase), lds, &build)
                 }
         }
 
         if err := addTaskToBuild(c, server, sr, &build); err != nil {
-                return nil, err
+                return nil, nil, err
         }
 
-        return &build, nil
+        // Extract links that are failures or exceptions for prefetching.
+        prefetch := []string{}
+        for _, step := range build.Components {
+                if len(prefetch) > 3 {
+                        break // Don't prefetch more than 3 things.
+                }
+                switch step.Status {
+                case resp.Failure, resp.InfraFailure:
+                        prefetch = append(prefetch, step.MainLink.URL)
+                }
+        }
+
+        return &build, prefetch, nil
 }
 
 // taskPageURL returns a URL to a human-consumable page of a swarming task.
 // Supports server aliases.
 func taskPageURL(swarmingHostname, taskID string) string {
         return fmt.Sprintf("https://%s/user/task/%s", swarmingHostname, taskID)
 }
 
 // botPageURL returns a URL to a human-consumable page of a swarming bot.
 // Supports server aliases.
@@ skipping 35 matching lines @@
         case *miloProto.Link_Url:
                 return &resp.Link{
                         Label: l.Label,
                         URL:   t.Url,
                 }
 
         default:
                 return nil
         }
 }