milo: source and bot links

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"
         "io/ioutil"
         "path/filepath"
         "strings"
         "sync"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/appengine/cmd/milo/logdog"
         "github.com/luci/luci-go/appengine/cmd/milo/resp"
         "github.com/luci/luci-go/appengine/gaeauth/client"
         "github.com/luci/luci-go/client/logdog/annotee"
         swarming "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logdog/types"
-        "github.com/luci/luci-go/common/logging"
-        miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/common/transport"
 )
 
 // Swarming task states..
 const (
         // TaskRunning means task is running.
         TaskRunning = "RUNNING"
         // TaskPending means task didn't start yet.
         TaskPending = "PENDING"
         // TaskExpired means task expired and did not start.
         TaskExpired = "EXPIRED"
         // TaskTimedOut means task started, but took too long.
         TaskTimedOut = "TIMED_OUT"
         // TaskBotDied means task started but bot died.
         TaskBotDied = "BOT_DIED"
         // TaskCanceled means the task was canceled. See CompletedTs to determine whether it was started.
         TaskCanceled = "CANCELED"
         // TaskCompleted means task is complete.
         TaskCompleted = "COMPLETED"
 )
 
 func resolveServer(server string) string {
         // TODO(hinoka): configure this map in luci-config
-        if server == "" || server == "default" || server == "dev" {
+        switch server {
+        case "", "default", "dev":
                 return "chromium-swarm-dev.appspot.com"
-        } else if server == "prod" {
+
+        case "prod":
                 return "chromium-swarm.appspot.com"
-        } else {
+
+        default:
                 return server
         }
 }
 
 func getSwarmingClient(c context.Context, server string) (*swarming.Service, error) {
         c, _ = context.WithTimeout(c, 60*time.Second)
         client := transport.GetClient(client.UseServiceAccountTransport(
                 c, []string{"https://www.googleapis.com/auth/userinfo.email"}, nil))
         sc, err := swarming.New(client)
         if err != nil {
@@ skipping 80 matching lines @@
                 defer wg.Done()
                 sr, errRes = getSwarmingResult(sc, taskID)
         }()
         wg.Wait()
         if errRes != nil {
                 return sr, log, errRes
         }
         return sr, log, errLog
 }
 
-// TODO(hinoka): This should go in a more generic file, when milo has more
-// than one page.
-func getNavi(taskID string, URL string) *resp.Navigation {
-        navi := &resp.Navigation{}
-        navi.PageTitle = &resp.Link{
-                Label: taskID,
-                URL:   URL,
-        }
-        navi.SiteTitle = &resp.Link{
-                Label: "Milo",
-                URL:   "/",
-        }
-        return navi
-}
-
-// Given a logdog/milo step, translate it to a BuildComponent struct.
-func miloBuildStep(
-        c context.Context, url string, anno *miloProto.Step, name string) *resp.BuildComponent {
-        url = strings.TrimSuffix(url, "/")
-        comp := &resp.BuildComponent{}
-        asc := anno.GetStepComponent()
-        comp.Label = asc.Name
-        switch asc.Status {
-        case miloProto.Status_RUNNING:
-                comp.Status = resp.Running
-
-        case miloProto.Status_SUCCESS:
-                comp.Status = resp.Success
-
-        case miloProto.Status_FAILURE:
-                if anno.GetFailureDetails() != nil {
-                        switch anno.GetFailureDetails().Type {
-                        case miloProto.FailureDetails_INFRA:
-                                comp.Status = resp.InfraFailure
-
-                        case miloProto.FailureDetails_DM_DEPENDENCY_FAILED:
-                                comp.Status = resp.DependencyFailure
-
-                        default:
-                                comp.Status = resp.Failure
-                        }
-                } else {
-                        comp.Status = resp.Failure
-                }
-
-        case miloProto.Status_EXCEPTION:
-                comp.Status = resp.InfraFailure
-
-                // Missing the case of waiting on unfinished dependency...
-        default:
-                comp.Status = resp.NotRun
-        }
-        // Sub link is for one link per log that isn't stdio.
-        for _, link := range asc.GetOtherLinks() {
-                lds := link.GetLogdogStream()
-                if lds == nil {
-                        logging.Warningf(c, "Warning: %v of %v has an empty logdog stream.", link, asc)
-                        continue // DNE???
-                }
-                shortName := lds.Name[5 : len(lds.Name)-2]
-                if strings.HasSuffix(lds.Name, "annotations") || strings.HasSuffix(lds.Name, "stdio") {
-                        // Skip the special ones.
-                        continue
-                }
-                newLink := &resp.Link{
-                        Label: shortName,
-                        URL:   url + "/" + lds.Name,
-                }
-                comp.SubLink = append(comp.SubLink, newLink)
-        }
-
-        // Main link is a link to the stdio.
-        comp.MainLink = &resp.Link{
-                Label: "stdio",
-                URL:   strings.Join([]string{url, name, "stdio"}, "/"),
-        }
-
-        // This should always be a step.
-        comp.Type = resp.Step
-
-        // This should always be 0
-        comp.LevelsDeep = 0
-
-        // Timeswamapts
-        comp.Started = asc.Started.Time().Format(time.RFC3339)
-
-        // This should be the exact same thing.
-        comp.Text = asc.Text
-
-        return comp
-}
-
 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)",
                         Value: fmt.Sprintf("$%.2f", sr.CostsUsd[0]),
                 })
         }
         if sr.State == TaskCompleted || sr.State == TaskTimedOut {
                 props.Property = append(props.Property, &resp.Property{
@@ skipping 15 matching lines @@
                         Key: parts[0],
                 }
                 if len(parts) == 2 {
                         p.Value = parts[1]
                 }
                 props.Property = append(props.Property, p)
         }
         return props
 }
 
-func taskToBuild(c context.Context, sr *swarming.SwarmingRpcsTaskResult) (*resp.MiloBuild, error) {
-        build := &resp.MiloBuild{}
+func taskToBuild(c context.Context, server string, sr *swarming.SwarmingRpcsTaskResult) (*resp.MiloBuild, error) {
+        build := &resp.MiloBuild{
+                Summary: resp.BuildComponent{
+                        Source: &resp.Link{
+                                Label: "Task " + sr.TaskId,
+                                URL:   taskPageURL(server, sr.TaskId),
+                        },
+                },
+        }
+
         switch sr.State {
         case TaskRunning:
                 build.Summary.Status = resp.Running
 
         case TaskPending:
                 build.Summary.Status = resp.NotRun
 
         case TaskExpired, TaskTimedOut, TaskBotDied:
                 build.Summary.Status = resp.InfraFailure
 
@@ skipping 17 matching lines @@
         }
 
         // Extract more swarming specific information into the properties.
         if props := taskProperties(sr); len(props.Property) > 0 {
                 build.PropertyGroup = append(build.PropertyGroup, props)
         }
         if props := tagsToProperties(sr.Tags); len(props.Property) > 0 {
                 build.PropertyGroup = append(build.PropertyGroup, props)
         }
 
+        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.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)
@@ skipping 45 matching lines @@
         for _, t := range sr.Tags {
                 if t == "allow_milo:1" {
                         allowMilo = true
                         break
                 }
         }
         if !allowMilo {
                 return nil, fmt.Errorf("Not A Milo Job")
         }
 
-        build, err := taskToBuild(c, sr)
+        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(resolveServer(server), taskID),
+                                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", swarmingHostname, taskID)
+        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)
+}