Milo: Console improvements

milo/common/config.go

 // Copyright 2016 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 17 matching lines @@
         "github.com/luci/luci-go/common/data/caching/proccache"
         "github.com/luci/luci-go/common/data/stringset"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/luci_config/server/cfgclient"
         "github.com/luci/luci-go/luci_config/server/cfgclient/backend"
 
         "github.com/luci/luci-go/milo/api/config"
 )
 
-// Console is af datastore entity representing a single console.
+// Console is a datastore entity representing a single console.
 type Console struct {
         // Parent is a key to the parent Project entity where this console was
         // defined in.
         Parent *datastore.Key `gae:"$parent"`
         // ID is the ID of the console.
         ID string `gae:"$id"`
         // RepoURL and Ref combined defines the commits the show up on the left
         // hand side of a Console.
         RepoURL string
         // RepoURL and Ref combined defines the commits the show up on the left
         // hand side of a Console.
         Ref string
         // ManifestName is the name of the manifest to look for when querying for
         // builds under this console.
         ManifestName string
         // URL is the URL to the luci-config definition of this console.
         URL string
         // Revision is the luci-config reivision from when this Console was retrieved.
         Revision string
-        // Builders is a list of universal builder IDs.
+        // Builders is a list of universal builder IDs.  This is indexed.
         Builders []string
+        // BuilderMeta is an expanded set of builders containing additional metadata.
+        // This should always match the Builders field.
+        BuilderMetas []BuilderMeta
+}
+
+// BuilderMeta is a struct containing metadata about a builder.
+type BuilderMeta struct {
+        Category  string
+        ShortName string
 }
 
 // GetProjectName retrieves the project name of the console out of the Console's
 // parent key.
 func (con *Console) GetProjectName() string {
         return con.Parent.StringID()
 }
 
 // NewConsole creates a fully populated console out of the luci-config proto
 // definition of a console.
 func NewConsole(project *datastore.Key, URL, revision string, con *config.Console) *Console {
         return &Console{
                 Parent:       project,
                 ID:           con.ID,
                 RepoURL:      con.RepoURL,
                 Ref:          con.Ref,
                 ManifestName: con.ManifestName,
                 Revision:     revision,
                 URL:          URL,
                 Builders:     BuilderFromProto(con.Builders),
+                BuilderMetas: BuilderRefFromProto(con.Builders),
         }
 }
 
 // BuilderFromProto tranforms a luci-config proto builder format into the datastore
 // format.
 func BuilderFromProto(cb []*config.Builder) []string {
         builders := make([]string, len(cb))
         for i, b := range cb {
                 builders[i] = b.Name
         }
         return builders
 }
 
+// BuilderFromProto tranforms a luci-config proto builder format into the BuilderRef
+// format.
+func BuilderRefFromProto(cb []*config.Builder) []BuilderMeta {

[dnj, 2017/08/02 23:33:04]

nit: function name needs to match comment

[Ryan Tseng, 2017/08/03 00:46:12]

oops copypasta mistake.

+        builders := make([]BuilderMeta, len(cb))
+        for i, b := range cb {
+                builders[i] = BuilderMeta{
+                        Category:  b.Category,
+                        ShortName: b.ShortName,
+                }
+        }
+        return builders
+}
+
 // LuciConfigURL returns a user friendly URL that specifies where to view
 // this console definition.
 func LuciConfigURL(c context.Context, configSet, path, revision string) string {
         // TODO(hinoka): This shouldn't be hardcoded, instead we should get the
         // luci-config instance from the context.  But we only use this instance at
         // the moment so it is okay for now.
         // TODO(hinoka): The UI doesn't allow specifying paths and revision yet.  Add
         // that in when it is supported.
         return fmt.Sprintf("https://luci-config.appspot.com/newui#/%s", configSet)
 }
@@ skipping 238 matching lines @@
         }
 
         // Print some stats.
         processedConsoles := 0
         for _, cons := range knownProjects {
                 if cons != nil {
                         processedConsoles += cons.Len()
                 }
         }
         logging.Infof(
-                c, "processed %d consoles over %d projects", len(knownProjects), processedConsoles)
+                c, "processed %d consoles over %d projects", processedConsoles, len(knownProjects))
 
         if len(merr) == 0 {
                 return nil
         }
         return merr
 }
 
 // GetAllConsoles returns all registered projects with the builder name.
 // If builderName is empty, then this retrieves all Consoles.
 func GetAllConsoles(c context.Context, builderName string) ([]*Console, error) {
         q := datastore.NewQuery("Console")
         if builderName != "" {
                 q = q.Eq("Builders", builderName)
         }
         con := []*Console{}
         err := datastore.GetAll(c, q, &con)
         return con, err
 }
 
 // GetConsole returns the requested console.
 func GetConsole(c context.Context, proj, id string) (*Console, error) {
         // TODO(hinoka): Memcache this.
         con := Console{
                 Parent: datastore.MakeKey(c, "Project", proj),
                 ID:     id,
         }
         err := datastore.Get(c, &con)
         return &con, err
 }