Milo: Pending swarming builds

appengine/cmd/milo/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 107 matching lines @@
         *swarming.SwarmingRpcsTaskResult, string, error) {
 
         var log string
         var sr *swarming.SwarmingRpcsTaskResult
         var errLog, errRes error
 
         // Detour: Return debugging results, useful for development.
         if server == "debug" {
                 sr, errRes = getDebugSwarmingResult(taskID)
                 log, errLog = getDebugTaskOutput(taskID)
-                if errLog != nil {
-                        return sr, log, errLog
+        } else {
+                sc, err := getSwarmingClient(c, server)
+                if err != nil {
+                        return nil, "", err
                 }
-                return sr, log, errRes
+
+                var wg sync.WaitGroup
+                wg.Add(2) // Getting log and result can happen concurrently.  Wait for both.
+
+                go func() {
+                        defer wg.Done()
+                        log, errLog = getTaskOutput(sc, taskID)
+                }()
+                go func() {
+                        defer wg.Done()
+                        sr, errRes = getSwarmingResult(sc, taskID)
+                }()
+                wg.Wait()
         }
 
-        sc, err := getSwarmingClient(c, server)
-        if err != nil {
-                return nil, "", err
+        switch sr.State {
+        case TaskCompleted, TaskRunning, TaskCanceled:
+        default:
+                //  Ignore log errors if the task might be pending, timed out, expired, etc.
+                if errLog != nil {
+                        errLog = nil
+                        log = ""
+                }
         }
-
-        var wg sync.WaitGroup
-        wg.Add(2) // Getting log and result can happen concurrently.  Wait for both.
-
-        go func() {
-                defer wg.Done()
-                log, errLog = getTaskOutput(sc, taskID)
-        }()
-        go func() {
-                defer wg.Done()
-                sr, errRes = getSwarmingResult(sc, taskID)
-        }()
-        wg.Wait()
         if errRes != nil {
+                // Swarming result errors take priority.
                 return sr, log, errRes
         }
         return sr, log, errLog
 }
 
 func taskProperties(sr *swarming.SwarmingRpcsTaskResult) *resp.PropertyGroup {
         props := &resp.PropertyGroup{GroupName: "Swarming"}
         if len(sr.CostsUsd) == 1 {
                 props.Property = append(props.Property, &resp.Property{
                         Key:   "Cost of job (USD)",
@@ skipping 76 matching lines @@
 
         if sr.BotId != "" {
                 build.Summary.Bot = &resp.Link{
                         Label: sr.BotId,
                         URL:   botPageURL(server, sr.BotId),
                 }
         }
 
         // Build times. Swarming timestamps are UTC RFC3339Nano, but without the
         // timezone information. Make them valid RFC3339Nano.
-        build.Summary.Started = sr.StartedTs + "Z"
+        if sr.StartedTs != "" {
+                build.Summary.Started = sr.StartedTs + "Z"
+        }
         if sr.CompletedTs != "" {
                 build.Summary.Finished = sr.CompletedTs + "Z"
         }
         if sr.Duration != 0 {
                 build.Summary.Duration = uint64(sr.Duration)
         } else if sr.State == TaskRunning {
                 started, err := time.Parse(time.RFC3339, build.Summary.Started)
                 if err != nil {
                         return nil, fmt.Errorf("invalid task StartedTs: %s", err)
                 }
@@ skipping 50 matching lines @@
         }
 
         build, err := taskToBuild(c, server, sr)
         if err != nil {
                 return nil, err
         }
 
         // 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.
-        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 {
-                logdog.AddLogDogToBuild(c, URL, lds, build)
+        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 {
+                        logdog.AddLogDogToBuild(c, URL, lds, build)
+                }
         }
 
         return build, 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", resolveServer(swarmingHostname), taskID)
 }
 
 // botPageURL returns a URL to a human-consumable page of a swarming bot.
 // Supports server aliases.
 func botPageURL(swarmingHostname, botID string) string {
         return fmt.Sprintf("https://%s/restricted/bot/%s", resolveServer(swarmingHostname), botID)
 }