[milo] remove linkBase and calculate links directly.

milo/buildsource/swarming/build.go

 // Copyright 2015 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 swarming
 
 import (
         "bytes"
         "fmt"
         "net/http"
@@ skipping 528 matching lines @@
         infoComp := infoComponent(model.InfraFailure,
                 "LogDog stream not found", "Job likely failed to start.")
         infoComp.Started = build.Summary.Started
         infoComp.Finished = build.Summary.Finished
         infoComp.Duration = build.Summary.Duration
         infoComp.Verbosity = resp.Interesting
         build.Components = append(build.Components, infoComp)
         return addTaskToBuild(c, host, res, build)
 }
 
-func (bl *BuildLoader) SwarmingBuildImpl(c context.Context, svc swarmingService, linkBase, taskID string) (*resp.MiloBuild, error) {
+func (bl *BuildLoader) SwarmingBuildImpl(c context.Context, svc swarmingService, taskID string) (*resp.MiloBuild, error) {
         // Fetch the data from Swarming
         var logDogStreamAddr *types.StreamAddr
 
         fetchParams := swarmingFetchParams{
                 fetchRes: true,
                 fetchLog: true,
 
                 // Cancel if LogDog annotation stream parameters are present in the tag set.
                 taskResCallback: func(res *swarming.SwarmingRpcsTaskResult) (cancelLogs bool) {
                         // If the build hasn't started yet, then there is no LogDog log stream to
@@ skipping 90 matching lines @@
                         comp := infoComponent(model.InfraFailure, "Milo annotation parser", err.Error())
                         comp.SubLink = append(comp.SubLink, resp.LinkSet{
                                 resp.NewLink("swarming task", taskPageURL(svc.getHost(), taskID)),
                         })
                         build.Components = append(build.Components, comp)
                 }
 
                 if lds != nil && lds.MainStream != nil && lds.MainStream.Data != nil {
                         s = lds.MainStream.Data
                 }
-                ub = swarmingURLBuilder(linkBase)
+                ub = swarmingURLBuilder(taskID)
 
         default:
                 s = &miloProto.Step{}
-                ub = swarmingURLBuilder(linkBase)
+                ub = swarmingURLBuilder(taskID)
         }
 
         if s != nil {
                 if err := addTaskToMiloStep(c, svc.getHost(), fr.res, s); err != nil {
                         return nil, err
                 }
                 rawpresentation.AddLogDogToBuild(c, ub, s, &build)
         }
 
         if err := addTaskToBuild(c, svc.getHost(), fr.res, &build); err != nil {
@@ skipping 45 matching lines @@
 func taskPageURL(swarmingHostname, taskID string) string {
         return fmt.Sprintf("https://%s/task?id=%s&show_raw=1&wide_logs=true", swarmingHostname, taskID)
 }
 
 // botPageURL returns a URL to a human-consumable page of a swarming bot.
 // Supports server aliases.
 func botPageURL(swarmingHostname, botID string) string {
         return fmt.Sprintf("https://%s/restricted/bot/%s", swarmingHostname, botID)
 }
 
+// URLBase is the routing prefix for swarming endpoints. It's here so that it
+// can be a constant between the swarmingURLBuilder and the frontend.
+const URLBase = "/swarming/task"
+
 // swarmingURLBuilder is a logdog.URLBuilder that builds Milo swarming log
 // links.
 //
-// The string value for this should be the "linkBase" parameter value supplied
-// to swarmingBuildImpl.
+// It should be the swarming task id.
 type swarmingURLBuilder string
 
 func (b swarmingURLBuilder) BuildLink(l *miloProto.Link) *resp.Link {
-        u, err := url.Parse(string(b))
-        if err != nil {
-                return nil
-        }
-
         switch t := l.Value.(type) {
         case *miloProto.Link_LogdogStream:
                 ls := t.LogdogStream
 
-                if u.Path == "" {
-                        u.Path = ls.Name
-                } else {
-                        u.Path = strings.TrimSuffix(u.Path, "/") + "/" + ls.Name
-                }
-                link := resp.NewLink(l.Label, u.String())
+                link := resp.NewLink(l.Label, fmt.Sprintf("%s/%s/%s", URLBase, b, ls.Name))
                 if link.Label == "" {
                         link.Label = ls.Name
                 }
                 return link
 
         case *miloProto.Link_Url:
                 return resp.NewLink(l.Label, t.Url)
 
         default:
                 return nil
         }
 }
 
 func swarmingTags(v []string) map[string]string {
         res := make(map[string]string, len(v))
         for _, tag := range v {
                 var value string
                 parts := strings.SplitN(tag, ":", 2)
                 if len(parts) == 2 {
                         value = parts[1]
                 }
                 res[parts[0]] = value
         }
         return res
 }