Use swarming in create_pagesets CT task

ct/go/util/util.go

 // Utility that contains methods for both CT master and worker scripts.
 package util
 
 import (
         "bufio"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "path"
         "path/filepath"
         "runtime"
         "strconv"
         "sync"
         "time"
 
         "go.skia.org/infra/go/exec"
+        "go.skia.org/infra/go/swarming"
         "go.skia.org/infra/go/util"
 
         "github.com/skia-dev/glog"
 )
 
 const (
         MAX_SYNC_TRIES = 3
 
         TS_FORMAT = "20060102150405"
 
@@ skipping 354 matching lines @@
                                 }))
                         }
                 }(i)
         }
 
         // Wait for all spawned goroutines to complete.
         wg.Wait()
 
         return nil
 }
+
+// GetStartRange returns the range worker should start processing at based on its num and how many
+// artifacts it is allowed to process.
+func GetStartRange(workerNum, artifactsPerWorker int) int {
+        return ((workerNum - 1) * artifactsPerWorker) + 1
+}
+
+// ArchiveTriggerCollectSwarmingTasks is a convenience function for CT scripts to call to
+// batch archive isolates, trigger swarming tasks, collect the triggered swarming tasks.
+func ArchiveTriggerCollectSwarmingTask(s *swarming.SwarmingClient, taskNames, genJSONs []string, hardTimeout, ioTimeout time.Duration) error {

[dogben, 2016/05/18 17:38:26]

Seems that taskNames is only used to verify tasksToHashes, but you could use
genJSONs for that purpose.

If you remove taskNames here, you can also simplify the code in
create_pagesets_on_workers.

[rmistry, 2016/05/19 12:59:50]

Keeping the taskNames check because of all the new code moved into this function
now.

[dogben, 2016/05/19 14:27:22]

I don't understand.

[rmistry, 2016/05/19 14:42:19]

Done.

+        // Batcharchive the tasks.
+        tasksToHashes, err := s.BatchArchiveTargets(genJSONs, BATCHARCHIVE_TIMEOUT)
+        if err != nil {
+                return fmt.Errorf("Could not batch archive targets: %s", err)
+        }
+        if len(taskNames) != len(tasksToHashes) {
+                return fmt.Errorf("len(taskNames) was %d and len(tasksToHashes) was %d", len(taskNames), len(tasksToHashes))
+        }
+        // Trigger swarming using the isolate hashes.
+        dimensions := map[string]string{"pool": SWARMING_POOL}
+        tasks, err := s.TriggerSwarmingTasks(tasksToHashes, dimensions, swarming.RECOMMENDED_PRIORITY, swarming.RECOMMENDED_EXPIRATION, hardTimeout, ioTimeout, false)
+        if err != nil {
+                return fmt.Errorf("Could not trigger swarming task: %s", err)
+        }
+        // Collect all tasks and log the ones that fail.
+        for _, task := range tasks {
+                if _, _, err := task.Collect(s); err != nil {
+                        glog.Errorf("task %s failed: %s", task.Title, err)
+                        continue
+                }
+        }
+        return nil
+}
+
+// GetPathToPyFiles returns the location of CT's python scripts.
+func GetPathToPyFiles(runOnSwarming bool) string {
+        var pathToPyFiles string

[dogben, 2016/05/18 17:38:26]

nit: just return rather than assigning to pathToPyFiles?

[rmistry, 2016/05/19 12:59:50]

Done.

+        if runOnSwarming {
+                pathToPyFiles = filepath.Join(filepath.Dir(filepath.Dir(os.Args[0])), "src", "go.skia.org", "infra", "ct", "py")
+        } else {
+                _, currentFile, _, _ := runtime.Caller(0)
+                pathToPyFiles = filepath.Join(filepath.Dir(filepath.Dir(filepath.Dir(currentFile))), "py")
+        }
+        return pathToPyFiles
+}