milo: Add a build info Swarming implementation.

milo/appengine/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 55 matching lines @@
         return sc, nil
 }
 
 // swarmingService is an interface that fetches data from Swarming.
 //
 // In production, this is fetched from a Swarming server. For testing, this can
 // be replaced with a mock.
 type swarmingService interface {
         getHost() string
         getSwarmingResult(c context.Context, taskID string) (*swarming.SwarmingRpcsTaskResult, error)
+        getSwarmingRequest(c context.Context, taskID string) (*swarming.SwarmingRpcsTaskRequest, error)
         getTaskOutput(c context.Context, taskID string) (string, error)
 }
 
 type prodSwarmingService struct {
         host   string
         client *swarming.Service
 }
 
 func newProdService(c context.Context, server string) (*prodSwarmingService, error) {
         client, err := getSwarmingClient(c, server)
@@ skipping 13 matching lines @@
 }
 
 func (svc *prodSwarmingService) getTaskOutput(c context.Context, taskID string) (string, error) {
         stdout, err := svc.client.Task.Stdout(taskID).Context(c).Do()
         if err != nil {
                 return "", err
         }
         return stdout.Output, nil
 }
 
+func (svc *prodSwarmingService) getSwarmingRequest(c context.Context, taskID string) (*swarming.SwarmingRpcsTaskRequest, error) {
+        return svc.client.Task.Request(taskID).Context(c).Do()
+}
+
 type swarmingFetchParams struct {
+        fetchReq bool
         fetchRes bool
         fetchLog bool
 }
 
 type swarmingFetchResult struct {
+        req *swarming.SwarmingRpcsTaskRequest
         res *swarming.SwarmingRpcsTaskResult
         log string
 }
 
 // swarmingFetch fetches (in parallel) the components that it is configured to
 // fetch.
 //
 // After fetching, an ACL check is performed to confirm that the user is
 // permitted to view the resulting data. If this check fails, get returns
 // errNotMiloJob.
 //
 // TODO(hinoka): Make this ACL check something more specific than the
 // resence of the "allow_milo" dimension.
 func swarmingFetch(c context.Context, svc swarmingService, taskID string, req swarmingFetchParams) (
         *swarmingFetchResult, error) {
 
         // logErr is managed separately from other fetch errors, since in some
         // situations it's acceptable to not have a log stream.
         var logErr error
         var fr swarmingFetchResult
 
         err := parallel.FanOutIn(func(workC chan<- func() error) {
+                if req.fetchReq {
+                        workC <- func() (err error) {
+                                fr.req, err = svc.getSwarmingRequest(c, taskID)
+                                return
+                        }
+                }
+
                 if req.fetchRes {
                         workC <- func() (err error) {
                                 fr.res, err = svc.getSwarmingResult(c, taskID)
                                 return
                         }
                 }
 
                 if req.fetchLog {
                         workC <- func() error {
                                 fr.log, logErr = svc.getTaskOutput(c, taskID)
                                 return nil
                         }
                 }
         })
         if err != nil {
                 return nil, err
         }
 
         // Current ACL implementation: error if this is not a Milo job.
         switch {
+        case req.fetchReq:
+                if !isMiloJob(fr.req.Tags) {
+                        return nil, errNotMiloJob
+                }
         case req.fetchRes:
                 if !isMiloJob(fr.res.Tags) {
                         return nil, errNotMiloJob
                 }
         default:
                 // No metadata to decide if this is a Milo job, so assume that it is not.
                 return nil, errNotMiloJob
         }
 
         if req.fetchRes && logErr != nil {
@@ skipping 368 matching lines @@
         case *miloProto.Link_Url:
                 return &resp.Link{
                         Label: l.Label,
                         URL:   t.Url,
                 }
 
         default:
                 return nil
         }
 }