Add manifest links and hack to index on revision.

milo/api/resp/build.go

 // Copyright 2015 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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 //go:generate stringer -type=Verbosity
 //go:generate stringer -type=ComponentType
 
 package resp
 
 import (
+        "encoding/hex"
         "encoding/json"
         "time"
 
+        "golang.org/x/net/context"
+
+        "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/milo/common"
         "github.com/luci/luci-go/milo/common/model"
 )
 
 // MiloBuild denotes a full renderable Milo build page.
 type MiloBuild struct {
         // Summary is a top level summary of the page.
         Summary BuildComponent
 
         // SourceStamp gives information about how the build came about.
         SourceStamp *SourceStamp
@@ skipping 237 matching lines @@
 func (comp *BuildComponent) toModelSummary() model.Summary {
         return model.Summary{
                 Status: comp.Status,
                 Start:  comp.Started,
                 End:    comp.Finished,
                 Text:   comp.Text,
         }
 }
 
 // SummarizeTo summarizes the data into a given model.BuildSummary.
-func (rb *MiloBuild) SummarizeTo(bs *model.BuildSummary) {
+func (rb *MiloBuild) SummarizeTo(c context.Context, bs *model.BuildSummary) error {
         bs.Summary = rb.Summary.toModelSummary()
         if rb.Summary.Status == model.Running {
                 // Assume the last step is the current step.
                 if len(rb.Components) > 0 {
                         cs := rb.Components[len(rb.Components)-1]
                         bs.CurrentStep = cs.toModelSummary()
                 }
         }
         if rb.SourceStamp != nil {
-                // TODO(hinoka): This should be full manifests, but lets just use single
-                // revisions for now.
+                // TODO(hinoka, iannucci): This should be full manifests, but lets just use
+                // single revisions for now. HACKS!
                 if rb.SourceStamp.Revision != nil {
-                        bs.Manifests = append(bs.Manifests, model.ManifestLink{
-                                Name: "REVISION",
-                                ID:   []byte(rb.SourceStamp.Revision.Label),
-                        })
+                        revisionBytes, err := hex.DecodeString(rb.SourceStamp.Revision.Label)
+                        if err != nil {
+                                logging.WithError(err).Warningf(c, "bad revision (not hex-decodable)")
+                        } else {
+                                bs.Manifests = append(bs.Manifests, model.ManifestLink{
+                                        Name: "REVISION",
+                                        ID:   []byte(rb.SourceStamp.Revision.Label),
+                                })
+                                consoles, err := common.GetConsolesForBuilder(c, bs.BuilderID)
+                                if err != nil {
+                                        return err
+                                }
+                                for _, con := range consoles {
+                                        // HACK(iannucci): Until we have real manifest support, console
+                                        // definitions will specify their manifest as "REVISION", and we'll do
+                                        // lookups with null URL fields.
+                                        bs.AddManifestRevisionIndex(
+                                                con.ProjectID, con.Console.Name, "REVISION", "", revisionBytes)
+                                }
+                        }
                 }
                 if rb.SourceStamp.Changelist != nil {
                         bs.Patches = append(bs.Patches, model.PatchInfo{
                                 Link:        rb.SourceStamp.Changelist.Link,
                                 AuthorEmail: rb.SourceStamp.AuthorEmail,
                         })
                 }
         }
+        return nil
 }