milo: add builder title to swarming build page

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"
         "github.com/luci/luci-go/common/transport"
 )
 
 // SwarmingTimeLayout is time layout used by swarming.
 const SwarmingTimeLayout = "2006-01-02T15:04:05.999999999"
 
 // Swarming task states..
 const (
         // TaskRunning means task is running.
         TaskRunning = "RUNNING"
@@ skipping 139 matching lines @@
                         Key: parts[0],
                 }
                 if len(parts) == 2 {
                         p.Value = parts[1]
                 }
                 props.Property = append(props.Property, p)
         }
         return props
 }
 
+// tagValue returns a value of the first tag matching the tag key. If not found
+// returns "".
+func tagValue(tags []string, key string) string {
+        prefix := key + ":"
+        for _, t := range tags {
+                if strings.HasPrefix(t, prefix) {
+                        return strings.TrimPrefix(t, prefix)
+                }
+        }
+        return ""
+}
+
+// addBuilderLink adds a link to the buildbucket builder view.
+func addBuilderLink(c context.Context, build *resp.MiloBuild, swarmingHostname string, sr *swarming.SwarmingRpcsTaskResult) {
+        bbHost := tagValue(sr.Tags, "buildbucket_hostname")
+        bucket := tagValue(sr.Tags, "buildbucket_bucket")
+        builder := tagValue(sr.Tags, "builder")
+        if bucket == "" {
+                logging.Errorf(
+                        c, "Could not extract buidlbucket bucket from task %s",
+                        taskPageURL(swarmingHostname, sr.TaskId))
+        }
+        if builder == "" {
+                logging.Errorf(
+                        c, "Could not extract builder name from task %s",
+                        taskPageURL(swarmingHostname, sr.TaskId))
+        }
+        if bucket != "" && builder != "" {
+                build.Summary.ParentLabel = &resp.Link{
+                        Label: builder,
+                        URL:   fmt.Sprintf("/buildbucket/%s/%s?server=%s", bucket, builder, bbHost),
+                }
+        }
+}
+
+// addBanner adds an OS banner derived from "os" swarming tag, if present.
+func addBanner(build *resp.MiloBuild, sr *swarming.SwarmingRpcsTaskResult) {
+        var os, ver string
+        for _, t := range sr.Tags {
+                value := strings.TrimPrefix(t, "os:")
+                if value == t {
+                        // t does not have the prefix
+                        continue
+                }
+                parts := strings.SplitN(value, "-", 2)
+                if len(parts) == 2 {
+                        os = parts[0]
+                        ver = parts[1]
+                        break
+                }
+        }
+
+        var base resp.LogoBase
+        switch os {
+        case "Ubuntu":
+                base = resp.Ubuntu
+        case "Windows":
+                base = resp.Windows
+        case "Mac":
+                base = resp.OSX
+        case "Android":
+                base = resp.Android
+        default:
+                return
+        }
+
+        build.Summary.Banner = &resp.LogoBanner{
+                OS: []resp.Logo{{
+                        LogoBase: base,
+                        Subtitle: ver,
+                        Count:    1,
+                }},
+        }
+}
+
 func taskToBuild(c context.Context, server string, sr *swarming.SwarmingRpcsTaskResult) (*resp.MiloBuild, error) {
         build := &resp.MiloBuild{
                 Summary: resp.BuildComponent{
+                        Label: sr.TaskId,
                         Source: &resp.Link{
                                 Label: "Task " + sr.TaskId,
                                 URL:   taskPageURL(server, sr.TaskId),
                         },
                 },
         }
 
         switch sr.State {
         case TaskRunning:
                 build.Summary.Status = resp.Running
@@ skipping 33 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)
         }
 
+        addBuilderLink(c, build, server, sr)
+        addBanner(build, sr)
+
+        // Add a link to the bot.
         if sr.BotId != "" {
                 build.Summary.Bot = &resp.Link{
                         Label: sr.BotId,
                         URL:   botPageURL(server, sr.BotId),
                 }
         }
 
+        // Compute start and finished times, and duration.
         var err error
         if sr.StartedTs != "" {
                 build.Summary.Started, err = time.Parse(SwarmingTimeLayout, sr.StartedTs)
                 if err != nil {
                         return nil, fmt.Errorf("invalid task StartedTs: %s", err)
                 }
         }
         if sr.CompletedTs != "" {
                 build.Summary.Finished, err = time.Parse(SwarmingTimeLayout, sr.CompletedTs)
                 if err != nil {
@@ skipping 88 matching lines @@
 // 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.
 func botPageURL(swarmingHostname, botID string) string {
         return fmt.Sprintf("https://%s/restricted/bot/%s", swarmingHostname, botID)
 }