Make hard and IO timeouts configurable in swarming.go

go/swarming/swarming.go

 /*
         Utilities for isolating and swarming. See swarming_test.go for usage examples.
 */
 package swarming
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io/ioutil"
         "os"
         "path"
         "strconv"
         "time"
 
         "github.com/skia-dev/glog"
         "go.skia.org/infra/go/exec"
         "go.skia.org/infra/go/gitinfo"
         "go.skia.org/infra/go/util"
 )
 
 const (
-        ISOLATE_BINARY         = "isolate"
-        ISOLATE_SERVER         = "isolateserver.appspot.com"
-        SWARMING_SERVER        = "chromium-swarm.appspot.com"
-        LUCI_CLIENT_REPO       = "https://github.com/luci/client-py"
-        IO_TIMEOUT             = 20 * time.Minute
-        HARD_TIMEOUT           = 1 * time.Hour
-        RECOMMENDED_PRIORITY   = 90
-        RECOMMENDED_EXPIRATION = 4 * time.Hour
+        ISOLATE_BINARY           = "isolate"
+        ISOLATE_SERVER           = "isolateserver.appspot.com"
+        SWARMING_SERVER          = "chromium-swarm.appspot.com"
+        LUCI_CLIENT_REPO         = "https://github.com/luci/client-py"
+        RECOMMENDED_IO_TIMEOUT   = 20 * time.Minute
+        RECOMMENDED_HARD_TIMEOUT = 1 * time.Hour
+        RECOMMENDED_PRIORITY     = 90
+        RECOMMENDED_EXPIRATION   = 4 * time.Hour
 )
 
 type SwarmingClient struct {
         WorkDir        string
         IsolatedServer string
         SwarmingServer string
 }
 
 type SwarmingTask struct {
         Title        string
@@ skipping 13 matching lines @@
 
 type ShardOutputFormat struct {
         ExitCode string `json:"exit_code"`
         Output   string `json:"output"`
 }
 
 type TaskOutputFormat struct {
         Shards []ShardOutputFormat `json:"shards"`
 }
 
-func (t *SwarmingTask) Trigger(s *SwarmingClient) error {
+func (t *SwarmingTask) Trigger(s *SwarmingClient, hardTimeout, ioTimeout time.Duration) error {
         swarmingBinary := path.Join(s.WorkDir, "client-py", "swarming.py")
         if err := _VerifyBinaryExists(swarmingBinary); err != nil {
                 return fmt.Errorf("Could not find swarming binary: %s", err)
         }
 
         // Run swarming trigger.
         dumpJSON := path.Join(t.OutputDir, fmt.Sprintf("%s-trigger-output.json", t.Title))
         triggerArgs := []string{
                 "trigger",
                 "--swarming", s.SwarmingServer,
                 "--isolate-server", s.IsolatedServer,
                 "--priority", strconv.Itoa(t.Priority),
                 "--shards", strconv.Itoa(1),
                 "--task-name", t.Title,
                 "--dump-json", dumpJSON,
                 "--expiration", strconv.FormatFloat(t.Expiration.Seconds(), 'f', 0, 64),
-                "--io-timeout", strconv.FormatFloat(IO_TIMEOUT.Seconds(), 'f', 0, 64),
-                "--hard-timeout", strconv.FormatFloat(HARD_TIMEOUT.Seconds(), 'f', 0, 64),
+                "--io-timeout", strconv.FormatFloat(ioTimeout.Seconds(), 'f', 0, 64),
+                "--hard-timeout", strconv.FormatFloat(hardTimeout.Seconds(), 'f', 0, 64),
                 "--verbose",
         }
         for k, v := range t.Dimensions {
                 triggerArgs = append(triggerArgs, "--dimension", k, v)
         }
         if t.Idempotent {
                 triggerArgs = append(triggerArgs, "--idempotent")
         }
         triggerArgs = append(triggerArgs, t.IsolatedHash)
 
@@ skipping 142 matching lines @@
         }
         var tasksToHashes map[string]string
         if err := json.NewDecoder(bytes.NewReader(dumpFile)).Decode(&tasksToHashes); err != nil {
                 return nil, fmt.Errorf("Could not decode %s: %s", dumpJSON, err)
         }
 
         return tasksToHashes, nil
 }
 
 // Trigger swarming using the specified hashes and dimensions.
-func (s *SwarmingClient) TriggerSwarmingTasks(tasksToHashes map[string]string, dimensions map[string]string, priority int, expiration time.Duration, idempotent bool) ([]*SwarmingTask, error) {
+func (s *SwarmingClient) TriggerSwarmingTasks(tasksToHashes map[string]string, dimensions map[string]string, priority int, expiration, hardTimeout, ioTimeout time.Duration, idempotent bool) ([]*SwarmingTask, error) {
         tasks := []*SwarmingTask{}
 
         for taskName, hash := range tasksToHashes {
                 taskOutputDir := path.Join(s.WorkDir, taskName)
                 if err := os.MkdirAll(taskOutputDir, 0700); err != nil {
                         return nil, fmt.Errorf("Could not create %s: %s", taskOutputDir, err)
                 }
                 task := &SwarmingTask{
                         Title:        taskName,
                         IsolatedHash: hash,
                         OutputDir:    taskOutputDir,
                         Dimensions:   dimensions,
                         Priority:     priority,
                         Expiration:   expiration,
                         Idempotent:   idempotent,
                 }
-                if err := task.Trigger(s); err != nil {
+                if err := task.Trigger(s, hardTimeout, ioTimeout); err != nil {
                         return nil, fmt.Errorf("Could not trigger task %s: %s", taskName, err)
                 }
-                glog.Infof("Triggered the task: %s", task)
+                glog.Infof("Triggered the task: %v", task)
                 tasks = append(tasks, task)
         }
 
         return tasks, nil
 }
 
 func (s *SwarmingClient) Cleanup() {
         if err := os.RemoveAll(s.WorkDir); err != nil {
                 glog.Errorf("Could not cleanup swarming work dir: %s", err)
         }
 }
 
 func _VerifyBinaryExists(binary string) error {
         err := exec.Run(&exec.Command{
                 Name:      binary,
                 Args:      []string{"help"},
                 Timeout:   60 * time.Second,
-                LogStdout: true,
+                LogStdout: false,

[rmistry, 2016/05/18 13:10:48]

Eliminating noise in logs.

                 LogStderr: true,
         })
         if err != nil {
                 return fmt.Errorf("Error finding the binary %s: %s", binary, err)
         }
         return nil
 }