Milo: Add task expired as a failure status

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 264 matching lines @@
 
         switch sr.State {
         case TaskRunning:
                 step.Status = miloProto.Status_RUNNING
 
         case TaskPending:
                 step.Status = miloProto.Status_PENDING
 
         case TaskExpired, TaskTimedOut, TaskBotDied:
                 step.Status = miloProto.Status_FAILURE
-                step.FailureDetails = &miloProto.FailureDetails{
-                        Type: miloProto.FailureDetails_INFRA,
-                }
 
                 switch sr.State {
                 case TaskExpired:
-                        step.FailureDetails.Text = "Task expired"
+                        step.FailureDetails = &miloProto.FailureDetails{
+                                Type: miloProto.FailureDetails_EXPIRED,
+                                Text: "Task expired",
+                        }
                 case TaskTimedOut:
-                        step.FailureDetails.Text = "Task timed out"
+                        step.FailureDetails = &miloProto.FailureDetails{
+                                Type: miloProto.FailureDetails_INFRA,
+                                Text: "Task timed out",
+                        }
                 case TaskBotDied:
-                        step.FailureDetails.Text = "Bot died"
+                        step.FailureDetails = &miloProto.FailureDetails{
+                                Type: miloProto.FailureDetails_INFRA,
+                                Text: "Bot died",
+                        }
                 }
 
         case TaskCanceled:
                 // Cancelled build is user action, so it is not an infra failure.
                 step.Status = miloProto.Status_FAILURE
                 step.FailureDetails = &miloProto.FailureDetails{
                         Type: miloProto.FailureDetails_CANCELLED,
                         Text: "Task cancelled by user",
                 }
 
@@ skipping 103 matching lines @@
                 if t == "allow_milo:1" {
                         allowMilo = true
                         break
                 }
         }
         if !allowMilo {
                 return nil, fmt.Errorf("Not A Milo Job")
         }
 
         var build resp.MiloBuild
+        var s *miloProto.Step
+        var lds *logdog.Streams
 
         // 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)
+                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
-                        }
-                        logdog.AddLogDogToBuild(c, swarmingURLBuilder(linkBase), lds, &build)
                 }
         }
 
+        if lds != nil && lds.MainStream != nil && lds.MainStream.Data != nil {
+                s = lds.MainStream.Data
+        } else {
+                s = &miloProto.Step{}
+        }
+
+        if err := addTaskToMiloStep(c, server, sr, s); err != nil {
+                return nil, err
+        }
+        logdog.AddLogDogToBuild(c, swarmingURLBuilder(linkBase), s, &build)
+
         if err := addTaskToBuild(c, server, sr, &build); err != nil {
                 return nil, err
         }
 
         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 {
@@ skipping 40 matching lines @@
         case *miloProto.Link_Url:
                 return &resp.Link{
                         Label: l.Label,
                         URL:   t.Url,
                 }
 
         default:
                 return nil
         }
 }