Add additional validation to swarming v1 distributor.

dm/appengine/distributor/swarming/v1/distributor.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 swarming
 
 import (
         "encoding/json"
         "fmt"
         "net/http"
@@ skipping 36 matching lines @@
 
 func toSwarmMap(m map[string]string) []*swarm.SwarmingRpcsStringPair {
         ret := make([]*swarm.SwarmingRpcsStringPair, 0, len(m))
         for key, value := range m {
                 ret = append(ret, &swarm.SwarmingRpcsStringPair{
                         Key: key, Value: value})
         }
         return ret
 }
 
-func httpClient(c context.Context) *http.Client {
+func httpClients(c context.Context) (anonC, authC *http.Client) {
         rt, err := auth.GetRPCTransport(c, auth.AsSelf)
         if err != nil {
                 // if we can't set up a transport, we're seriously hosed
                 panic(err)
         }
-        return &http.Client{Transport: rt}
+        anonTransport, err := auth.GetRPCTransport(c, auth.NoAuth)
+        if err != nil {
+                panic(err)
+        }
+        anonC = &http.Client{Transport: anonTransport}
+        authC = &http.Client{Transport: rt}
+        return
 }
 
 func newSwarmClient(c context.Context, cfg *sv1.Config) *swarm.Service {
-        svc, err := swarm.New(httpClient(c))
+        _, authC := httpClients(c)
+        svc, err := swarm.New(authC)
         if err != nil {
                 // can only happen with nil client
                 panic(err)
         }
-        svc.BasePath = fmt.Sprintf("https://%s/_ah/api/swarming/v1/", cfg.Swarming.Host)
+        svc.BasePath = cfg.Swarming.Url + "/_ah/api/swarming/v1/"
         return svc
 }
 
 func (d *swarmingDist) Run(tsk *distributor.TaskDescription) (tok distributor.Token, _ time.Duration, err error) {
         auth := tsk.ExecutionAuth()
         id := auth.Id
         desc := tsk.Payload()
 
         params := &sv1.Parameters{}
         if err = jsonpb.UnmarshalString(desc.DistributorParameters, params); err != nil {
                 err = errors.Annotate(err).
                         Reason("unmarshalling DistributorParameters").
                         InternalReason("These paramaeters were already validated?").
                         Err()
                 return
         }
         if err = params.Normalize(); err != nil {
                 err = errors.Annotate(err).
                         Reason("normalizing DistributorParameters").
                         InternalReason("These paramaeters were already normalized successfully once?").
                         Err()
                 return
         }
 
         isoCtx, _ := context.WithTimeout(d, 30*time.Second)
-        iso, err := prepIsolate(isoCtx, d.sCfg.Isolate.Host, tsk, params)
+        iso, err := prepIsolate(isoCtx, d.sCfg.Isolate.Url, tsk, params)
         if err != nil {
                 err = errors.Annotate(err).Reason("prepping Isolated").Err()
                 return
         }
 
         topic, token, err := tsk.PrepareTopic()
         if err != nil {
                 err = errors.Annotate(err).Reason("preparing topic").Err()
                 return
         }
@@ skipping 142 matching lines @@
                                 Status: dm.AbnormalFinish_RESULT_MALFORMED,
                                 Reason: fmt.Sprintf("swarming: unknown state %s", rslt.State),
                         }
                 }
         }
 
         return ret, nil
 }
 
 func (d *swarmingDist) InfoURL(tok distributor.Token) string {
-        return fmt.Sprintf("https://%s/user/task/%s", d.sCfg.Swarming.Host, tok)
+        return fmt.Sprintf("%s/user/task/%s", d.sCfg.Swarming.Url, tok)
 }
 
 func (d *swarmingDist) HandleNotification(notification *distributor.Notification) (*dm.Result, error) {
         type Data struct {
                 TaskID distributor.Token `json:"task_id"`
         }
         dat := &Data{}
         if err := json.Unmarshal(notification.Data, dat); err != nil {
                 logging.Fields{"payload": notification.Data}.Errorf(
                         d, "Could not unmarshal swarming payload! relying on timeout.")
@@ skipping 16 matching lines @@
 
 func factory(c context.Context, cfg *distributor.Config) (distributor.D, error) {
         return &swarmingDist{c, cfg, cfg.Content.(*sv1.Config)}, nil
 }
 
 // AddFactory adds this distributor implementation into the distributor
 // Registry.
 func AddFactory(m distributor.FactoryMap) {
         m[(*sv1.Config)(nil)] = factory
 }