Milo: Remove swarming tags from build properties

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"
         "fmt"
         "net/http"
@@ skipping 229 matching lines @@
         }
         if sr.State == TaskCompleted || sr.State == TaskTimedOut {
                 props.Property = append(props.Property, &resp.Property{
                         Key:   "Exit Code",
                         Value: fmt.Sprintf("%d", sr.ExitCode),
                 })
         }
         return props
 }
 
-func tagsToProperties(tags []string) *resp.PropertyGroup {
-        props := &resp.PropertyGroup{GroupName: "Swarming Tags"}
+func tagsToMap(tags []string) map[string]string {
+        result := make(map[string]string, len(tags))
         for _, t := range tags {
-                if t == "" {
-                        continue
+                parts := strings.SplitN(t, ":", 2)
+                if len(parts) == 2 {
+                        result[parts[0]] = parts[1]
                 }
-                parts := strings.SplitN(t, ":", 2)
-                p := &resp.Property{
-                        Key: parts[0],
-                }
-                if len(parts) == 2 {
-                        p.Value = parts[1]
-                }
-                props.Property = append(props.Property, p)
         }
-        return props
+        return result
 }
 
 // addBuilderLink adds a link to the buildbucket builder view.
-func addBuilderLink(c context.Context, build *resp.MiloBuild, swarmingHostname string, sr *swarming.SwarmingRpcsTaskResult) {
-        tags := swarmingTags(sr.Tags)
-
+func addBuilderLink(c context.Context, build *resp.MiloBuild, tags map[string]string) {
         bbHost := tags["buildbucket_hostname"]
         bucket := tags["buildbucket_bucket"]
         builder := tags["builder"]
-        if bucket == "" {
-                logging.Errorf(
-                        c, "Could not extract buildbucket 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
-                }
+func addBanner(build *resp.MiloBuild, tags map[string]string) {
+        os := tags["os"]
+        var ver string
+        parts := strings.SplitN(os, "-", 2)
+        if len(parts) == 2 {
+                os = parts[0]
+                ver = parts[1]
         }
 
         var base resp.LogoBase
         switch os {
         case "Ubuntu":
                 base = resp.Ubuntu
         case "Windows":
                 base = resp.Windows
         case "Mac":
                 base = resp.OSX
@@ skipping 90 matching lines @@
                 ts, err := time.Parse(SwarmingTimeLayout, sr.CompletedTs)
                 if err != nil {
                         return fmt.Errorf("invalid task CompletedTs: %s", err)
                 }
                 step.Ended = google.NewTimestamp(ts)
         }
 
         return nil
 }
 
+func addBuildsetInfo(build *resp.MiloBuild, tags map[string]string) {
+        buildset := tags["buildset"]
+        if !strings.HasPrefix(buildset, "patch/") {
+                // Buildset isn't a patch, ignore.
+                return
+        }
+
+        patchset := strings.TrimLeft(buildset, "patch/")
+        // TODO(hinoka): Also support Rietveld patches.
+        if strings.HasPrefix(patchset, "gerrit/") {
+                gerritPatchset := strings.TrimLeft(patchset, "gerrit/")
+                parts := strings.Split(gerritPatchset, "/")
+                if len(parts) != 3 {
+                        // Not a well-formed gerrit patchset.
+                        return
+                }
+                if build.SourceStamp == nil {
+                        build.SourceStamp = &resp.SourceStamp{}
+                }
+                build.SourceStamp.Changelist = &resp.Link{
+                        Label: "Gerrit CL",
+                        URL:   fmt.Sprintf("https://%s/c/%s/%s", parts[0], parts[1], parts[2]),
+                }
+
+        }
+}
+
+func addRecipeLink(build *resp.MiloBuild, tags map[string]string) {
+        name := tags["recipe_name"]
+        repoURL := tags["recipe_repository"]
+        revision := tags["recipe_revision"]
+        if name != "" && repoURL != "" {
+                if revision == "" {
+                        revision = "master"
+                }
+                // Link directly to the revision if it is a gerrit URL, otherwise just
+                // display it in the name.
+                if repoParse, err := url.Parse(repoURL); err == nil && strings.HasSuffix(
+                        repoParse.Host, ".googlesource.com") {
+                        repoURL += "/+/" + revision + "/"
+                } else {
+                        if len(revision) > 8 {
+                                revision = revision[:8]
+                        }
+                        name += " @ " + revision
+                }
+                build.Summary.Recipe = &resp.Link{
+                        Label: name,
+                        URL:   repoURL,
+                }
+        }
+}
+
 func addTaskToBuild(c context.Context, server string, sr *swarming.SwarmingRpcsTaskResult, build *resp.MiloBuild) error {
         build.Summary.Label = sr.TaskId
         build.Summary.Type = resp.Recipe
         build.Summary.Source = &resp.Link{
                 Label: "Task " + sr.TaskId,
                 URL:   taskPageURL(server, sr.TaskId),
         }
 
         // 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)
-        }
+        tags := tagsToMap(sr.Tags)
 
-        addBuilderLink(c, build, server, sr)
-        addBanner(build, sr)
+        addBuildsetInfo(build, tags)
+        addBanner(build, tags)
+        addBuilderLink(c, build, tags)
+        addRecipeLink(build, tags)
 
         // Add a link to the bot.
         if sr.BotId != "" {
                 build.Summary.Bot = &resp.Link{
                         Label: sr.BotId,
                         URL:   botPageURL(server, sr.BotId),
                 }
         }
 
         return nil
@@ skipping 261 matching lines @@
         for _, tag := range v {
                 var value string
                 parts := strings.SplitN(tag, ":", 2)
                 if len(parts) == 2 {
                         value = parts[1]
                 }
                 res[parts[0]] = value
         }
         return res
 }