[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"
         "net/url"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
+        "github.com/luci/gae/service/info"
         swarming "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/logdog/client/annotee"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/milo/api/resp"
@@ skipping 512 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)
+
+                if ub, err = swarmingURLBuilderForTask(c, taskID); err != nil {
+                        return nil, err
+                }
 
         default:
                 s = &miloProto.Step{}
-                ub = swarmingURLBuilder(linkBase)
+                if ub, err = swarmingURLBuilderForTask(c, taskID); err != nil {
+                        return nil, err
+                }
         }
 
         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 48 matching lines @@
 
 // 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)
 }
 
 // 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.
+// Make one of these with swarmingURLBuilderForTask.
 type swarmingURLBuilder string
 
+// swarmingURLBuilderForTask returns a URLBuilder that builds links relative to
+// the current milo hostname's /swarming/task/<id> endpoint.
+func swarmingURLBuilderForTask(c context.Context, task string) (rawpresentation.URLBuilder, error) {

[Ryan Tseng, 2017/07/12 03:52:56]

Honestly relative urls are fine, most other places use relative URLs, this used
full URLs previously just because it was convenient.

[iannucci, 2017/07/12 18:08:36]

Done.

+        hostname, err := info.ModuleHostname(c, "", "", "")
+        if err != nil {
+                return nil, err
+        }
+        // version.module.hostname.tld
+        toks := strings.SplitN(hostname, ".", 3)
+        if len(toks) != 3 {
+                return nil, errors.Reason("unable to determine base URL").
+                        InternalReason("bad ModuleHostname %q", hostname).Err()
+        }
+        return swarmingURLBuilder(fmt.Sprintf(
+                "https://%s-dot-%s-dot-%s/swarming/task/%s", toks[0], toks[1], toks[2], task,

[Ryan Tseng, 2017/07/12 03:52:56]

"/swarming/task/" + task 

is sufficient

Probably better too, since we don't really want to see blah-dot-blah in all the
places

[iannucci, 2017/07/12 18:08:36]

Done.

+        )), nil
+}
+
 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
-                }
+                u.Path += "/" + ls.Name
                 link := resp.NewLink(l.Label, u.String())
                 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
 }