Milo: Use LogDog URLs in top-level "Logs" field.

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"
@@ skipping 497 matching lines @@
 
 // updatePostProcessBuild transforms a build from its raw JSON format into the
 // format that should be presented to users.
 //
 // Post-processing includes:
 //      - If the build is LogDog-only, promotes aliases (LogDog links) to
 //        first-class links in the build.
 func updatePostProcessBuild(b *buildbotBuild) {
         // If this is a LogDog-only build, we want to promote the LogDog links.
         if loc, ok := b.getPropertyValue("log_location").(string); ok && strings.HasPrefix(loc, "logdog://") {
+                linkMap := map[string]string{}
                 for sidx := range b.Steps {
-                        promoteLogDogLinks(&b.Steps[sidx], sidx == 0)
+                        promoteLogDogLinks(&b.Steps[sidx], sidx == 0, linkMap)
+                }
+
+                // Update "Logs". This field is part of BuildBot, and is the amalgamation
+                // of all logs in the build's steps. Since each log is out of context of its
+                // original step, we can't apply the promotion logic; instead, we will use
+                // the link map to map any old URLs that were matched in "promoteLogDogLnks"
+                // to their new URLs.
+                for _, link := range b.Logs {
+                        // "link" is in the form: [NAME, URL]
+                        if len(link) != 2 {
+                                continue
+                        }
+
+                        if newURL, ok := linkMap[link[1]]; ok {
+                                link[1] = newURL
+                        }
                 }
         }
 }
 
 // promoteLogDogLinks updates the links in a BuildBot step to
 // promote LogDog links.
 //
 // A build's links come in one of three forms:
 //      - Log Links, which link directly to BuildBot build logs.
 //      - URL Links, which are named links to arbitrary URLs.
 //      - Aliases, which attach to the label in one of the other types of links and
 //        augment it with additional named links.
 //
 // LogDog uses aliases exclusively to attach LogDog logs to other links. When
 // the build is LogDog-only, though, the original links are actually junk. What
 // we want to do is remove the original junk links and replace them with their
 // alias counterparts, so that the "natural" BuildBot links are actually LogDog
 // links.
-func promoteLogDogLinks(s *buildbotStep, isInitialStep bool) {
+//
+// As URLs are re-mapped, the supplied "linkMap" will be updated to map the old
+// URLs to the new ones.
+func promoteLogDogLinks(s *buildbotStep, isInitialStep bool, linkMap map[string]string) {
         type stepLog struct {
                 label string
                 url   string
         }
 
         remainingAliases := stringset.New(len(s.Aliases))
         for linkAnchor := range s.Aliases {
                 remainingAliases.Add(linkAnchor)
         }
 
@@ skipping 24 matching lines @@
                         // Any link named "logdog" (Annotee cosmetic implementation detail) will
                         // inherit the name of the original log.
                         if !isLog {
                                 if aliasStepLog.label == "logdog" {
                                         aliasStepLog.label = sl.label
                                 }
                         }
 
                         result[i] = &aliasStepLog
                 }
+
+                // If we performed mapping, add the OLD -> NEW URL mapping to linkMap.
+                //
+                // Since multpiple aliases can apply to a single log, and we have to pick
+                // one, here, we'll arbitrarily pick the last one. This is maybe more
+                // consistent than the first one because linkMap, itself, will end up
+                // holding the last mapping for any given URL.
+                if len(result) > 0 {
+                        linkMap[sl.url] = result[len(result)-1].url
+                }
+
                 return result
         }
 
         // Update step logs.
         newLogs := make([][]string, 0, len(s.Logs))
         for _, l := range s.Logs {
                 for _, res := range maybePromoteAliases(&stepLog{l[0], l[1]}, true) {
                         newLogs = append(newLogs, []string{res.label, res.url})
                 }
         }
@@ skipping 20 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
 }