milo: Add SwarmBucket templating.

milo/appengine/swarming/buildinfo.go

 // Copyright 2017 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 (
         "strconv"
         "strings"
         "unicode/utf8"
 
         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"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/grpc/grpcutil"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
         milo "github.com/luci/luci-go/milo/api/proto"
+        "github.com/luci/luci-go/swarming/tasktemplate"
 
         "golang.org/x/net/context"
 )
 
 // BuildInfoProvider provides build information.
 //
 // In a production system, this will be completely defaults. For testing, the
 // various services and data sources may be substituted for testing stubs.
 type BuildInfoProvider struct {
         bl buildLoader
@@ skipping 94 matching lines @@
 // This will return a gRPC error on failure.
 //
 // This function is messy and implementation-specific. That's the point of this
 // endpoint, though. All of the nastiness here should be replaced with something
 // more elegant once that becomes available. In the meantime...
 func resolveLogDogAnnotations(c context.Context, sr *swarming.SwarmingRpcsTaskRequest, projectHint cfgtypes.ProjectName,
         host, taskID string, tryNumber int64) (*types.StreamAddr, error) {
 
         // Try and resolve from explicit tags (preferred).
         tags := swarmingTags(sr.Tags)
-        addr, err := resolveLogDogStreamAddrFromTags(tags)
+        addr, err := resolveLogDogStreamAddrFromTags(tags, taskID, tryNumber)
         if err == nil {
                 return addr, nil
         }
         logging.WithError(err).Debugf(c, "Could not resolve stream address from tags.")
 
         // If this is a Kitchen command, maybe we can infer our LogDog project from
         // the command-line.
         if sr.Properties == nil {
                 logging.Warningf(c, "No request properties, can't infer annotation stream path.")
                 return nil, grpcutil.NotFound
@@ skipping 55 matching lines @@
                         if i < len(cmd)-2 {
                                 proj = cfgtypes.ProjectName(cmd[i+1])
                                 return
                         }
                         break
                 }
         }
         return
 }
 
-func resolveLogDogStreamAddrFromTags(tags map[string]string) (*types.StreamAddr, error) {
+func resolveLogDogStreamAddrFromTags(tags map[string]string, taskID string, tryNumber int64) (*types.StreamAddr, error) {
         // If we don't have a LUCI project, abort.
         luciProject, logLocation := tags["luci_project"], tags["log_location"]
         switch {
         case luciProject == "":
                 return nil, errors.New("no 'luci_project' tag")
         case logLocation == "":
                 return nil, errors.New("no 'log_location' tag")
         }
 
+        // Gather our Swarming task template parameters and perform a substitution.
+        runID, err := getRunID(taskID, tryNumber)
+        if err != nil {
+                return nil, errors.Annotate(err).Err()
+        }
+        p := tasktemplate.Params{
+                SwarmingRunID: runID,
+        }
+        if logLocation, err = p.Resolve(logLocation); err != nil {
+                return nil, errors.Annotate(err).Reason("failed to resolve swarming task templating in 'log_location'").Err()
+        }
+
         addr, err := types.ParseURL(logLocation)
         if err != nil {
                 return nil, errors.Annotate(err).Reason("could not parse LogDog stream from location").Err()
         }
 
         // The LogDog stream's project should match the LUCI project.
         if string(addr.Project) != luciProject {
                 return nil, errors.Reason("stream project %(streamProject)q doesn't match LUCI project %(luciProject)q").
                         D("luciProject", luciProject).
                         D("streamProject", addr.Project).
@@ skipping 25 matching lines @@
         lastChar, lastCharSize := utf8.DecodeLastRuneInString(taskID)
         v, err := strconv.ParseUint(string(lastChar), 16, 8)
         if err != nil {
                 return "", errors.Annotate(err).Reason("failed to parse hex from rune: %(rune)r").
                         D("rune", lastChar).
                         Err()
         }
 
         return taskID[:len(taskID)-lastCharSize] + strconv.FormatUint((v|uint64(tryNumber)), 16), nil
 }