milo: Use struct for BuildBot properties.

milo/appengine/buildbot/structs.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 (
         "bytes"
         "compress/gzip"
         "encoding/json"
@@ skipping 53 matching lines @@
         Text string `json:"text"`
 }
 
 func (a *buildbotLinkAlias) toLink() *resp.Link {
         return &resp.Link{
                 Label: a.Text,
                 URL:   a.URL,
         }
 }
 
+type buildbotProperty struct {
+        Name   string
+        Value  interface{}
+        Source string
+}
+
+func (p *buildbotProperty) MarshalJSON() ([]byte, error) {
+        return json.Marshal([]interface{}{p.Name, p.Value, p.Source})

[hinoka, 2017/02/03 01:06:17]

This works??? I am amazed and terrified at the same time.

[dnj, 2017/02/03 01:30:00]

Yep, Marshal will just see it as it was prior to this CL: a slice of interface{}
things.

+}
+
+func (p *buildbotProperty) UnmarshalJSON(d []byte) error {
+        // The raw BuildBot representation is a slice of interfaces.
+        var raw []interface{}
+        if err := json.Unmarshal(d, &raw); err != nil {
+                return err
+        }
+
+        switch len(raw) {
+        case 3:
+                if s, ok := raw[2].(string); ok {
+                        p.Source = s
+                }
+                fallthrough
+
+        case 2:
+                p.Value = raw[1]
+                fallthrough
+
+        case 1:
+                if s, ok := raw[0].(string); ok {
+                        p.Name = s
+                }
+        }
+        return nil
+}
+
 // buildbotBuild is a single build json on buildbot.
 type buildbotBuild struct {
         Master      string   `gae:"$master"`
         Blame       []string `json:"blame" gae:"-"`
         Buildername string   `json:"builderName"`
         // This needs to be reflected.  This can be either a String or a buildbotStep.
         Currentstep interface{} `json:"currentStep" gae:"-"`
         // We don't care about this one.
         Eta    interface{} `json:"eta" gae:"-"`
         Logs   [][]string  `json:"logs" gae:"-"`
         Number int         `json:"number"`
         // This is a slice of tri-tuples of [property name, value, source].
         // property name is always a string
         // value can be a string or float
         // source is optional, but is always a string if present
-        Properties  [][]interface{}      `json:"properties" gae:"-"`
+        Properties  []*buildbotProperty  `json:"properties" gae:"-"`
         Reason      string               `json:"reason"`
         Results     *int                 `json:"results" gae:"-"`
         Slave       string               `json:"slave"`
         Sourcestamp *buildbotSourceStamp `json:"sourceStamp" gae:"-"`
         Steps       []buildbotStep       `json:"steps" gae:"-"`
         Text        []string             `json:"text" gae:"-"`
         Times       []*float64           `json:"times" gae:"-"`
         // This one is injected by Milo.  Does not exist in a normal json query.
         TimeStamp *int `json:"timeStamp" gae:"-"`
         // This one is marked by Milo, denotes whether or not the build is internal.
@@ skipping 95 matching lines @@
         if err != nil {
                 return err
         }
         bs, err := ioutil.ReadAll(reader)
         if err != nil {
                 return err
         }
         return json.Unmarshal(bs, b)
 }
 
+func (b *buildbotBuild) getPropertyValue(name string) interface{} {
+        for _, prop := range b.Properties {
+                if prop.Name == name {
+                        return prop.Value
+                }
+        }
+        return ""
+}
+
 type errTooBig struct {
         error
 }
 
 // Save returns a property map of the struct to save in the datastore.  It
 // contains two fields, the ID which is the key, and a data field which is a
 // serialized and gzipped representation of the entire struct.
 func (b *buildbotBuild) Save(withMeta bool) (datastore.PropertyMap, error) {
         bs, err := json.Marshal(b)
         if err != nil {
@@ skipping 154 matching lines @@
                         PendingBuilds   int    `json:"pending_builds"`
                         State           string `json:"state"`
                         TotalSlaves     int    `json:"total_slaves"`
                 } `json:"builders"`
                 ServerUptime float64 `json:"server_uptime"`
         } `json:"varz"`
 
         // This is injected by the pubsub publisher on the buildbot side.
         Name string `json:"name"`
 }