Milo: Fix Gerrit/Rietveld link for buildbot builds.

milo/appengine/buildbot/build.go

 // Copyright 2016 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 buildbot
 
 import (
         "encoding/json"
         "errors"
         "fmt"
         "io/ioutil"
         "math"
         "path/filepath"
         "regexp"
         "sort"
+        "strconv"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/data/stringset"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/milo/api/resp"
         "github.com/luci/luci-go/milo/appengine/common/model"
@@ skipping 362 matching lines @@
                 })
         }
         return
 }
 
 // sourcestamp extracts the source stamp from various parts of a buildbot build,
 // including the properties.
 func sourcestamp(c context.Context, b *buildbotBuild) *resp.SourceStamp {
         ss := &resp.SourceStamp{}
         rietveld := ""
+        gerrit := ""
         got_revision := ""
         repository := ""
         issue := int64(-1)
         // TODO(hinoka): Gerrit URLs.

[iannucci, 2017/06/21 00:00:44]

rm?

[Ryan Tseng, 2017/06/21 00:01:28]

herp derp

         for _, prop := range b.Properties {
                 switch prop.Name {
                 case "rietveld":
                         if v, ok := prop.Value.(string); ok {
                                 rietveld = v
                         } else {
                                 logging.Warningf(c, "Field rietveld is not a string: %#v", prop.Value)
                         }
                 case "issue":
+                        // Sometime this is a number (float), sometime it is a string.
                         if v, ok := prop.Value.(float64); ok {
                                 issue = int64(v)
+                        } else if v, ok := prop.Value.(string); ok {
+                                if vi, err := strconv.Atoi(v); err == nil {
+                                        issue = int64(vi)
+                                } else {
+                                        logging.Warningf(c, "Could not decode field issue: %q - %s", prop.Value, err)
+                                }
                         } else {
-                                logging.Warningf(c, "Field issue is not a float: %#v", prop.Value)
+                                logging.Warningf(c, "Field issue is not a string or float: %#v", prop.Value)
                         }
 
                 case "got_revision":
                         if v, ok := prop.Value.(string); ok {
                                 got_revision = v
                         } else {
                                 logging.Warningf(c, "Field got_revision is not a string: %#v", prop.Value)
                         }
 
+                case "patch_issue":
+                        if v, ok := prop.Value.(float64); ok {
+                                issue = int64(v)
+                        } else {
+                                logging.Warningf(c, "Field patch_issue is not a float: %#v", prop.Value)
+                        }
+
+                case "patch_gerrit_url":
+                        if v, ok := prop.Value.(string); ok {
+                                gerrit = v
+                        } else {
+                                logging.Warningf(c, "Field gerrit is not a string: %#v", prop.Value)
+                        }
+
                 case "repository":
                         if v, ok := prop.Value.(string); ok {
                                 repository = v
                         }
                 }
         }
         if issue != -1 {
-                if rietveld != "" {
+                switch {
+                case rietveld != "":
                         rietveld = strings.TrimRight(rietveld, "/")
                         ss.Changelist = resp.NewLink(
-                                fmt.Sprintf("Issue %d", issue),
-                                fmt.Sprintf("%s/%d", rietveld, issue),
-                        )
-                } else {
-                        logging.Warningf(c, "Found issue but not rietveld property.")
+                                fmt.Sprintf("Rietveld CL %d", issue),
+                                fmt.Sprintf("%s/%d", rietveld, issue))
+                case gerrit != "":
+                        gerrit = strings.TrimRight(gerrit, "/")
+                        ss.Changelist = resp.NewLink(
+                                fmt.Sprintf("Gerrit CL %d", issue),
+                                fmt.Sprintf("%s/c/%d", gerrit, issue))
                 }
         }
+
         if got_revision != "" {
                 ss.Revision = resp.NewLink(got_revision, "")
                 if repository != "" {
                         ss.Revision.URL = repository + "/+/" + got_revision
                 }
         }
         return ss
 }
 
 func getDebugBuild(c context.Context, builder string, buildNum int) (*buildbotBuild, error) {
@@ skipping 174 matching lines @@
         var newAliases map[string][]*buildbotLinkAlias
         if l := remainingAliases.Len(); l > 0 {
                 newAliases = make(map[string][]*buildbotLinkAlias, l)
                 remainingAliases.Iter(func(v string) bool {
                         newAliases[v] = s.Aliases[v]
                         return true
                 })
         }
         s.Aliases = newAliases
 }