Refactor and test jobsim_client.

dm/tools/jobsim_client/main.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.
 
 // Jobsim client is a self-contained binary that implements various toy job
 // algorithms for use in testing DM with live distributors (like swarming).
 package main
 
 import (
         "encoding/json"
@@ skipping 94 matching lines @@
                 return err
         }, retry.LogCallback(r, "ActivateExecution"))
         if err != nil {
                 panic(err)
         }
 
         // activated with key!
         r.exAuth.Token = key
 }
 
-func (r *cmdRun) depOn(jobProperties ...interface{}) []string {
+func (r *cmdRun) depOn(jobProperties ...interface{}) (data []string, stop bool) {
         req := &dm.EnsureGraphDataReq{
                 ForExecution: r.exAuth,
 
                 Quest:        make([]*dm.Quest_Desc, len(jobProperties)),
                 QuestAttempt: make([]*dm.AttemptList_Nums, len(jobProperties)),
 
                 Include: &dm.EnsureGraphDataReq_Include{
                         Attempt: &dm.EnsureGraphDataReq_Include_Options{Result: true},
                 },
         }
@@ skipping 10 matching lines @@
 
         rsp := (*dm.EnsureGraphDataRsp)(nil)
         err := retry.Retry(r, retry.Default, func() (err error) {
                 rsp, err = r.client.EnsureGraphData(r, req)
                 return
         }, retry.LogCallback(r, "EnsureGraphData"))
         if err != nil {
                 panic(err)
         }
         if rsp.ShouldHalt {
-                logging.Infof(r, "got ShouldHalt, quitting")
-                os.Exit(0)
+                logging.Infof(r, "got ShouldHalt")
+                return nil, true
         }
 
         ret := make([]string, len(jobProperties))
         for i, qid := range rsp.QuestIds {
                 ret[i] = rsp.Result.Quests[qid.Id].Attempts[1].Data.GetFinished().Data.Object
         }
 
-        return ret
+        return ret, false
 }
 
-func (r *cmdRun) finish(data interface{}) {
+func (r *cmdRun) finish(data interface{}) int {
         encData, err := json.Marshal(data)
         if err != nil {
                 panic(err)
         }
         err = retry.Retry(r, retry.Default, func() error {
                 _, err := r.client.FinishAttempt(r, &dm.FinishAttemptReq{
                         Auth: r.exAuth, Data: dm.NewJsonResult(string(encData)),
                 })
                 return err
         }, retry.LogCallback(r, "FinishAttempt"))
         if err != nil {
                 panic(err)
         }
-        os.Exit(0)
+        return 0
 }
 
 // argErr prints an err and usage to stderr and returns an exit code.
 func (r *cmdRun) argErr(format string, a ...interface{}) int {
         if format != "" {
                 fmt.Fprintf(os.Stderr, format+"\n", a...)
         }
         fmt.Fprintln(os.Stderr, r.cmd.ShortDesc)
         fmt.Fprintln(os.Stderr, r.cmd.UsageLine)
         fmt.Fprintln(os.Stderr, "\nFlags:")
         r.Flags.PrintDefaults()
         return -1
 }
 
 var application = &cli.Application{
         Name:  "jobsim_client",
         Title: "Executable Job simulator client",
         Context: func(ctx context.Context) context.Context {
                 return gologger.StdConfig.Use(ctx)
         },
         Commands: []*subcommands.Command{
                 cmdEditDistance,
                 subcommands.CmdHelp,
         },
 }
 
 func main() {
         os.Exit(subcommands.Run(application, os.Args[1:]))
 }