Moving future to final 0.22.0 release and Mesos 1.6.2 (#114 )

Changes in compose testing setup: * Upgrading Aurora to 0.22.0 * Upgrading Mesos to 1.6.2
Adding autopause APIs to future (#110 )
2020-01-14 15:34:59 -08:00 · 2020-01-13 16:03:40 -08:00 · 2019-08-28 17:12:59 -07:00 · 2019-08-28 17:11:32 -07:00
16 changed files with 1970 additions and 1042 deletions
--- a/.auroraversion
+++ b/.auroraversion
@ -1 +1 @@
-0.21.0
+0.22.0
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,8 +1,17 @@
-1.21.1 (unreleased)
+1.22.0 (unreleased)
 * CreateService and StartJobUpdate do not continue retrying if a timeout has been encountered
 by the HTTP client. Instead they now return an error that conforms to the Timedout interface.
 Users can check for a Timedout error by using `realis.IsTimeout(err)`.
 * New API function VariableBatchStep has been added which returns the current batch at which
 a Variable Batch Update configured Update is currently in.
 * Added new PauseUpdateMonitor which monitors an update until it is an `ROLL_FORWARD_PAUSED` state.
 * Added variableBatchStep command to sample client to be used for testing new VariableBatchStep api.
 * JobUpdateStatus has changed function signature from:
 `JobUpdateStatus(updateKey aurora.JobUpdateKey, desiredStatuses map[aurora.JobUpdateStatus]bool, interval, timeout time.Duration) (aurora.JobUpdateStatus, error)`
 to
 `JobUpdateStatus(updateKey aurora.JobUpdateKey, desiredStatuses []aurora.JobUpdateStatus, interval, timeout time.Duration) (aurora.JobUpdateStatus, error)`
 * Added TerminalUpdateStates function which returns an slice containing all UpdateStates which are considered terminal states.
 1.21.0
@ -11,4 +20,6 @@ Users can check for a Timedout error by using `realis.IsTimeout(err)`.
 * `aurora.ACTIVE_STATES`, `aurora.SLAVE_ASSIGNED_STATES`, `aurora.LIVE_STATES`, `aurora.TERMINAL_STATES`, `aurora.ACTIVE_JOB_UPDATE_STATES`, `aurora.AWAITNG_PULSE_JOB_UPDATE_STATES` are all now generated as a slices.
 * Please use `realis.ActiveStates`, `realis.SlaveAssignedStates`,`realis.LiveStates`, `realis.TerminalStates`, `realis.ActiveJobUpdateStates`, `realis.AwaitingPulseJobUpdateStates` in their places when map representations are needed.
 * `GetInstanceIds(key *aurora.JobKey, states map[aurora.ScheduleStatus]bool) (map[int32]bool, error)` has changed signature to ` GetInstanceIds(key *aurora.JobKey, states []aurora.ScheduleStatus) ([]int32, error)`
-* Adding support for GPU as resource.
+* Adding support for GPU as resource.
 * Changing compose environment to Aurora snapshot in order to support staggered update.
 * Adding staggered updates API.
--- a/auroraAPI.thrift
+++ b/auroraAPI.thrift
@ -716,9 +716,40 @@ struct JobUpdateKey {
  2: string id
 }
 /** Limits the amount of active changes being made to instances to groupSize. */
 struct QueueJobUpdateStrategy {
  1: i32 groupSize
 }
 /** Similar to Queue strategy but will not start a new group until all instances in an active
 * group have finished updating.
 */
 struct BatchJobUpdateStrategy {
  1: i32 groupSize
  /* Update will pause automatically after each batch completes */
  2: bool autopauseAfterBatch
 }
 /** Same as Batch strategy but each time an active group completes, the size of the next active
 * group may change.
 */
 struct VariableBatchJobUpdateStrategy {
  1: list<i32> groupSizes
  /* Update will pause automatically after each batch completes */
  2: bool autopauseAfterBatch
 }
 union JobUpdateStrategy {
 1: QueueJobUpdateStrategy queueStrategy
 2: BatchJobUpdateStrategy batchStrategy
 3: VariableBatchJobUpdateStrategy varBatchStrategy
 }
 /** Job update thresholds and limits. */
 struct JobUpdateSettings {
-  /** Max number of instances being updated at any given moment. */
+  /** Deprecated, please set value inside of desired update strategy instead.
   * Max number of instances being updated at any given moment.
   */
  1: i32 updateGroupSize
  /** Max number of instance failures to tolerate before marking instance as FAILED. */
@ -736,7 +767,7 @@ struct JobUpdateSettings {
  /** Instance IDs to act on. All instances will be affected if this is not set. */
  7: set<Range> updateOnlyTheseInstances
-  /**
+  /** Deprecated, please set updateStrategy to the Batch strategy instead.
   * If true, use updateGroupSize as strict batching boundaries, and avoid proceeding to another
   * batch until the preceding batch finishes updating.
   */
@ -755,6 +786,9 @@ struct JobUpdateSettings {
   * differs between the old and new task configurations, updates will use the newest configuration.
   */
  10: optional bool slaAware
  /** Update strategy to be used for the update. See JobUpdateStrategy for choices. */
  11: optional JobUpdateStrategy updateStrategy
 }
 /** Event marking a state transition in job update lifecycle. */
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -14,7 +14,7 @@ services:
        ipv4_address: 192.168.33.2
  master:
-    image: rdelvalle/mesos-master:1.5.1
+    image: rdelvalle/mesos-master:1.6.2
    restart: on-failure
    ports:
    - "5050:5050"
@ -32,7 +32,7 @@ services:
    - zk
  agent-one:
-    image: rdelvalle/mesos-agent:1.5.1
+    image: rdelvalle/mesos-agent:1.6.2
    pid: host
    restart: on-failure
    ports:
@ -56,7 +56,7 @@ services:
    - zk
  agent-two:
-    image: rdelvalle/mesos-agent:1.5.1
+    image: rdelvalle/mesos-agent:1.6.2
    pid: host
    restart: on-failure
    ports:
@ -80,7 +80,7 @@ services:
      - zk
  aurora-one:
-    image: rdelvalle/aurora:0.21.0
+    image: rdelvalle/aurora:0.22.0
    pid: host
    ports:
    - "8081:8081"
--- a/examples/client.go
+++ b/examples/client.go
@ -451,6 +451,13 @@ func main() {
 		}
 		fmt.Println(resp.String())
 	case "variableBatchStep":
 		step, err := r.VariableBatchStep(aurora.JobUpdateKey{Job: job.JobKey(), ID: updateId})
 		if err != nil {
 			log.Fatal(err)
 		}
 		fmt.Println(step)
 	case "taskConfig":
 		fmt.Println("Getting job info")
 		live, err := r.GetInstanceIds(job.JobKey(), aurora.ACTIVE_STATES)
--- a/gen-go/apache/aurora/auroraAPI.go
+++ b/gen-go/apache/aurora/auroraAPI.go
--- a/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
+++ b/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
@ -195,19 +195,19 @@ func main() {
    }
    argvalue0 := flag.Arg(1)
    value0 := argvalue0
-    arg354 := flag.Arg(2)
+    arg355 := flag.Arg(2)
-    mbTrans355 := thrift.NewTMemoryBufferLen(len(arg354))
+    mbTrans356 := thrift.NewTMemoryBufferLen(len(arg355))
-    defer mbTrans355.Close()
+    defer mbTrans356.Close()
-    _, err356 := mbTrans355.WriteString(arg354)
+    _, err357 := mbTrans356.WriteString(arg355)
-    if err356 != nil {
+    if err357 != nil {
      Usage()
      return
    }
-    factory357 := thrift.NewTJSONProtocolFactory()
+    factory358 := thrift.NewTJSONProtocolFactory()
-    jsProt358 := factory357.GetProtocol(mbTrans355)
+    jsProt359 := factory358.GetProtocol(mbTrans356)
    argvalue1 := aurora.NewResourceAggregate()
-    err359 := argvalue1.Read(jsProt358)
+    err360 := argvalue1.Read(jsProt359)
-    if err359 != nil {
+    if err360 != nil {
      Usage()
      return
    }
@ -263,19 +263,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "QueryRecovery requires 1 args")
      flag.Usage()
    }
-    arg362 := flag.Arg(1)
+    arg363 := flag.Arg(1)
-    mbTrans363 := thrift.NewTMemoryBufferLen(len(arg362))
+    mbTrans364 := thrift.NewTMemoryBufferLen(len(arg363))
-    defer mbTrans363.Close()
+    defer mbTrans364.Close()
-    _, err364 := mbTrans363.WriteString(arg362)
+    _, err365 := mbTrans364.WriteString(arg363)
-    if err364 != nil {
+    if err365 != nil {
      Usage()
      return
    }
-    factory365 := thrift.NewTJSONProtocolFactory()
+    factory366 := thrift.NewTJSONProtocolFactory()
-    jsProt366 := factory365.GetProtocol(mbTrans363)
+    jsProt367 := factory366.GetProtocol(mbTrans364)
    argvalue0 := aurora.NewTaskQuery()
-    err367 := argvalue0.Read(jsProt366)
+    err368 := argvalue0.Read(jsProt367)
-    if err367 != nil {
+    if err368 != nil {
      Usage()
      return
    }
@ -288,19 +288,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "DeleteRecoveryTasks requires 1 args")
      flag.Usage()
    }
-    arg368 := flag.Arg(1)
+    arg369 := flag.Arg(1)
-    mbTrans369 := thrift.NewTMemoryBufferLen(len(arg368))
+    mbTrans370 := thrift.NewTMemoryBufferLen(len(arg369))
-    defer mbTrans369.Close()
+    defer mbTrans370.Close()
-    _, err370 := mbTrans369.WriteString(arg368)
+    _, err371 := mbTrans370.WriteString(arg369)
-    if err370 != nil {
+    if err371 != nil {
      Usage()
      return
    }
-    factory371 := thrift.NewTJSONProtocolFactory()
+    factory372 := thrift.NewTJSONProtocolFactory()
-    jsProt372 := factory371.GetProtocol(mbTrans369)
+    jsProt373 := factory372.GetProtocol(mbTrans370)
    argvalue0 := aurora.NewTaskQuery()
-    err373 := argvalue0.Read(jsProt372)
+    err374 := argvalue0.Read(jsProt373)
-    if err373 != nil {
+    if err374 != nil {
      Usage()
      return
    }
@ -329,19 +329,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "StartMaintenance requires 1 args")
      flag.Usage()
    }
-    arg374 := flag.Arg(1)
+    arg375 := flag.Arg(1)
-    mbTrans375 := thrift.NewTMemoryBufferLen(len(arg374))
+    mbTrans376 := thrift.NewTMemoryBufferLen(len(arg375))
-    defer mbTrans375.Close()
+    defer mbTrans376.Close()
-    _, err376 := mbTrans375.WriteString(arg374)
+    _, err377 := mbTrans376.WriteString(arg375)
-    if err376 != nil {
+    if err377 != nil {
      Usage()
      return
    }
-    factory377 := thrift.NewTJSONProtocolFactory()
+    factory378 := thrift.NewTJSONProtocolFactory()
-    jsProt378 := factory377.GetProtocol(mbTrans375)
+    jsProt379 := factory378.GetProtocol(mbTrans376)
    argvalue0 := aurora.NewHosts()
-    err379 := argvalue0.Read(jsProt378)
+    err380 := argvalue0.Read(jsProt379)
-    if err379 != nil {
+    if err380 != nil {
      Usage()
      return
    }
@ -354,19 +354,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "DrainHosts requires 1 args")
      flag.Usage()
    }
-    arg380 := flag.Arg(1)
+    arg381 := flag.Arg(1)
-    mbTrans381 := thrift.NewTMemoryBufferLen(len(arg380))
+    mbTrans382 := thrift.NewTMemoryBufferLen(len(arg381))
-    defer mbTrans381.Close()
+    defer mbTrans382.Close()
-    _, err382 := mbTrans381.WriteString(arg380)
+    _, err383 := mbTrans382.WriteString(arg381)
-    if err382 != nil {
+    if err383 != nil {
      Usage()
      return
    }
-    factory383 := thrift.NewTJSONProtocolFactory()
+    factory384 := thrift.NewTJSONProtocolFactory()
-    jsProt384 := factory383.GetProtocol(mbTrans381)
+    jsProt385 := factory384.GetProtocol(mbTrans382)
    argvalue0 := aurora.NewHosts()
-    err385 := argvalue0.Read(jsProt384)
+    err386 := argvalue0.Read(jsProt385)
-    if err385 != nil {
+    if err386 != nil {
      Usage()
      return
    }
@ -379,19 +379,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "MaintenanceStatus requires 1 args")
      flag.Usage()
    }
-    arg386 := flag.Arg(1)
+    arg387 := flag.Arg(1)
-    mbTrans387 := thrift.NewTMemoryBufferLen(len(arg386))
+    mbTrans388 := thrift.NewTMemoryBufferLen(len(arg387))
-    defer mbTrans387.Close()
+    defer mbTrans388.Close()
-    _, err388 := mbTrans387.WriteString(arg386)
+    _, err389 := mbTrans388.WriteString(arg387)
-    if err388 != nil {
+    if err389 != nil {
      Usage()
      return
    }
-    factory389 := thrift.NewTJSONProtocolFactory()
+    factory390 := thrift.NewTJSONProtocolFactory()
-    jsProt390 := factory389.GetProtocol(mbTrans387)
+    jsProt391 := factory390.GetProtocol(mbTrans388)
    argvalue0 := aurora.NewHosts()
-    err391 := argvalue0.Read(jsProt390)
+    err392 := argvalue0.Read(jsProt391)
-    if err391 != nil {
+    if err392 != nil {
      Usage()
      return
    }
@ -404,19 +404,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "EndMaintenance requires 1 args")
      flag.Usage()
    }
-    arg392 := flag.Arg(1)
+    arg393 := flag.Arg(1)
-    mbTrans393 := thrift.NewTMemoryBufferLen(len(arg392))
+    mbTrans394 := thrift.NewTMemoryBufferLen(len(arg393))
-    defer mbTrans393.Close()
+    defer mbTrans394.Close()
-    _, err394 := mbTrans393.WriteString(arg392)
+    _, err395 := mbTrans394.WriteString(arg393)
-    if err394 != nil {
+    if err395 != nil {
      Usage()
      return
    }
-    factory395 := thrift.NewTJSONProtocolFactory()
+    factory396 := thrift.NewTJSONProtocolFactory()
-    jsProt396 := factory395.GetProtocol(mbTrans393)
+    jsProt397 := factory396.GetProtocol(mbTrans394)
    argvalue0 := aurora.NewHosts()
-    err397 := argvalue0.Read(jsProt396)
+    err398 := argvalue0.Read(jsProt397)
-    if err397 != nil {
+    if err398 != nil {
      Usage()
      return
    }
@ -429,42 +429,42 @@ func main() {
      fmt.Fprintln(os.Stderr, "SlaDrainHosts requires 3 args")
      flag.Usage()
    }
-    arg398 := flag.Arg(1)
+    arg399 := flag.Arg(1)
-    mbTrans399 := thrift.NewTMemoryBufferLen(len(arg398))
+    mbTrans400 := thrift.NewTMemoryBufferLen(len(arg399))
-    defer mbTrans399.Close()
+    defer mbTrans400.Close()
-    _, err400 := mbTrans399.WriteString(arg398)
+    _, err401 := mbTrans400.WriteString(arg399)
-    if err400 != nil {
+    if err401 != nil {
      Usage()
      return
    }
-    factory401 := thrift.NewTJSONProtocolFactory()
+    factory402 := thrift.NewTJSONProtocolFactory()
-    jsProt402 := factory401.GetProtocol(mbTrans399)
+    jsProt403 := factory402.GetProtocol(mbTrans400)
    argvalue0 := aurora.NewHosts()
-    err403 := argvalue0.Read(jsProt402)
+    err404 := argvalue0.Read(jsProt403)
-    if err403 != nil {
+    if err404 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    arg404 := flag.Arg(2)
+    arg405 := flag.Arg(2)
-    mbTrans405 := thrift.NewTMemoryBufferLen(len(arg404))
+    mbTrans406 := thrift.NewTMemoryBufferLen(len(arg405))
-    defer mbTrans405.Close()
+    defer mbTrans406.Close()
-    _, err406 := mbTrans405.WriteString(arg404)
+    _, err407 := mbTrans406.WriteString(arg405)
-    if err406 != nil {
+    if err407 != nil {
      Usage()
      return
    }
-    factory407 := thrift.NewTJSONProtocolFactory()
+    factory408 := thrift.NewTJSONProtocolFactory()
-    jsProt408 := factory407.GetProtocol(mbTrans405)
+    jsProt409 := factory408.GetProtocol(mbTrans406)
    argvalue1 := aurora.NewSlaPolicy()
-    err409 := argvalue1.Read(jsProt408)
+    err410 := argvalue1.Read(jsProt409)
-    if err409 != nil {
+    if err410 != nil {
      Usage()
      return
    }
    value1 := argvalue1
-    argvalue2, err410 := (strconv.ParseInt(flag.Arg(3), 10, 64))
+    argvalue2, err411 := (strconv.ParseInt(flag.Arg(3), 10, 64))
-    if err410 != nil {
+    if err411 != nil {
      Usage()
      return
    }
@ -485,19 +485,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "TriggerExplicitTaskReconciliation requires 1 args")
      flag.Usage()
    }
-    arg411 := flag.Arg(1)
+    arg412 := flag.Arg(1)
-    mbTrans412 := thrift.NewTMemoryBufferLen(len(arg411))
+    mbTrans413 := thrift.NewTMemoryBufferLen(len(arg412))
-    defer mbTrans412.Close()
+    defer mbTrans413.Close()
-    _, err413 := mbTrans412.WriteString(arg411)
+    _, err414 := mbTrans413.WriteString(arg412)
-    if err413 != nil {
+    if err414 != nil {
      Usage()
      return
    }
-    factory414 := thrift.NewTJSONProtocolFactory()
+    factory415 := thrift.NewTJSONProtocolFactory()
-    jsProt415 := factory414.GetProtocol(mbTrans412)
+    jsProt416 := factory415.GetProtocol(mbTrans413)
    argvalue0 := aurora.NewExplicitReconciliationSettings()
-    err416 := argvalue0.Read(jsProt415)
+    err417 := argvalue0.Read(jsProt416)
-    if err416 != nil {
+    if err417 != nil {
      Usage()
      return
    }
@ -518,19 +518,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PruneTasks requires 1 args")
      flag.Usage()
    }
-    arg417 := flag.Arg(1)
+    arg418 := flag.Arg(1)
-    mbTrans418 := thrift.NewTMemoryBufferLen(len(arg417))
+    mbTrans419 := thrift.NewTMemoryBufferLen(len(arg418))
-    defer mbTrans418.Close()
+    defer mbTrans419.Close()
-    _, err419 := mbTrans418.WriteString(arg417)
+    _, err420 := mbTrans419.WriteString(arg418)
-    if err419 != nil {
+    if err420 != nil {
      Usage()
      return
    }
-    factory420 := thrift.NewTJSONProtocolFactory()
+    factory421 := thrift.NewTJSONProtocolFactory()
-    jsProt421 := factory420.GetProtocol(mbTrans418)
+    jsProt422 := factory421.GetProtocol(mbTrans419)
    argvalue0 := aurora.NewTaskQuery()
-    err422 := argvalue0.Read(jsProt421)
+    err423 := argvalue0.Read(jsProt422)
-    if err422 != nil {
+    if err423 != nil {
      Usage()
      return
    }
@ -543,19 +543,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
      flag.Usage()
    }
-    arg423 := flag.Arg(1)
+    arg424 := flag.Arg(1)
-    mbTrans424 := thrift.NewTMemoryBufferLen(len(arg423))
+    mbTrans425 := thrift.NewTMemoryBufferLen(len(arg424))
-    defer mbTrans424.Close()
+    defer mbTrans425.Close()
-    _, err425 := mbTrans424.WriteString(arg423)
+    _, err426 := mbTrans425.WriteString(arg424)
-    if err425 != nil {
+    if err426 != nil {
      Usage()
      return
    }
-    factory426 := thrift.NewTJSONProtocolFactory()
+    factory427 := thrift.NewTJSONProtocolFactory()
-    jsProt427 := factory426.GetProtocol(mbTrans424)
+    jsProt428 := factory427.GetProtocol(mbTrans425)
    argvalue0 := aurora.NewJobConfiguration()
-    err428 := argvalue0.Read(jsProt427)
+    err429 := argvalue0.Read(jsProt428)
-    if err428 != nil {
+    if err429 != nil {
      Usage()
      return
    }
@ -568,19 +568,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
      flag.Usage()
    }
-    arg429 := flag.Arg(1)
+    arg430 := flag.Arg(1)
-    mbTrans430 := thrift.NewTMemoryBufferLen(len(arg429))
+    mbTrans431 := thrift.NewTMemoryBufferLen(len(arg430))
-    defer mbTrans430.Close()
+    defer mbTrans431.Close()
-    _, err431 := mbTrans430.WriteString(arg429)
+    _, err432 := mbTrans431.WriteString(arg430)
-    if err431 != nil {
+    if err432 != nil {
      Usage()
      return
    }
-    factory432 := thrift.NewTJSONProtocolFactory()
+    factory433 := thrift.NewTJSONProtocolFactory()
-    jsProt433 := factory432.GetProtocol(mbTrans430)
+    jsProt434 := factory433.GetProtocol(mbTrans431)
    argvalue0 := aurora.NewJobConfiguration()
-    err434 := argvalue0.Read(jsProt433)
+    err435 := argvalue0.Read(jsProt434)
-    if err434 != nil {
+    if err435 != nil {
      Usage()
      return
    }
@ -593,19 +593,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
      flag.Usage()
    }
-    arg435 := flag.Arg(1)
+    arg436 := flag.Arg(1)
-    mbTrans436 := thrift.NewTMemoryBufferLen(len(arg435))
+    mbTrans437 := thrift.NewTMemoryBufferLen(len(arg436))
-    defer mbTrans436.Close()
+    defer mbTrans437.Close()
-    _, err437 := mbTrans436.WriteString(arg435)
+    _, err438 := mbTrans437.WriteString(arg436)
-    if err437 != nil {
+    if err438 != nil {
      Usage()
      return
    }
-    factory438 := thrift.NewTJSONProtocolFactory()
+    factory439 := thrift.NewTJSONProtocolFactory()
-    jsProt439 := factory438.GetProtocol(mbTrans436)
+    jsProt440 := factory439.GetProtocol(mbTrans437)
    argvalue0 := aurora.NewJobKey()
-    err440 := argvalue0.Read(jsProt439)
+    err441 := argvalue0.Read(jsProt440)
-    if err440 != nil {
+    if err441 != nil {
      Usage()
      return
    }
@ -618,19 +618,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
      flag.Usage()
    }
-    arg441 := flag.Arg(1)
+    arg442 := flag.Arg(1)
-    mbTrans442 := thrift.NewTMemoryBufferLen(len(arg441))
+    mbTrans443 := thrift.NewTMemoryBufferLen(len(arg442))
-    defer mbTrans442.Close()
+    defer mbTrans443.Close()
-    _, err443 := mbTrans442.WriteString(arg441)
+    _, err444 := mbTrans443.WriteString(arg442)
-    if err443 != nil {
+    if err444 != nil {
      Usage()
      return
    }
-    factory444 := thrift.NewTJSONProtocolFactory()
+    factory445 := thrift.NewTJSONProtocolFactory()
-    jsProt445 := factory444.GetProtocol(mbTrans442)
+    jsProt446 := factory445.GetProtocol(mbTrans443)
    argvalue0 := aurora.NewJobKey()
-    err446 := argvalue0.Read(jsProt445)
+    err447 := argvalue0.Read(jsProt446)
-    if err446 != nil {
+    if err447 != nil {
      Usage()
      return
    }
@ -643,36 +643,36 @@ func main() {
      fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
      flag.Usage()
    }
-    arg447 := flag.Arg(1)
+    arg448 := flag.Arg(1)
-    mbTrans448 := thrift.NewTMemoryBufferLen(len(arg447))
+    mbTrans449 := thrift.NewTMemoryBufferLen(len(arg448))
-    defer mbTrans448.Close()
+    defer mbTrans449.Close()
-    _, err449 := mbTrans448.WriteString(arg447)
+    _, err450 := mbTrans449.WriteString(arg448)
-    if err449 != nil {
+    if err450 != nil {
      Usage()
      return
    }
-    factory450 := thrift.NewTJSONProtocolFactory()
+    factory451 := thrift.NewTJSONProtocolFactory()
-    jsProt451 := factory450.GetProtocol(mbTrans448)
+    jsProt452 := factory451.GetProtocol(mbTrans449)
    argvalue0 := aurora.NewJobKey()
-    err452 := argvalue0.Read(jsProt451)
+    err453 := argvalue0.Read(jsProt452)
-    if err452 != nil {
+    if err453 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    arg453 := flag.Arg(2)
+    arg454 := flag.Arg(2)
-    mbTrans454 := thrift.NewTMemoryBufferLen(len(arg453))
+    mbTrans455 := thrift.NewTMemoryBufferLen(len(arg454))
-    defer mbTrans454.Close()
+    defer mbTrans455.Close()
-    _, err455 := mbTrans454.WriteString(arg453)
+    _, err456 := mbTrans455.WriteString(arg454)
-    if err455 != nil { 
+    if err456 != nil { 
      Usage()
      return
    }
-    factory456 := thrift.NewTJSONProtocolFactory()
+    factory457 := thrift.NewTJSONProtocolFactory()
-    jsProt457 := factory456.GetProtocol(mbTrans454)
+    jsProt458 := factory457.GetProtocol(mbTrans455)
    containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
-    err458 := containerStruct1.ReadField2(jsProt457)
+    err459 := containerStruct1.ReadField2(jsProt458)
-    if err458 != nil {
+    if err459 != nil {
      Usage()
      return
    }
@ -686,36 +686,36 @@ func main() {
      fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
      flag.Usage()
    }
-    arg459 := flag.Arg(1)
+    arg460 := flag.Arg(1)
-    mbTrans460 := thrift.NewTMemoryBufferLen(len(arg459))
+    mbTrans461 := thrift.NewTMemoryBufferLen(len(arg460))
-    defer mbTrans460.Close()
+    defer mbTrans461.Close()
-    _, err461 := mbTrans460.WriteString(arg459)
+    _, err462 := mbTrans461.WriteString(arg460)
-    if err461 != nil {
+    if err462 != nil {
      Usage()
      return
    }
-    factory462 := thrift.NewTJSONProtocolFactory()
+    factory463 := thrift.NewTJSONProtocolFactory()
-    jsProt463 := factory462.GetProtocol(mbTrans460)
+    jsProt464 := factory463.GetProtocol(mbTrans461)
    argvalue0 := aurora.NewJobKey()
-    err464 := argvalue0.Read(jsProt463)
+    err465 := argvalue0.Read(jsProt464)
-    if err464 != nil {
+    if err465 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    arg465 := flag.Arg(2)
+    arg466 := flag.Arg(2)
-    mbTrans466 := thrift.NewTMemoryBufferLen(len(arg465))
+    mbTrans467 := thrift.NewTMemoryBufferLen(len(arg466))
-    defer mbTrans466.Close()
+    defer mbTrans467.Close()
-    _, err467 := mbTrans466.WriteString(arg465)
+    _, err468 := mbTrans467.WriteString(arg466)
-    if err467 != nil { 
+    if err468 != nil { 
      Usage()
      return
    }
-    factory468 := thrift.NewTJSONProtocolFactory()
+    factory469 := thrift.NewTJSONProtocolFactory()
-    jsProt469 := factory468.GetProtocol(mbTrans466)
+    jsProt470 := factory469.GetProtocol(mbTrans467)
    containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
-    err470 := containerStruct1.ReadField2(jsProt469)
+    err471 := containerStruct1.ReadField2(jsProt470)
-    if err470 != nil {
+    if err471 != nil {
      Usage()
      return
    }
@ -731,25 +731,25 @@ func main() {
      fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
      flag.Usage()
    }
-    arg472 := flag.Arg(1)
+    arg473 := flag.Arg(1)
-    mbTrans473 := thrift.NewTMemoryBufferLen(len(arg472))
+    mbTrans474 := thrift.NewTMemoryBufferLen(len(arg473))
-    defer mbTrans473.Close()
+    defer mbTrans474.Close()
-    _, err474 := mbTrans473.WriteString(arg472)
+    _, err475 := mbTrans474.WriteString(arg473)
-    if err474 != nil {
+    if err475 != nil {
      Usage()
      return
    }
-    factory475 := thrift.NewTJSONProtocolFactory()
+    factory476 := thrift.NewTJSONProtocolFactory()
-    jsProt476 := factory475.GetProtocol(mbTrans473)
+    jsProt477 := factory476.GetProtocol(mbTrans474)
    argvalue0 := aurora.NewInstanceKey()
-    err477 := argvalue0.Read(jsProt476)
+    err478 := argvalue0.Read(jsProt477)
-    if err477 != nil {
+    if err478 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    tmp1, err478 := (strconv.Atoi(flag.Arg(2)))
+    tmp1, err479 := (strconv.Atoi(flag.Arg(2)))
-    if err478 != nil {
+    if err479 != nil {
      Usage()
      return
    }
@ -763,19 +763,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
      flag.Usage()
    }
-    arg479 := flag.Arg(1)
+    arg480 := flag.Arg(1)
-    mbTrans480 := thrift.NewTMemoryBufferLen(len(arg479))
+    mbTrans481 := thrift.NewTMemoryBufferLen(len(arg480))
-    defer mbTrans480.Close()
+    defer mbTrans481.Close()
-    _, err481 := mbTrans480.WriteString(arg479)
+    _, err482 := mbTrans481.WriteString(arg480)
-    if err481 != nil {
+    if err482 != nil {
      Usage()
      return
    }
-    factory482 := thrift.NewTJSONProtocolFactory()
+    factory483 := thrift.NewTJSONProtocolFactory()
-    jsProt483 := factory482.GetProtocol(mbTrans480)
+    jsProt484 := factory483.GetProtocol(mbTrans481)
    argvalue0 := aurora.NewJobConfiguration()
-    err484 := argvalue0.Read(jsProt483)
+    err485 := argvalue0.Read(jsProt484)
-    if err484 != nil {
+    if err485 != nil {
      Usage()
      return
    }
@ -788,19 +788,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg485 := flag.Arg(1)
+    arg486 := flag.Arg(1)
-    mbTrans486 := thrift.NewTMemoryBufferLen(len(arg485))
+    mbTrans487 := thrift.NewTMemoryBufferLen(len(arg486))
-    defer mbTrans486.Close()
+    defer mbTrans487.Close()
-    _, err487 := mbTrans486.WriteString(arg485)
+    _, err488 := mbTrans487.WriteString(arg486)
-    if err487 != nil {
+    if err488 != nil {
      Usage()
      return
    }
-    factory488 := thrift.NewTJSONProtocolFactory()
+    factory489 := thrift.NewTJSONProtocolFactory()
-    jsProt489 := factory488.GetProtocol(mbTrans486)
+    jsProt490 := factory489.GetProtocol(mbTrans487)
    argvalue0 := aurora.NewJobUpdateRequest()
-    err490 := argvalue0.Read(jsProt489)
+    err491 := argvalue0.Read(jsProt490)
-    if err490 != nil {
+    if err491 != nil {
      Usage()
      return
    }
@ -815,19 +815,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg492 := flag.Arg(1)
+    arg493 := flag.Arg(1)
-    mbTrans493 := thrift.NewTMemoryBufferLen(len(arg492))
+    mbTrans494 := thrift.NewTMemoryBufferLen(len(arg493))
-    defer mbTrans493.Close()
+    defer mbTrans494.Close()
-    _, err494 := mbTrans493.WriteString(arg492)
+    _, err495 := mbTrans494.WriteString(arg493)
-    if err494 != nil {
+    if err495 != nil {
      Usage()
      return
    }
-    factory495 := thrift.NewTJSONProtocolFactory()
+    factory496 := thrift.NewTJSONProtocolFactory()
-    jsProt496 := factory495.GetProtocol(mbTrans493)
+    jsProt497 := factory496.GetProtocol(mbTrans494)
    argvalue0 := aurora.NewJobUpdateKey()
-    err497 := argvalue0.Read(jsProt496)
+    err498 := argvalue0.Read(jsProt497)
-    if err497 != nil {
+    if err498 != nil {
      Usage()
      return
    }
@ -842,19 +842,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg499 := flag.Arg(1)
+    arg500 := flag.Arg(1)
-    mbTrans500 := thrift.NewTMemoryBufferLen(len(arg499))
+    mbTrans501 := thrift.NewTMemoryBufferLen(len(arg500))
-    defer mbTrans500.Close()
+    defer mbTrans501.Close()
-    _, err501 := mbTrans500.WriteString(arg499)
+    _, err502 := mbTrans501.WriteString(arg500)
-    if err501 != nil {
+    if err502 != nil {
      Usage()
      return
    }
-    factory502 := thrift.NewTJSONProtocolFactory()
+    factory503 := thrift.NewTJSONProtocolFactory()
-    jsProt503 := factory502.GetProtocol(mbTrans500)
+    jsProt504 := factory503.GetProtocol(mbTrans501)
    argvalue0 := aurora.NewJobUpdateKey()
-    err504 := argvalue0.Read(jsProt503)
+    err505 := argvalue0.Read(jsProt504)
-    if err504 != nil {
+    if err505 != nil {
      Usage()
      return
    }
@ -869,19 +869,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg506 := flag.Arg(1)
+    arg507 := flag.Arg(1)
-    mbTrans507 := thrift.NewTMemoryBufferLen(len(arg506))
+    mbTrans508 := thrift.NewTMemoryBufferLen(len(arg507))
-    defer mbTrans507.Close()
+    defer mbTrans508.Close()
-    _, err508 := mbTrans507.WriteString(arg506)
+    _, err509 := mbTrans508.WriteString(arg507)
-    if err508 != nil {
+    if err509 != nil {
      Usage()
      return
    }
-    factory509 := thrift.NewTJSONProtocolFactory()
+    factory510 := thrift.NewTJSONProtocolFactory()
-    jsProt510 := factory509.GetProtocol(mbTrans507)
+    jsProt511 := factory510.GetProtocol(mbTrans508)
    argvalue0 := aurora.NewJobUpdateKey()
-    err511 := argvalue0.Read(jsProt510)
+    err512 := argvalue0.Read(jsProt511)
-    if err511 != nil {
+    if err512 != nil {
      Usage()
      return
    }
@ -896,19 +896,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg513 := flag.Arg(1)
+    arg514 := flag.Arg(1)
-    mbTrans514 := thrift.NewTMemoryBufferLen(len(arg513))
+    mbTrans515 := thrift.NewTMemoryBufferLen(len(arg514))
-    defer mbTrans514.Close()
+    defer mbTrans515.Close()
-    _, err515 := mbTrans514.WriteString(arg513)
+    _, err516 := mbTrans515.WriteString(arg514)
-    if err515 != nil {
+    if err516 != nil {
      Usage()
      return
    }
-    factory516 := thrift.NewTJSONProtocolFactory()
+    factory517 := thrift.NewTJSONProtocolFactory()
-    jsProt517 := factory516.GetProtocol(mbTrans514)
+    jsProt518 := factory517.GetProtocol(mbTrans515)
    argvalue0 := aurora.NewJobUpdateKey()
-    err518 := argvalue0.Read(jsProt517)
+    err519 := argvalue0.Read(jsProt518)
-    if err518 != nil {
+    if err519 != nil {
      Usage()
      return
    }
@ -923,19 +923,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
      flag.Usage()
    }
-    arg520 := flag.Arg(1)
+    arg521 := flag.Arg(1)
-    mbTrans521 := thrift.NewTMemoryBufferLen(len(arg520))
+    mbTrans522 := thrift.NewTMemoryBufferLen(len(arg521))
-    defer mbTrans521.Close()
+    defer mbTrans522.Close()
-    _, err522 := mbTrans521.WriteString(arg520)
+    _, err523 := mbTrans522.WriteString(arg521)
-    if err522 != nil {
+    if err523 != nil {
      Usage()
      return
    }
-    factory523 := thrift.NewTJSONProtocolFactory()
+    factory524 := thrift.NewTJSONProtocolFactory()
-    jsProt524 := factory523.GetProtocol(mbTrans521)
+    jsProt525 := factory524.GetProtocol(mbTrans522)
    argvalue0 := aurora.NewJobUpdateKey()
-    err525 := argvalue0.Read(jsProt524)
+    err526 := argvalue0.Read(jsProt525)
-    if err525 != nil {
+    if err526 != nil {
      Usage()
      return
    }
@ -966,19 +966,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
      flag.Usage()
    }
-    arg527 := flag.Arg(1)
+    arg528 := flag.Arg(1)
-    mbTrans528 := thrift.NewTMemoryBufferLen(len(arg527))
+    mbTrans529 := thrift.NewTMemoryBufferLen(len(arg528))
-    defer mbTrans528.Close()
+    defer mbTrans529.Close()
-    _, err529 := mbTrans528.WriteString(arg527)
+    _, err530 := mbTrans529.WriteString(arg528)
-    if err529 != nil {
+    if err530 != nil {
      Usage()
      return
    }
-    factory530 := thrift.NewTJSONProtocolFactory()
+    factory531 := thrift.NewTJSONProtocolFactory()
-    jsProt531 := factory530.GetProtocol(mbTrans528)
+    jsProt532 := factory531.GetProtocol(mbTrans529)
    argvalue0 := aurora.NewTaskQuery()
-    err532 := argvalue0.Read(jsProt531)
+    err533 := argvalue0.Read(jsProt532)
-    if err532 != nil {
+    if err533 != nil {
      Usage()
      return
    }
@ -991,19 +991,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
      flag.Usage()
    }
-    arg533 := flag.Arg(1)
+    arg534 := flag.Arg(1)
-    mbTrans534 := thrift.NewTMemoryBufferLen(len(arg533))
+    mbTrans535 := thrift.NewTMemoryBufferLen(len(arg534))
-    defer mbTrans534.Close()
+    defer mbTrans535.Close()
-    _, err535 := mbTrans534.WriteString(arg533)
+    _, err536 := mbTrans535.WriteString(arg534)
-    if err535 != nil {
+    if err536 != nil {
      Usage()
      return
    }
-    factory536 := thrift.NewTJSONProtocolFactory()
+    factory537 := thrift.NewTJSONProtocolFactory()
-    jsProt537 := factory536.GetProtocol(mbTrans534)
+    jsProt538 := factory537.GetProtocol(mbTrans535)
    argvalue0 := aurora.NewTaskQuery()
-    err538 := argvalue0.Read(jsProt537)
+    err539 := argvalue0.Read(jsProt538)
-    if err538 != nil {
+    if err539 != nil {
      Usage()
      return
    }
@ -1016,19 +1016,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
      flag.Usage()
    }
-    arg539 := flag.Arg(1)
+    arg540 := flag.Arg(1)
-    mbTrans540 := thrift.NewTMemoryBufferLen(len(arg539))
+    mbTrans541 := thrift.NewTMemoryBufferLen(len(arg540))
-    defer mbTrans540.Close()
+    defer mbTrans541.Close()
-    _, err541 := mbTrans540.WriteString(arg539)
+    _, err542 := mbTrans541.WriteString(arg540)
-    if err541 != nil {
+    if err542 != nil {
      Usage()
      return
    }
-    factory542 := thrift.NewTJSONProtocolFactory()
+    factory543 := thrift.NewTJSONProtocolFactory()
-    jsProt543 := factory542.GetProtocol(mbTrans540)
+    jsProt544 := factory543.GetProtocol(mbTrans541)
    argvalue0 := aurora.NewTaskQuery()
-    err544 := argvalue0.Read(jsProt543)
+    err545 := argvalue0.Read(jsProt544)
-    if err544 != nil {
+    if err545 != nil {
      Usage()
      return
    }
@ -1041,19 +1041,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
      flag.Usage()
    }
-    arg545 := flag.Arg(1)
+    arg546 := flag.Arg(1)
-    mbTrans546 := thrift.NewTMemoryBufferLen(len(arg545))
+    mbTrans547 := thrift.NewTMemoryBufferLen(len(arg546))
-    defer mbTrans546.Close()
+    defer mbTrans547.Close()
-    _, err547 := mbTrans546.WriteString(arg545)
+    _, err548 := mbTrans547.WriteString(arg546)
-    if err547 != nil {
+    if err548 != nil {
      Usage()
      return
    }
-    factory548 := thrift.NewTJSONProtocolFactory()
+    factory549 := thrift.NewTJSONProtocolFactory()
-    jsProt549 := factory548.GetProtocol(mbTrans546)
+    jsProt550 := factory549.GetProtocol(mbTrans547)
    argvalue0 := aurora.NewJobKey()
-    err550 := argvalue0.Read(jsProt549)
+    err551 := argvalue0.Read(jsProt550)
-    if err550 != nil {
+    if err551 != nil {
      Usage()
      return
    }
@ -1086,19 +1086,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
      flag.Usage()
    }
-    arg553 := flag.Arg(1)
+    arg554 := flag.Arg(1)
-    mbTrans554 := thrift.NewTMemoryBufferLen(len(arg553))
+    mbTrans555 := thrift.NewTMemoryBufferLen(len(arg554))
-    defer mbTrans554.Close()
+    defer mbTrans555.Close()
-    _, err555 := mbTrans554.WriteString(arg553)
+    _, err556 := mbTrans555.WriteString(arg554)
-    if err555 != nil {
+    if err556 != nil {
      Usage()
      return
    }
-    factory556 := thrift.NewTJSONProtocolFactory()
+    factory557 := thrift.NewTJSONProtocolFactory()
-    jsProt557 := factory556.GetProtocol(mbTrans554)
+    jsProt558 := factory557.GetProtocol(mbTrans555)
    argvalue0 := aurora.NewJobConfiguration()
-    err558 := argvalue0.Read(jsProt557)
+    err559 := argvalue0.Read(jsProt558)
-    if err558 != nil {
+    if err559 != nil {
      Usage()
      return
    }
@ -1111,19 +1111,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
      flag.Usage()
    }
-    arg559 := flag.Arg(1)
+    arg560 := flag.Arg(1)
-    mbTrans560 := thrift.NewTMemoryBufferLen(len(arg559))
+    mbTrans561 := thrift.NewTMemoryBufferLen(len(arg560))
-    defer mbTrans560.Close()
+    defer mbTrans561.Close()
-    _, err561 := mbTrans560.WriteString(arg559)
+    _, err562 := mbTrans561.WriteString(arg560)
-    if err561 != nil {
+    if err562 != nil {
      Usage()
      return
    }
-    factory562 := thrift.NewTJSONProtocolFactory()
+    factory563 := thrift.NewTJSONProtocolFactory()
-    jsProt563 := factory562.GetProtocol(mbTrans560)
+    jsProt564 := factory563.GetProtocol(mbTrans561)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err564 := argvalue0.Read(jsProt563)
+    err565 := argvalue0.Read(jsProt564)
-    if err564 != nil {
+    if err565 != nil {
      Usage()
      return
    }
@ -1136,19 +1136,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
      flag.Usage()
    }
-    arg565 := flag.Arg(1)
+    arg566 := flag.Arg(1)
-    mbTrans566 := thrift.NewTMemoryBufferLen(len(arg565))
+    mbTrans567 := thrift.NewTMemoryBufferLen(len(arg566))
-    defer mbTrans566.Close()
+    defer mbTrans567.Close()
-    _, err567 := mbTrans566.WriteString(arg565)
+    _, err568 := mbTrans567.WriteString(arg566)
-    if err567 != nil {
+    if err568 != nil {
      Usage()
      return
    }
-    factory568 := thrift.NewTJSONProtocolFactory()
+    factory569 := thrift.NewTJSONProtocolFactory()
-    jsProt569 := factory568.GetProtocol(mbTrans566)
+    jsProt570 := factory569.GetProtocol(mbTrans567)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err570 := argvalue0.Read(jsProt569)
+    err571 := argvalue0.Read(jsProt570)
-    if err570 != nil {
+    if err571 != nil {
      Usage()
      return
    }
@ -1161,19 +1161,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
      flag.Usage()
    }
-    arg571 := flag.Arg(1)
+    arg572 := flag.Arg(1)
-    mbTrans572 := thrift.NewTMemoryBufferLen(len(arg571))
+    mbTrans573 := thrift.NewTMemoryBufferLen(len(arg572))
-    defer mbTrans572.Close()
+    defer mbTrans573.Close()
-    _, err573 := mbTrans572.WriteString(arg571)
+    _, err574 := mbTrans573.WriteString(arg572)
-    if err573 != nil {
+    if err574 != nil {
      Usage()
      return
    }
-    factory574 := thrift.NewTJSONProtocolFactory()
+    factory575 := thrift.NewTJSONProtocolFactory()
-    jsProt575 := factory574.GetProtocol(mbTrans572)
+    jsProt576 := factory575.GetProtocol(mbTrans573)
    argvalue0 := aurora.NewJobUpdateRequest()
-    err576 := argvalue0.Read(jsProt575)
+    err577 := argvalue0.Read(jsProt576)
-    if err576 != nil {
+    if err577 != nil {
      Usage()
      return
    }
--- a/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
+++ b/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
@ -175,19 +175,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
      flag.Usage()
    }
-    arg162 := flag.Arg(1)
+    arg163 := flag.Arg(1)
-    mbTrans163 := thrift.NewTMemoryBufferLen(len(arg162))
+    mbTrans164 := thrift.NewTMemoryBufferLen(len(arg163))
-    defer mbTrans163.Close()
+    defer mbTrans164.Close()
-    _, err164 := mbTrans163.WriteString(arg162)
+    _, err165 := mbTrans164.WriteString(arg163)
-    if err164 != nil {
+    if err165 != nil {
      Usage()
      return
    }
-    factory165 := thrift.NewTJSONProtocolFactory()
+    factory166 := thrift.NewTJSONProtocolFactory()
-    jsProt166 := factory165.GetProtocol(mbTrans163)
+    jsProt167 := factory166.GetProtocol(mbTrans164)
    argvalue0 := aurora.NewJobConfiguration()
-    err167 := argvalue0.Read(jsProt166)
+    err168 := argvalue0.Read(jsProt167)
-    if err167 != nil {
+    if err168 != nil {
      Usage()
      return
    }
@ -200,19 +200,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
      flag.Usage()
    }
-    arg168 := flag.Arg(1)
+    arg169 := flag.Arg(1)
-    mbTrans169 := thrift.NewTMemoryBufferLen(len(arg168))
+    mbTrans170 := thrift.NewTMemoryBufferLen(len(arg169))
-    defer mbTrans169.Close()
+    defer mbTrans170.Close()
-    _, err170 := mbTrans169.WriteString(arg168)
+    _, err171 := mbTrans170.WriteString(arg169)
-    if err170 != nil {
+    if err171 != nil {
      Usage()
      return
    }
-    factory171 := thrift.NewTJSONProtocolFactory()
+    factory172 := thrift.NewTJSONProtocolFactory()
-    jsProt172 := factory171.GetProtocol(mbTrans169)
+    jsProt173 := factory172.GetProtocol(mbTrans170)
    argvalue0 := aurora.NewJobConfiguration()
-    err173 := argvalue0.Read(jsProt172)
+    err174 := argvalue0.Read(jsProt173)
-    if err173 != nil {
+    if err174 != nil {
      Usage()
      return
    }
@ -225,19 +225,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
      flag.Usage()
    }
-    arg174 := flag.Arg(1)
+    arg175 := flag.Arg(1)
-    mbTrans175 := thrift.NewTMemoryBufferLen(len(arg174))
+    mbTrans176 := thrift.NewTMemoryBufferLen(len(arg175))
-    defer mbTrans175.Close()
+    defer mbTrans176.Close()
-    _, err176 := mbTrans175.WriteString(arg174)
+    _, err177 := mbTrans176.WriteString(arg175)
-    if err176 != nil {
+    if err177 != nil {
      Usage()
      return
    }
-    factory177 := thrift.NewTJSONProtocolFactory()
+    factory178 := thrift.NewTJSONProtocolFactory()
-    jsProt178 := factory177.GetProtocol(mbTrans175)
+    jsProt179 := factory178.GetProtocol(mbTrans176)
    argvalue0 := aurora.NewJobKey()
-    err179 := argvalue0.Read(jsProt178)
+    err180 := argvalue0.Read(jsProt179)
-    if err179 != nil {
+    if err180 != nil {
      Usage()
      return
    }
@ -250,19 +250,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
      flag.Usage()
    }
-    arg180 := flag.Arg(1)
+    arg181 := flag.Arg(1)
-    mbTrans181 := thrift.NewTMemoryBufferLen(len(arg180))
+    mbTrans182 := thrift.NewTMemoryBufferLen(len(arg181))
-    defer mbTrans181.Close()
+    defer mbTrans182.Close()
-    _, err182 := mbTrans181.WriteString(arg180)
+    _, err183 := mbTrans182.WriteString(arg181)
-    if err182 != nil {
+    if err183 != nil {
      Usage()
      return
    }
-    factory183 := thrift.NewTJSONProtocolFactory()
+    factory184 := thrift.NewTJSONProtocolFactory()
-    jsProt184 := factory183.GetProtocol(mbTrans181)
+    jsProt185 := factory184.GetProtocol(mbTrans182)
    argvalue0 := aurora.NewJobKey()
-    err185 := argvalue0.Read(jsProt184)
+    err186 := argvalue0.Read(jsProt185)
-    if err185 != nil {
+    if err186 != nil {
      Usage()
      return
    }
@ -275,36 +275,36 @@ func main() {
      fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
      flag.Usage()
    }
-    arg186 := flag.Arg(1)
+    arg187 := flag.Arg(1)
-    mbTrans187 := thrift.NewTMemoryBufferLen(len(arg186))
+    mbTrans188 := thrift.NewTMemoryBufferLen(len(arg187))
-    defer mbTrans187.Close()
+    defer mbTrans188.Close()
-    _, err188 := mbTrans187.WriteString(arg186)
+    _, err189 := mbTrans188.WriteString(arg187)
-    if err188 != nil {
+    if err189 != nil {
      Usage()
      return
    }
-    factory189 := thrift.NewTJSONProtocolFactory()
+    factory190 := thrift.NewTJSONProtocolFactory()
-    jsProt190 := factory189.GetProtocol(mbTrans187)
+    jsProt191 := factory190.GetProtocol(mbTrans188)
    argvalue0 := aurora.NewJobKey()
-    err191 := argvalue0.Read(jsProt190)
+    err192 := argvalue0.Read(jsProt191)
-    if err191 != nil {
+    if err192 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    arg192 := flag.Arg(2)
+    arg193 := flag.Arg(2)
-    mbTrans193 := thrift.NewTMemoryBufferLen(len(arg192))
+    mbTrans194 := thrift.NewTMemoryBufferLen(len(arg193))
-    defer mbTrans193.Close()
+    defer mbTrans194.Close()
-    _, err194 := mbTrans193.WriteString(arg192)
+    _, err195 := mbTrans194.WriteString(arg193)
-    if err194 != nil { 
+    if err195 != nil { 
      Usage()
      return
    }
-    factory195 := thrift.NewTJSONProtocolFactory()
+    factory196 := thrift.NewTJSONProtocolFactory()
-    jsProt196 := factory195.GetProtocol(mbTrans193)
+    jsProt197 := factory196.GetProtocol(mbTrans194)
    containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
-    err197 := containerStruct1.ReadField2(jsProt196)
+    err198 := containerStruct1.ReadField2(jsProt197)
-    if err197 != nil {
+    if err198 != nil {
      Usage()
      return
    }
@ -318,36 +318,36 @@ func main() {
      fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
      flag.Usage()
    }
-    arg198 := flag.Arg(1)
+    arg199 := flag.Arg(1)
-    mbTrans199 := thrift.NewTMemoryBufferLen(len(arg198))
+    mbTrans200 := thrift.NewTMemoryBufferLen(len(arg199))
-    defer mbTrans199.Close()
+    defer mbTrans200.Close()
-    _, err200 := mbTrans199.WriteString(arg198)
+    _, err201 := mbTrans200.WriteString(arg199)
-    if err200 != nil {
+    if err201 != nil {
      Usage()
      return
    }
-    factory201 := thrift.NewTJSONProtocolFactory()
+    factory202 := thrift.NewTJSONProtocolFactory()
-    jsProt202 := factory201.GetProtocol(mbTrans199)
+    jsProt203 := factory202.GetProtocol(mbTrans200)
    argvalue0 := aurora.NewJobKey()
-    err203 := argvalue0.Read(jsProt202)
+    err204 := argvalue0.Read(jsProt203)
-    if err203 != nil {
+    if err204 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    arg204 := flag.Arg(2)
+    arg205 := flag.Arg(2)
-    mbTrans205 := thrift.NewTMemoryBufferLen(len(arg204))
+    mbTrans206 := thrift.NewTMemoryBufferLen(len(arg205))
-    defer mbTrans205.Close()
+    defer mbTrans206.Close()
-    _, err206 := mbTrans205.WriteString(arg204)
+    _, err207 := mbTrans206.WriteString(arg205)
-    if err206 != nil { 
+    if err207 != nil { 
      Usage()
      return
    }
-    factory207 := thrift.NewTJSONProtocolFactory()
+    factory208 := thrift.NewTJSONProtocolFactory()
-    jsProt208 := factory207.GetProtocol(mbTrans205)
+    jsProt209 := factory208.GetProtocol(mbTrans206)
    containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
-    err209 := containerStruct1.ReadField2(jsProt208)
+    err210 := containerStruct1.ReadField2(jsProt209)
-    if err209 != nil {
+    if err210 != nil {
      Usage()
      return
    }
@ -363,25 +363,25 @@ func main() {
      fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
      flag.Usage()
    }
-    arg211 := flag.Arg(1)
+    arg212 := flag.Arg(1)
-    mbTrans212 := thrift.NewTMemoryBufferLen(len(arg211))
+    mbTrans213 := thrift.NewTMemoryBufferLen(len(arg212))
-    defer mbTrans212.Close()
+    defer mbTrans213.Close()
-    _, err213 := mbTrans212.WriteString(arg211)
+    _, err214 := mbTrans213.WriteString(arg212)
-    if err213 != nil {
+    if err214 != nil {
      Usage()
      return
    }
-    factory214 := thrift.NewTJSONProtocolFactory()
+    factory215 := thrift.NewTJSONProtocolFactory()
-    jsProt215 := factory214.GetProtocol(mbTrans212)
+    jsProt216 := factory215.GetProtocol(mbTrans213)
    argvalue0 := aurora.NewInstanceKey()
-    err216 := argvalue0.Read(jsProt215)
+    err217 := argvalue0.Read(jsProt216)
-    if err216 != nil {
+    if err217 != nil {
      Usage()
      return
    }
    value0 := argvalue0
-    tmp1, err217 := (strconv.Atoi(flag.Arg(2)))
+    tmp1, err218 := (strconv.Atoi(flag.Arg(2)))
-    if err217 != nil {
+    if err218 != nil {
      Usage()
      return
    }
@ -395,19 +395,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
      flag.Usage()
    }
-    arg218 := flag.Arg(1)
+    arg219 := flag.Arg(1)
-    mbTrans219 := thrift.NewTMemoryBufferLen(len(arg218))
+    mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
-    defer mbTrans219.Close()
+    defer mbTrans220.Close()
-    _, err220 := mbTrans219.WriteString(arg218)
+    _, err221 := mbTrans220.WriteString(arg219)
-    if err220 != nil {
+    if err221 != nil {
      Usage()
      return
    }
-    factory221 := thrift.NewTJSONProtocolFactory()
+    factory222 := thrift.NewTJSONProtocolFactory()
-    jsProt222 := factory221.GetProtocol(mbTrans219)
+    jsProt223 := factory222.GetProtocol(mbTrans220)
    argvalue0 := aurora.NewJobConfiguration()
-    err223 := argvalue0.Read(jsProt222)
+    err224 := argvalue0.Read(jsProt223)
-    if err223 != nil {
+    if err224 != nil {
      Usage()
      return
    }
@ -420,19 +420,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg224 := flag.Arg(1)
+    arg225 := flag.Arg(1)
-    mbTrans225 := thrift.NewTMemoryBufferLen(len(arg224))
+    mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
-    defer mbTrans225.Close()
+    defer mbTrans226.Close()
-    _, err226 := mbTrans225.WriteString(arg224)
+    _, err227 := mbTrans226.WriteString(arg225)
-    if err226 != nil {
+    if err227 != nil {
      Usage()
      return
    }
-    factory227 := thrift.NewTJSONProtocolFactory()
+    factory228 := thrift.NewTJSONProtocolFactory()
-    jsProt228 := factory227.GetProtocol(mbTrans225)
+    jsProt229 := factory228.GetProtocol(mbTrans226)
    argvalue0 := aurora.NewJobUpdateRequest()
-    err229 := argvalue0.Read(jsProt228)
+    err230 := argvalue0.Read(jsProt229)
-    if err229 != nil {
+    if err230 != nil {
      Usage()
      return
    }
@ -447,19 +447,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg231 := flag.Arg(1)
+    arg232 := flag.Arg(1)
-    mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
+    mbTrans233 := thrift.NewTMemoryBufferLen(len(arg232))
-    defer mbTrans232.Close()
+    defer mbTrans233.Close()
-    _, err233 := mbTrans232.WriteString(arg231)
+    _, err234 := mbTrans233.WriteString(arg232)
-    if err233 != nil {
+    if err234 != nil {
      Usage()
      return
    }
-    factory234 := thrift.NewTJSONProtocolFactory()
+    factory235 := thrift.NewTJSONProtocolFactory()
-    jsProt235 := factory234.GetProtocol(mbTrans232)
+    jsProt236 := factory235.GetProtocol(mbTrans233)
    argvalue0 := aurora.NewJobUpdateKey()
-    err236 := argvalue0.Read(jsProt235)
+    err237 := argvalue0.Read(jsProt236)
-    if err236 != nil {
+    if err237 != nil {
      Usage()
      return
    }
@ -474,19 +474,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg238 := flag.Arg(1)
+    arg239 := flag.Arg(1)
-    mbTrans239 := thrift.NewTMemoryBufferLen(len(arg238))
+    mbTrans240 := thrift.NewTMemoryBufferLen(len(arg239))
-    defer mbTrans239.Close()
+    defer mbTrans240.Close()
-    _, err240 := mbTrans239.WriteString(arg238)
+    _, err241 := mbTrans240.WriteString(arg239)
-    if err240 != nil {
+    if err241 != nil {
      Usage()
      return
    }
-    factory241 := thrift.NewTJSONProtocolFactory()
+    factory242 := thrift.NewTJSONProtocolFactory()
-    jsProt242 := factory241.GetProtocol(mbTrans239)
+    jsProt243 := factory242.GetProtocol(mbTrans240)
    argvalue0 := aurora.NewJobUpdateKey()
-    err243 := argvalue0.Read(jsProt242)
+    err244 := argvalue0.Read(jsProt243)
-    if err243 != nil {
+    if err244 != nil {
      Usage()
      return
    }
@ -501,19 +501,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg245 := flag.Arg(1)
+    arg246 := flag.Arg(1)
-    mbTrans246 := thrift.NewTMemoryBufferLen(len(arg245))
+    mbTrans247 := thrift.NewTMemoryBufferLen(len(arg246))
-    defer mbTrans246.Close()
+    defer mbTrans247.Close()
-    _, err247 := mbTrans246.WriteString(arg245)
+    _, err248 := mbTrans247.WriteString(arg246)
-    if err247 != nil {
+    if err248 != nil {
      Usage()
      return
    }
-    factory248 := thrift.NewTJSONProtocolFactory()
+    factory249 := thrift.NewTJSONProtocolFactory()
-    jsProt249 := factory248.GetProtocol(mbTrans246)
+    jsProt250 := factory249.GetProtocol(mbTrans247)
    argvalue0 := aurora.NewJobUpdateKey()
-    err250 := argvalue0.Read(jsProt249)
+    err251 := argvalue0.Read(jsProt250)
-    if err250 != nil {
+    if err251 != nil {
      Usage()
      return
    }
@ -528,19 +528,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
      flag.Usage()
    }
-    arg252 := flag.Arg(1)
+    arg253 := flag.Arg(1)
-    mbTrans253 := thrift.NewTMemoryBufferLen(len(arg252))
+    mbTrans254 := thrift.NewTMemoryBufferLen(len(arg253))
-    defer mbTrans253.Close()
+    defer mbTrans254.Close()
-    _, err254 := mbTrans253.WriteString(arg252)
+    _, err255 := mbTrans254.WriteString(arg253)
-    if err254 != nil {
+    if err255 != nil {
      Usage()
      return
    }
-    factory255 := thrift.NewTJSONProtocolFactory()
+    factory256 := thrift.NewTJSONProtocolFactory()
-    jsProt256 := factory255.GetProtocol(mbTrans253)
+    jsProt257 := factory256.GetProtocol(mbTrans254)
    argvalue0 := aurora.NewJobUpdateKey()
-    err257 := argvalue0.Read(jsProt256)
+    err258 := argvalue0.Read(jsProt257)
-    if err257 != nil {
+    if err258 != nil {
      Usage()
      return
    }
@ -555,19 +555,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
      flag.Usage()
    }
-    arg259 := flag.Arg(1)
+    arg260 := flag.Arg(1)
-    mbTrans260 := thrift.NewTMemoryBufferLen(len(arg259))
+    mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
-    defer mbTrans260.Close()
+    defer mbTrans261.Close()
-    _, err261 := mbTrans260.WriteString(arg259)
+    _, err262 := mbTrans261.WriteString(arg260)
-    if err261 != nil {
+    if err262 != nil {
      Usage()
      return
    }
-    factory262 := thrift.NewTJSONProtocolFactory()
+    factory263 := thrift.NewTJSONProtocolFactory()
-    jsProt263 := factory262.GetProtocol(mbTrans260)
+    jsProt264 := factory263.GetProtocol(mbTrans261)
    argvalue0 := aurora.NewJobUpdateKey()
-    err264 := argvalue0.Read(jsProt263)
+    err265 := argvalue0.Read(jsProt264)
-    if err264 != nil {
+    if err265 != nil {
      Usage()
      return
    }
@ -598,19 +598,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
      flag.Usage()
    }
-    arg266 := flag.Arg(1)
+    arg267 := flag.Arg(1)
-    mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
+    mbTrans268 := thrift.NewTMemoryBufferLen(len(arg267))
-    defer mbTrans267.Close()
+    defer mbTrans268.Close()
-    _, err268 := mbTrans267.WriteString(arg266)
+    _, err269 := mbTrans268.WriteString(arg267)
-    if err268 != nil {
+    if err269 != nil {
      Usage()
      return
    }
-    factory269 := thrift.NewTJSONProtocolFactory()
+    factory270 := thrift.NewTJSONProtocolFactory()
-    jsProt270 := factory269.GetProtocol(mbTrans267)
+    jsProt271 := factory270.GetProtocol(mbTrans268)
    argvalue0 := aurora.NewTaskQuery()
-    err271 := argvalue0.Read(jsProt270)
+    err272 := argvalue0.Read(jsProt271)
-    if err271 != nil {
+    if err272 != nil {
      Usage()
      return
    }
@ -623,19 +623,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
      flag.Usage()
    }
-    arg272 := flag.Arg(1)
+    arg273 := flag.Arg(1)
-    mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
+    mbTrans274 := thrift.NewTMemoryBufferLen(len(arg273))
-    defer mbTrans273.Close()
+    defer mbTrans274.Close()
-    _, err274 := mbTrans273.WriteString(arg272)
+    _, err275 := mbTrans274.WriteString(arg273)
-    if err274 != nil {
+    if err275 != nil {
      Usage()
      return
    }
-    factory275 := thrift.NewTJSONProtocolFactory()
+    factory276 := thrift.NewTJSONProtocolFactory()
-    jsProt276 := factory275.GetProtocol(mbTrans273)
+    jsProt277 := factory276.GetProtocol(mbTrans274)
    argvalue0 := aurora.NewTaskQuery()
-    err277 := argvalue0.Read(jsProt276)
+    err278 := argvalue0.Read(jsProt277)
-    if err277 != nil {
+    if err278 != nil {
      Usage()
      return
    }
@ -648,19 +648,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
      flag.Usage()
    }
-    arg278 := flag.Arg(1)
+    arg279 := flag.Arg(1)
-    mbTrans279 := thrift.NewTMemoryBufferLen(len(arg278))
+    mbTrans280 := thrift.NewTMemoryBufferLen(len(arg279))
-    defer mbTrans279.Close()
+    defer mbTrans280.Close()
-    _, err280 := mbTrans279.WriteString(arg278)
+    _, err281 := mbTrans280.WriteString(arg279)
-    if err280 != nil {
+    if err281 != nil {
      Usage()
      return
    }
-    factory281 := thrift.NewTJSONProtocolFactory()
+    factory282 := thrift.NewTJSONProtocolFactory()
-    jsProt282 := factory281.GetProtocol(mbTrans279)
+    jsProt283 := factory282.GetProtocol(mbTrans280)
    argvalue0 := aurora.NewTaskQuery()
-    err283 := argvalue0.Read(jsProt282)
+    err284 := argvalue0.Read(jsProt283)
-    if err283 != nil {
+    if err284 != nil {
      Usage()
      return
    }
@ -673,19 +673,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
      flag.Usage()
    }
-    arg284 := flag.Arg(1)
+    arg285 := flag.Arg(1)
-    mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
+    mbTrans286 := thrift.NewTMemoryBufferLen(len(arg285))
-    defer mbTrans285.Close()
+    defer mbTrans286.Close()
-    _, err286 := mbTrans285.WriteString(arg284)
+    _, err287 := mbTrans286.WriteString(arg285)
-    if err286 != nil {
+    if err287 != nil {
      Usage()
      return
    }
-    factory287 := thrift.NewTJSONProtocolFactory()
+    factory288 := thrift.NewTJSONProtocolFactory()
-    jsProt288 := factory287.GetProtocol(mbTrans285)
+    jsProt289 := factory288.GetProtocol(mbTrans286)
    argvalue0 := aurora.NewJobKey()
-    err289 := argvalue0.Read(jsProt288)
+    err290 := argvalue0.Read(jsProt289)
-    if err289 != nil {
+    if err290 != nil {
      Usage()
      return
    }
@ -718,19 +718,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
      flag.Usage()
    }
-    arg292 := flag.Arg(1)
+    arg293 := flag.Arg(1)
-    mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
+    mbTrans294 := thrift.NewTMemoryBufferLen(len(arg293))
-    defer mbTrans293.Close()
+    defer mbTrans294.Close()
-    _, err294 := mbTrans293.WriteString(arg292)
+    _, err295 := mbTrans294.WriteString(arg293)
-    if err294 != nil {
+    if err295 != nil {
      Usage()
      return
    }
-    factory295 := thrift.NewTJSONProtocolFactory()
+    factory296 := thrift.NewTJSONProtocolFactory()
-    jsProt296 := factory295.GetProtocol(mbTrans293)
+    jsProt297 := factory296.GetProtocol(mbTrans294)
    argvalue0 := aurora.NewJobConfiguration()
-    err297 := argvalue0.Read(jsProt296)
+    err298 := argvalue0.Read(jsProt297)
-    if err297 != nil {
+    if err298 != nil {
      Usage()
      return
    }
@ -743,19 +743,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
      flag.Usage()
    }
-    arg298 := flag.Arg(1)
+    arg299 := flag.Arg(1)
-    mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
+    mbTrans300 := thrift.NewTMemoryBufferLen(len(arg299))
-    defer mbTrans299.Close()
+    defer mbTrans300.Close()
-    _, err300 := mbTrans299.WriteString(arg298)
+    _, err301 := mbTrans300.WriteString(arg299)
-    if err300 != nil {
+    if err301 != nil {
      Usage()
      return
    }
-    factory301 := thrift.NewTJSONProtocolFactory()
+    factory302 := thrift.NewTJSONProtocolFactory()
-    jsProt302 := factory301.GetProtocol(mbTrans299)
+    jsProt303 := factory302.GetProtocol(mbTrans300)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err303 := argvalue0.Read(jsProt302)
+    err304 := argvalue0.Read(jsProt303)
-    if err303 != nil {
+    if err304 != nil {
      Usage()
      return
    }
@ -768,19 +768,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
      flag.Usage()
    }
-    arg304 := flag.Arg(1)
+    arg305 := flag.Arg(1)
-    mbTrans305 := thrift.NewTMemoryBufferLen(len(arg304))
+    mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
-    defer mbTrans305.Close()
+    defer mbTrans306.Close()
-    _, err306 := mbTrans305.WriteString(arg304)
+    _, err307 := mbTrans306.WriteString(arg305)
-    if err306 != nil {
+    if err307 != nil {
      Usage()
      return
    }
-    factory307 := thrift.NewTJSONProtocolFactory()
+    factory308 := thrift.NewTJSONProtocolFactory()
-    jsProt308 := factory307.GetProtocol(mbTrans305)
+    jsProt309 := factory308.GetProtocol(mbTrans306)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err309 := argvalue0.Read(jsProt308)
+    err310 := argvalue0.Read(jsProt309)
-    if err309 != nil {
+    if err310 != nil {
      Usage()
      return
    }
@ -793,19 +793,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
      flag.Usage()
    }
-    arg310 := flag.Arg(1)
+    arg311 := flag.Arg(1)
-    mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
+    mbTrans312 := thrift.NewTMemoryBufferLen(len(arg311))
-    defer mbTrans311.Close()
+    defer mbTrans312.Close()
-    _, err312 := mbTrans311.WriteString(arg310)
+    _, err313 := mbTrans312.WriteString(arg311)
-    if err312 != nil {
+    if err313 != nil {
      Usage()
      return
    }
-    factory313 := thrift.NewTJSONProtocolFactory()
+    factory314 := thrift.NewTJSONProtocolFactory()
-    jsProt314 := factory313.GetProtocol(mbTrans311)
+    jsProt315 := factory314.GetProtocol(mbTrans312)
    argvalue0 := aurora.NewJobUpdateRequest()
-    err315 := argvalue0.Read(jsProt314)
+    err316 := argvalue0.Read(jsProt315)
-    if err315 != nil {
+    if err316 != nil {
      Usage()
      return
    }
--- a/gen-go/apache/aurora/read_only_scheduler-remote/read_only_scheduler-remote.go
+++ b/gen-go/apache/aurora/read_only_scheduler-remote/read_only_scheduler-remote.go
@ -179,19 +179,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
      flag.Usage()
    }
-    arg81 := flag.Arg(1)
+    arg82 := flag.Arg(1)
-    mbTrans82 := thrift.NewTMemoryBufferLen(len(arg81))
+    mbTrans83 := thrift.NewTMemoryBufferLen(len(arg82))
-    defer mbTrans82.Close()
+    defer mbTrans83.Close()
-    _, err83 := mbTrans82.WriteString(arg81)
+    _, err84 := mbTrans83.WriteString(arg82)
-    if err83 != nil {
+    if err84 != nil {
      Usage()
      return
    }
-    factory84 := thrift.NewTJSONProtocolFactory()
+    factory85 := thrift.NewTJSONProtocolFactory()
-    jsProt85 := factory84.GetProtocol(mbTrans82)
+    jsProt86 := factory85.GetProtocol(mbTrans83)
    argvalue0 := aurora.NewTaskQuery()
-    err86 := argvalue0.Read(jsProt85)
+    err87 := argvalue0.Read(jsProt86)
-    if err86 != nil {
+    if err87 != nil {
      Usage()
      return
    }
@ -204,19 +204,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
      flag.Usage()
    }
-    arg87 := flag.Arg(1)
+    arg88 := flag.Arg(1)
-    mbTrans88 := thrift.NewTMemoryBufferLen(len(arg87))
+    mbTrans89 := thrift.NewTMemoryBufferLen(len(arg88))
-    defer mbTrans88.Close()
+    defer mbTrans89.Close()
-    _, err89 := mbTrans88.WriteString(arg87)
+    _, err90 := mbTrans89.WriteString(arg88)
-    if err89 != nil {
+    if err90 != nil {
      Usage()
      return
    }
-    factory90 := thrift.NewTJSONProtocolFactory()
+    factory91 := thrift.NewTJSONProtocolFactory()
-    jsProt91 := factory90.GetProtocol(mbTrans88)
+    jsProt92 := factory91.GetProtocol(mbTrans89)
    argvalue0 := aurora.NewTaskQuery()
-    err92 := argvalue0.Read(jsProt91)
+    err93 := argvalue0.Read(jsProt92)
-    if err92 != nil {
+    if err93 != nil {
      Usage()
      return
    }
@ -229,19 +229,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
      flag.Usage()
    }
-    arg93 := flag.Arg(1)
+    arg94 := flag.Arg(1)
-    mbTrans94 := thrift.NewTMemoryBufferLen(len(arg93))
+    mbTrans95 := thrift.NewTMemoryBufferLen(len(arg94))
-    defer mbTrans94.Close()
+    defer mbTrans95.Close()
-    _, err95 := mbTrans94.WriteString(arg93)
+    _, err96 := mbTrans95.WriteString(arg94)
-    if err95 != nil {
+    if err96 != nil {
      Usage()
      return
    }
-    factory96 := thrift.NewTJSONProtocolFactory()
+    factory97 := thrift.NewTJSONProtocolFactory()
-    jsProt97 := factory96.GetProtocol(mbTrans94)
+    jsProt98 := factory97.GetProtocol(mbTrans95)
    argvalue0 := aurora.NewTaskQuery()
-    err98 := argvalue0.Read(jsProt97)
+    err99 := argvalue0.Read(jsProt98)
-    if err98 != nil {
+    if err99 != nil {
      Usage()
      return
    }
@ -254,19 +254,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
      flag.Usage()
    }
-    arg99 := flag.Arg(1)
+    arg100 := flag.Arg(1)
-    mbTrans100 := thrift.NewTMemoryBufferLen(len(arg99))
+    mbTrans101 := thrift.NewTMemoryBufferLen(len(arg100))
-    defer mbTrans100.Close()
+    defer mbTrans101.Close()
-    _, err101 := mbTrans100.WriteString(arg99)
+    _, err102 := mbTrans101.WriteString(arg100)
-    if err101 != nil {
+    if err102 != nil {
      Usage()
      return
    }
-    factory102 := thrift.NewTJSONProtocolFactory()
+    factory103 := thrift.NewTJSONProtocolFactory()
-    jsProt103 := factory102.GetProtocol(mbTrans100)
+    jsProt104 := factory103.GetProtocol(mbTrans101)
    argvalue0 := aurora.NewJobKey()
-    err104 := argvalue0.Read(jsProt103)
+    err105 := argvalue0.Read(jsProt104)
-    if err104 != nil {
+    if err105 != nil {
      Usage()
      return
    }
@ -299,19 +299,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
      flag.Usage()
    }
-    arg107 := flag.Arg(1)
+    arg108 := flag.Arg(1)
-    mbTrans108 := thrift.NewTMemoryBufferLen(len(arg107))
+    mbTrans109 := thrift.NewTMemoryBufferLen(len(arg108))
-    defer mbTrans108.Close()
+    defer mbTrans109.Close()
-    _, err109 := mbTrans108.WriteString(arg107)
+    _, err110 := mbTrans109.WriteString(arg108)
-    if err109 != nil {
+    if err110 != nil {
      Usage()
      return
    }
-    factory110 := thrift.NewTJSONProtocolFactory()
+    factory111 := thrift.NewTJSONProtocolFactory()
-    jsProt111 := factory110.GetProtocol(mbTrans108)
+    jsProt112 := factory111.GetProtocol(mbTrans109)
    argvalue0 := aurora.NewJobConfiguration()
-    err112 := argvalue0.Read(jsProt111)
+    err113 := argvalue0.Read(jsProt112)
-    if err112 != nil {
+    if err113 != nil {
      Usage()
      return
    }
@ -324,19 +324,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
      flag.Usage()
    }
-    arg113 := flag.Arg(1)
+    arg114 := flag.Arg(1)
-    mbTrans114 := thrift.NewTMemoryBufferLen(len(arg113))
+    mbTrans115 := thrift.NewTMemoryBufferLen(len(arg114))
-    defer mbTrans114.Close()
+    defer mbTrans115.Close()
-    _, err115 := mbTrans114.WriteString(arg113)
+    _, err116 := mbTrans115.WriteString(arg114)
-    if err115 != nil {
+    if err116 != nil {
      Usage()
      return
    }
-    factory116 := thrift.NewTJSONProtocolFactory()
+    factory117 := thrift.NewTJSONProtocolFactory()
-    jsProt117 := factory116.GetProtocol(mbTrans114)
+    jsProt118 := factory117.GetProtocol(mbTrans115)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err118 := argvalue0.Read(jsProt117)
+    err119 := argvalue0.Read(jsProt118)
-    if err118 != nil {
+    if err119 != nil {
      Usage()
      return
    }
@ -349,19 +349,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
      flag.Usage()
    }
-    arg119 := flag.Arg(1)
+    arg120 := flag.Arg(1)
-    mbTrans120 := thrift.NewTMemoryBufferLen(len(arg119))
+    mbTrans121 := thrift.NewTMemoryBufferLen(len(arg120))
-    defer mbTrans120.Close()
+    defer mbTrans121.Close()
-    _, err121 := mbTrans120.WriteString(arg119)
+    _, err122 := mbTrans121.WriteString(arg120)
-    if err121 != nil {
+    if err122 != nil {
      Usage()
      return
    }
-    factory122 := thrift.NewTJSONProtocolFactory()
+    factory123 := thrift.NewTJSONProtocolFactory()
-    jsProt123 := factory122.GetProtocol(mbTrans120)
+    jsProt124 := factory123.GetProtocol(mbTrans121)
    argvalue0 := aurora.NewJobUpdateQuery()
-    err124 := argvalue0.Read(jsProt123)
+    err125 := argvalue0.Read(jsProt124)
-    if err124 != nil {
+    if err125 != nil {
      Usage()
      return
    }
@ -374,19 +374,19 @@ func main() {
      fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
      flag.Usage()
    }
-    arg125 := flag.Arg(1)
+    arg126 := flag.Arg(1)
-    mbTrans126 := thrift.NewTMemoryBufferLen(len(arg125))
+    mbTrans127 := thrift.NewTMemoryBufferLen(len(arg126))
-    defer mbTrans126.Close()
+    defer mbTrans127.Close()
-    _, err127 := mbTrans126.WriteString(arg125)
+    _, err128 := mbTrans127.WriteString(arg126)
-    if err127 != nil {
+    if err128 != nil {
      Usage()
      return
    }
-    factory128 := thrift.NewTJSONProtocolFactory()
+    factory129 := thrift.NewTJSONProtocolFactory()
-    jsProt129 := factory128.GetProtocol(mbTrans126)
+    jsProt130 := factory129.GetProtocol(mbTrans127)
    argvalue0 := aurora.NewJobUpdateRequest()
-    err130 := argvalue0.Read(jsProt129)
+    err131 := argvalue0.Read(jsProt130)
-    if err130 != nil {
+    if err131 != nil {
      Usage()
      return
    }
--- a/generateBindings.sh
+++ b/generateBindings.sh
@ -1,6 +1,6 @@
 #! /bin/bash
-THRIFT_VER=0.9.3
+THRIFT_VER=0.12.0
 if [[ $(thrift -version | grep -e $THRIFT_VER -c) -ne 1 ]]; then
    echo "Warning: This wrapper has only been tested with version" $THRIFT_VER;
--- a/monitors.go
+++ b/monitors.go
@ -36,15 +36,9 @@ func (m *Monitor) JobUpdate(
 	timeout int) (bool, error) {
 	updateQ := aurora.JobUpdateQuery{
-		Key:   &updateKey,
+		Key:            &updateKey,
-		Limit: 1,
+		Limit:          1,
-		UpdateStatuses: []aurora.JobUpdateStatus{
+		UpdateStatuses: TerminalUpdateStates(),
 			aurora.JobUpdateStatus_ROLLED_FORWARD,
 			aurora.JobUpdateStatus_ROLLED_BACK,
 			aurora.JobUpdateStatus_ABORTED,
 			aurora.JobUpdateStatus_ERROR,
 			aurora.JobUpdateStatus_FAILED,
 		},
 	}
 	updateSummaries, err := m.JobUpdateQuery(
 		updateQ,
@ -75,22 +69,13 @@ func (m *Monitor) JobUpdate(
 }
 // JobUpdateStatus polls the scheduler every certain amount of time to see if the update has entered a specified state.
-func (m *Monitor) JobUpdateStatus(
+func (m *Monitor) JobUpdateStatus(updateKey aurora.JobUpdateKey,
-	updateKey aurora.JobUpdateKey,
+	desiredStatuses []aurora.JobUpdateStatus,
-	desiredStatuses map[aurora.JobUpdateStatus]bool,
+	interval, timeout time.Duration) (aurora.JobUpdateStatus, error) {
 	interval time.Duration,
 	timeout time.Duration) (aurora.JobUpdateStatus, error) {
 	desiredStatusesSlice := make([]aurora.JobUpdateStatus, 0)
 	for k := range desiredStatuses {
 		desiredStatusesSlice = append(desiredStatusesSlice, k)
 	}
 	updateQ := aurora.JobUpdateQuery{
 		Key:            &updateKey,
 		Limit:          1,
-		UpdateStatuses: desiredStatusesSlice,
+		UpdateStatuses: desiredStatuses,
 	}
 	summary, err := m.JobUpdateQuery(updateQ, interval, timeout)
@ -129,11 +114,74 @@ func (m *Monitor) JobUpdateQuery(
 	}
 }
-// Instances will monitor a Job until all instances enter one of the LIVE_STATES
+// AutoPaused monitor is a special monitor for auto pause enabled batch updates. This monitor ensures that the update
-func (m *Monitor) Instances(
+// being monitored is capable of auto pausing and has auto pausing enabled. After verifying this information,
-	key *aurora.JobKey,
+// the monitor watches for the job to enter the ROLL_FORWARD_PAUSED state and calculates the current batch
-	instances int32,
+// the update is in using information from the update configuration.
-	interval, timeout int) (bool, error) {
+func (m *Monitor) AutoPausedUpdateMonitor(key aurora.JobUpdateKey, interval, timeout time.Duration) (int, error) {
 	key.Job = &aurora.JobKey{
 		Role:        key.Job.Role,
 		Environment: key.Job.Environment,
 		Name:        key.Job.Name,
 	}
 	query := aurora.JobUpdateQuery{
 		UpdateStatuses: aurora.ACTIVE_JOB_UPDATE_STATES,
 		Limit:          1,
 		Key:            &key,
 	}
 	response, err := m.Client.JobUpdateDetails(query)
 	if err != nil {
 		return -1, errors.Wrap(err, "unable to get information about update")
 	}
 	// TODO (rdelvalle): check for possible nil values when going down the list of structs
 	updateDetails := response.Result_.GetJobUpdateDetailsResult_.DetailsList
 	if len(updateDetails) == 0 {
 		return -1, errors.Errorf("details for update could not be found")
 	}
 	updateStrategy := updateDetails[0].Update.Instructions.Settings.UpdateStrategy
 	var batchSizes []int32
 	switch {
 	case updateStrategy.IsSetVarBatchStrategy():
 		batchSizes = updateStrategy.VarBatchStrategy.GroupSizes
 		if !updateStrategy.VarBatchStrategy.AutopauseAfterBatch {
 			return -1, errors.Errorf("update does not have auto pause enabled")
 		}
 	case updateStrategy.IsSetBatchStrategy():
 		batchSizes = []int32{updateStrategy.BatchStrategy.GroupSize}
 		if !updateStrategy.BatchStrategy.AutopauseAfterBatch {
 			return -1, errors.Errorf("update does not have auto pause enabled")
 		}
 	default:
 		return -1, errors.Errorf("update is not using a batch update strategy")
 	}
 	query.UpdateStatuses = append(TerminalUpdateStates(), aurora.JobUpdateStatus_ROLL_FORWARD_PAUSED)
 	summary, err := m.JobUpdateQuery(query, interval, timeout)
 	if err != nil {
 		return -1, err
 	}
 	if summary[0].State.Status != aurora.JobUpdateStatus_ROLL_FORWARD_PAUSED {
 		return -1, errors.Errorf("update is in a terminal state %v", summary[0].State.Status)
 	}
 	updatingInstances := make(map[int32]struct{})
 	for _, e := range updateDetails[0].InstanceEvents {
 		// We only care about INSTANCE_UPDATING actions because we only care that they've been attempted
 		if e != nil && e.GetAction() == aurora.JobUpdateAction_INSTANCE_UPDATING {
 			updatingInstances[e.GetInstanceId()] = struct{}{}
 		}
 	}
 	return calculateCurrentBatch(int32(len(updatingInstances)), batchSizes), nil
 }
 // Monitor a Job until all instances enter one of the LIVE_STATES
 func (m *Monitor) Instances(key *aurora.JobKey, instances int32, interval, timeout int) (bool, error) {
 	return m.ScheduleStatus(key, instances, LiveStates, interval, timeout)
 }
--- a/realis.go
+++ b/realis.go
@ -829,7 +829,7 @@ func (r *realisClient) AbortJobUpdate(updateKey aurora.JobUpdateKey, message str
 	m := Monitor{Client: r}
 	_, err := m.JobUpdateStatus(
 		updateKey,
-		map[aurora.JobUpdateStatus]bool{aurora.JobUpdateStatus_ABORTED: true},
+		[]aurora.JobUpdateStatus{aurora.JobUpdateStatus_ABORTED},
 		time.Second*5,
 		time.Minute)
--- a/realis_e2e_test.go
+++ b/realis_e2e_test.go
@ -916,3 +916,119 @@ func TestAuroraJob_UpdateSlaPolicy(t *testing.T) {
 		})
 	}
 }
 func TestRealisClient_UpdateStrategies(t *testing.T) {
 	// Create a single job
 	job := realis.NewJob().
 		Environment("prod").
 		Role("vagrant").
 		ExecutorName(aurora.AURORA_EXECUTOR_NAME).
 		ExecutorData(string(thermosPayload)).
 		CPU(.01).
 		RAM(4).
 		Disk(10).
 		InstanceCount(6).
 		IsService(true)
 	strategies := []struct {
 		UpdateJob *realis.UpdateJob
 		Name      string
 	}{
 		{
 			UpdateJob: realis.NewDefaultUpdateJob(job.TaskConfig()).
 				QueueUpdateStrategy(aurora.QueueJobUpdateStrategy{GroupSize: 2}).
 				InstanceCount(6).
 				WatchTime(1000),
 			Name: "Queue",
 		},
 		{
 			UpdateJob: realis.NewDefaultUpdateJob(job.TaskConfig()).
 				BatchUpdateStrategy(aurora.BatchJobUpdateStrategy{GroupSize: 2}).
 				InstanceCount(6).
 				WatchTime(1000),
 			Name: "Batch",
 		},
 		{
 			UpdateJob: realis.NewDefaultUpdateJob(job.TaskConfig()).
 				VariableBatchStrategy(aurora.VariableBatchJobUpdateStrategy{GroupSizes: []int32{1, 2, 3}}).
 				InstanceCount(6).
 				WatchTime(1000),
 			Name: "VarBatch",
 		},
 	}
 	for _, strategy := range strategies {
 		t.Run("TestRealisClient_UpdateStrategies_"+strategy.Name, func(t *testing.T) {
 			job.Name("update_strategies_" + strategy.Name)
 			resp, err := r.StartJobUpdate(strategy.UpdateJob, "")
 			assert.NoError(t, err)
 			assert.NotNil(t, resp)
 			assert.NotNil(t, resp.GetResult_())
 			assert.NotNil(t, resp.GetResult_().GetStartJobUpdateResult_())
 			assert.NotNil(t, resp.GetResult_().GetStartJobUpdateResult_().GetKey())
 			var ok bool
 			var mErr error
 			key := *resp.GetResult_().GetStartJobUpdateResult_().GetKey()
 			if ok, mErr = monitor.JobUpdate(key, 5, 240); !ok || mErr != nil {
 				// Update may already be in a terminal state so don't check for error
 				_, err := r.AbortJobUpdate(key, "Monitor timed out.")
 				assert.NoError(t, err)
 			}
 			_, err = r.KillJob(job.JobKey())
 			assert.NoError(t, err)
 		})
 	}
 }
 func TestRealisClient_BatchAwareAutoPause(t *testing.T) {
 	// Create a single job
 	job := realis.NewJob().
 		Environment("prod").
 		Role("vagrant").
 		Name("BatchAwareAutoPauseTest").
 		ExecutorName(aurora.AURORA_EXECUTOR_NAME).
 		ExecutorData(string(thermosPayload)).
 		CPU(.01).
 		RAM(4).
 		Disk(10).
 		InstanceCount(6).
 		IsService(true)
 	updateGroups := []int32{1, 2, 3}
 	strategy := realis.NewDefaultUpdateJob(job.TaskConfig()).
 		VariableBatchStrategy(aurora.VariableBatchJobUpdateStrategy{
 			GroupSizes:          updateGroups,
 			AutopauseAfterBatch: true,
 		}).
 		InstanceCount(6).
 		WatchTime(1000)
 	resp, err := r.StartJobUpdate(strategy, "")
 	require.NoError(t, err)
 	require.NotNil(t, resp)
 	require.NotNil(t, resp.GetResult_())
 	require.NotNil(t, resp.GetResult_().GetStartJobUpdateResult_())
 	require.NotNil(t, resp.GetResult_().GetStartJobUpdateResult_().GetKey())
 	key := *resp.GetResult_().GetStartJobUpdateResult_().GetKey()
 	for i := range updateGroups {
 		curStep, mErr := monitor.AutoPausedUpdateMonitor(key, time.Second*5, time.Second*240)
 		if mErr != nil {
 			// Update may already be in a terminal state so don't check for error
 			_, err := r.AbortJobUpdate(key, "Monitor timed out.")
 			assert.NoError(t, err)
 		}
 		assert.Equal(t, i, curStep)
 		_, err = r.ResumeJobUpdate(&key, "auto resuming test")
 		require.NoError(t, err)
 	}
 	_, err = r.KillJob(job.JobKey())
 	assert.NoError(t, err)
 }
--- a/updatejob.go
+++ b/updatejob.go
@ -159,6 +159,21 @@ func (u *UpdateJob) RollbackOnFail(rollback bool) *UpdateJob {
 }
 // NewUpdateSettings return an opinionated set of job update settings.
 func (u *UpdateJob) BatchUpdateStrategy(strategy aurora.BatchJobUpdateStrategy) *UpdateJob {
 	u.req.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{BatchStrategy: &strategy}
 	return u
 }
 func (u *UpdateJob) QueueUpdateStrategy(strategy aurora.QueueJobUpdateStrategy) *UpdateJob {
 	u.req.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{QueueStrategy: &strategy}
 	return u
 }
 func (u *UpdateJob) VariableBatchStrategy(strategy aurora.VariableBatchJobUpdateStrategy) *UpdateJob {
 	u.req.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{VarBatchStrategy: &strategy}
 	return u
 }
 func NewUpdateSettings() *aurora.JobUpdateSettings {
 	us := new(aurora.JobUpdateSettings)
 	// Mirrors defaults set by Pystachio
--- a/util.go
+++ b/util.go
@ -25,6 +25,18 @@ var TerminalStates = make(map[aurora.ScheduleStatus]bool)
 // ActiveJobUpdateStates - States a Job Update may be in where it is considered active.
 var ActiveJobUpdateStates = make(map[aurora.JobUpdateStatus]bool)
 // TerminalJobUpdateStates returns a slice containing all the terminal states an update may end up in.
 // This is a function in order to avoid having a slice that can be accidentally mutated.
 func TerminalUpdateStates() []aurora.JobUpdateStatus {
 	return []aurora.JobUpdateStatus{
 		aurora.JobUpdateStatus_ROLLED_FORWARD,
 		aurora.JobUpdateStatus_ROLLED_BACK,
 		aurora.JobUpdateStatus_ABORTED,
 		aurora.JobUpdateStatus_ERROR,
 		aurora.JobUpdateStatus_FAILED,
 	}
 }
 // AwaitingPulseJobUpdateStates - States a job update may be in where it is waiting for a pulse.
 var AwaitingPulseJobUpdateStates = make(map[aurora.JobUpdateStatus]bool)
@ -87,3 +99,22 @@ func validateAuroraURL(location string) (string, error) {
 	return u.String(), nil
 }
 func calculateCurrentBatch(updatingInstances int32, batchSizes []int32) int {
 	for i, size := range batchSizes {
 		updatingInstances -= size
 		if updatingInstances <= 0 {
 			return i
 		}
 	}
 	// Overflow batches
 	batchCount := len(batchSizes) - 1
 	lastBatchIndex := len(batchSizes) - 1
 	batchCount += int(updatingInstances / batchSizes[lastBatchIndex])
 	if updatingInstances%batchSizes[lastBatchIndex] != 0 {
 		batchCount++
 	}
 	return batchCount
 }
--- a/util_test.go
+++ b/util_test.go
@ -63,3 +63,40 @@ func TestAuroraURLValidator(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
 func TestCurrentBatchCalculator(t *testing.T) {
 	t.Run("singleBatchOverflow", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(10, []int32{2})
 		assert.Equal(t, 4, curBatch)
 	})
 	t.Run("noInstancesUpdating", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(0, []int32{2})
 		assert.Equal(t, 0, curBatch)
 	})
 	t.Run("evenMatchSingleBatch", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(2, []int32{2})
 		assert.Equal(t, 0, curBatch)
 	})
 	t.Run("moreInstancesThanBatches", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(5, []int32{1, 2})
 		assert.Equal(t, 2, curBatch)
 	})
 	t.Run("moreInstancesThanBatchesDecreasing", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(5, []int32{2, 1})
 		assert.Equal(t, 3, curBatch)
 	})
 	t.Run("unevenFit", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(2, []int32{1, 2})
 		assert.Equal(t, 1, curBatch)
 	})
 	t.Run("halfWay", func(t *testing.T) {
 		curBatch := calculateCurrentBatch(1, []int32{1, 2})
 		assert.Equal(t, 0, curBatch)
 	})
 }
Author	SHA1	Message	Date
Renan I. Del Valle	efc0fdcd81	Moving future to final 0.22.0 release and Mesos 1.6.2 (#114 ) Changes in compose testing setup: * Upgrading Aurora to 0.22.0 * Upgrading Mesos to 1.6.2	2020-01-14 15:34:59 -08:00
Renan I. Del Valle	b505304b79	Adding autopause APIs to future (#110 ) * Updating thrift definitions to add autopause for batch based update strategies. * Adding batch calculator utility and test cases for it. * Adding PauseUpdateMonitor which allows users to poll Aurora for information on an active Update being carried out until it enters the ROLL_FORWARD_PAUSED state. * Tests for PauseUpdateMonitor and VariableBatchStep added to the end to end tests. * Adding TerminalUpdateStates function which returns a slice containing all terminal states for an update. Changed signature of JobUpdateStatus from using a map for desired states to a slice. A map is no longer necessary with the new version of thrift and only adds complexity.	2020-01-13 16:03:40 -08:00
Renan DelValle	2148351b94	Variable Batch Update Support (#100 ) * Changing generateBinding.sh check to check for thrift 0.12.0 and adding support for Variable Batch updates. * Adding update strategies change to changelog, changed docker-compose to point to aurora 0.22.0 snapshot. Added test coverage for update strategies.	2019-08-28 17:12:59 -07:00
Renan DelValle	f936576c4d	Increasing aurora version for future branch.	2019-08-28 17:11:32 -07:00