milo: Use struct for BuildBot properties.

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"
         "fmt"
         "io/ioutil"
         "net/http"
         "path/filepath"
         "regexp"
         "sort"
         "strings"
         "time"
 
-        ds "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/common/miloerror"
+
+        ds "github.com/luci/gae/service/datastore"
+
         "golang.org/x/net/context"
 )
 
 var errBuildNotFound = miloerror.Error{
         Message: "Build not found",
         Code:    http.StatusNotFound,
 }
 
 // getBuild fetches a buildbot build from the datastore and checks ACLs.
 // The return code matches the master responses.
@@ skipping 308 matching lines @@
         Value interface{}
         Group string
 }
 
 // properties extracts all properties from buildbot builds and groups them into
 // property groups.
 func properties(b *buildbotBuild) (result []*resp.PropertyGroup) {
         groups := map[string]*resp.PropertyGroup{}
         allProps := map[string]Prop{}
         for _, prop := range b.Properties {
-                allProps[prop[0].(string)] = Prop{
-                        Value: prop[1],
-                        Group: prop[2].(string),
+                allProps[prop.Name] = Prop{
+                        Value: prop.Value,
+                        Group: prop.Source,
                 }
         }
         for key, prop := range allProps {
                 value := prop.Value
                 groupName := prop.Group
                 if _, ok := groups[groupName]; !ok {
                         groups[groupName] = &resp.PropertyGroup{GroupName: groupName}
                 }
                 vs, ok := parseProp(allProps, key, value)
                 if !ok {
@@ skipping 49 matching lines @@
 }
 
 // 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 := ""
         issue := int64(-1)
         // TODO(hinoka): Gerrit URLs.
         for _, prop := range b.Properties {
-                key := prop[0].(string)
-                value := prop[1]
-                switch key {
+                switch prop.Name {
                 case "rietveld":
-                        if v, ok := value.(string); ok {
+                        if v, ok := prop.Value.(string); ok {
                                 rietveld = v
                         } else {
-                                logging.Warningf(c, "Field rietveld is not a string: %#v", value)
+                                logging.Warningf(c, "Field rietveld is not a string: %#v", prop.Value)
                         }
                 case "issue":
-                        if v, ok := value.(float64); ok {
+                        if v, ok := prop.Value.(float64); ok {
                                 issue = int64(v)
                         } else {
-                                logging.Warningf(c, "Field issue is not a float: %#v", value)
+                                logging.Warningf(c, "Field issue is not a float: %#v", prop.Value)
                         }
 
                 case "got_revision":
-                        if v, ok := value.(string); ok {
+                        if v, ok := prop.Value.(string); ok {
                                 ss.Revision = v
                         } else {
-                                logging.Warningf(c, "Field got_revision is not a string: %#v", value)
+                                logging.Warningf(c, "Field got_revision is not a string: %#v", prop.Value)
                         }
 
                 }
         }
         if issue != -1 {
                 if rietveld != "" {
                         rietveld = strings.TrimRight(rietveld, "/")
                         ss.Changelist = &resp.Link{
                                 Label: fmt.Sprintf("Issue %d", issue),
                                 URL:   fmt.Sprintf("%s/%d", rietveld, issue),
@@ skipping 34 matching lines @@
 
         // TODO(hinoka): Do all fields concurrently.
         return &resp.MiloBuild{
                 SourceStamp:   sourcestamp(c, b),
                 Summary:       summary(c, b),
                 Components:    components(b),
                 PropertyGroup: properties(b),
                 Blame:         blame(b),
         }, nil
 }