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.

CHANGELOG.md

@@ -1,4 +1,4 @@
-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.
@@ -11,4 +11,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.

auroraAPI.thrift

@@ -716,9 +716,36 @@ 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
+}
+
+/** 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
+}
+
+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 +763,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 +782,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. */

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.1
     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.1
     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.1
     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-07c1dee796e553540a025d3ef5e126cfaf14620d
     pid: host
     ports:
     - "8081:8081"

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)
-    mbTrans355 := thrift.NewTMemoryBufferLen(len(arg354))
-    defer mbTrans355.Close()
-    _, err356 := mbTrans355.WriteString(arg354)
-    if err356 != nil {
+    arg355 := flag.Arg(2)
+    mbTrans356 := thrift.NewTMemoryBufferLen(len(arg355))
+    defer mbTrans356.Close()
+    _, err357 := mbTrans356.WriteString(arg355)
+    if err357 != nil {
       Usage()
       return
     }
-    factory357 := thrift.NewTJSONProtocolFactory()
-    jsProt358 := factory357.GetProtocol(mbTrans355)
+    factory358 := thrift.NewTJSONProtocolFactory()
+    jsProt359 := factory358.GetProtocol(mbTrans356)
     argvalue1 := aurora.NewResourceAggregate()
-    err359 := argvalue1.Read(jsProt358)
-    if err359 != nil {
+    err360 := argvalue1.Read(jsProt359)
+    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)
-    mbTrans363 := thrift.NewTMemoryBufferLen(len(arg362))
-    defer mbTrans363.Close()
-    _, err364 := mbTrans363.WriteString(arg362)
-    if err364 != nil {
+    arg363 := flag.Arg(1)
+    mbTrans364 := thrift.NewTMemoryBufferLen(len(arg363))
+    defer mbTrans364.Close()
+    _, err365 := mbTrans364.WriteString(arg363)
+    if err365 != nil {
       Usage()
       return
     }
-    factory365 := thrift.NewTJSONProtocolFactory()
-    jsProt366 := factory365.GetProtocol(mbTrans363)
+    factory366 := thrift.NewTJSONProtocolFactory()
+    jsProt367 := factory366.GetProtocol(mbTrans364)
     argvalue0 := aurora.NewTaskQuery()
-    err367 := argvalue0.Read(jsProt366)
-    if err367 != nil {
+    err368 := argvalue0.Read(jsProt367)
+    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)
-    mbTrans369 := thrift.NewTMemoryBufferLen(len(arg368))
-    defer mbTrans369.Close()
-    _, err370 := mbTrans369.WriteString(arg368)
-    if err370 != nil {
+    arg369 := flag.Arg(1)
+    mbTrans370 := thrift.NewTMemoryBufferLen(len(arg369))
+    defer mbTrans370.Close()
+    _, err371 := mbTrans370.WriteString(arg369)
+    if err371 != nil {
       Usage()
       return
     }
-    factory371 := thrift.NewTJSONProtocolFactory()
-    jsProt372 := factory371.GetProtocol(mbTrans369)
+    factory372 := thrift.NewTJSONProtocolFactory()
+    jsProt373 := factory372.GetProtocol(mbTrans370)
     argvalue0 := aurora.NewTaskQuery()
-    err373 := argvalue0.Read(jsProt372)
-    if err373 != nil {
+    err374 := argvalue0.Read(jsProt373)
+    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)
-    mbTrans375 := thrift.NewTMemoryBufferLen(len(arg374))
-    defer mbTrans375.Close()
-    _, err376 := mbTrans375.WriteString(arg374)
-    if err376 != nil {
+    arg375 := flag.Arg(1)
+    mbTrans376 := thrift.NewTMemoryBufferLen(len(arg375))
+    defer mbTrans376.Close()
+    _, err377 := mbTrans376.WriteString(arg375)
+    if err377 != nil {
       Usage()
       return
     }
-    factory377 := thrift.NewTJSONProtocolFactory()
-    jsProt378 := factory377.GetProtocol(mbTrans375)
+    factory378 := thrift.NewTJSONProtocolFactory()
+    jsProt379 := factory378.GetProtocol(mbTrans376)
     argvalue0 := aurora.NewHosts()
-    err379 := argvalue0.Read(jsProt378)
-    if err379 != nil {
+    err380 := argvalue0.Read(jsProt379)
+    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)
-    mbTrans381 := thrift.NewTMemoryBufferLen(len(arg380))
-    defer mbTrans381.Close()
-    _, err382 := mbTrans381.WriteString(arg380)
-    if err382 != nil {
+    arg381 := flag.Arg(1)
+    mbTrans382 := thrift.NewTMemoryBufferLen(len(arg381))
+    defer mbTrans382.Close()
+    _, err383 := mbTrans382.WriteString(arg381)
+    if err383 != nil {
       Usage()
       return
     }
-    factory383 := thrift.NewTJSONProtocolFactory()
-    jsProt384 := factory383.GetProtocol(mbTrans381)
+    factory384 := thrift.NewTJSONProtocolFactory()
+    jsProt385 := factory384.GetProtocol(mbTrans382)
     argvalue0 := aurora.NewHosts()
-    err385 := argvalue0.Read(jsProt384)
-    if err385 != nil {
+    err386 := argvalue0.Read(jsProt385)
+    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)
-    mbTrans387 := thrift.NewTMemoryBufferLen(len(arg386))
-    defer mbTrans387.Close()
-    _, err388 := mbTrans387.WriteString(arg386)
-    if err388 != nil {
+    arg387 := flag.Arg(1)
+    mbTrans388 := thrift.NewTMemoryBufferLen(len(arg387))
+    defer mbTrans388.Close()
+    _, err389 := mbTrans388.WriteString(arg387)
+    if err389 != nil {
       Usage()
       return
     }
-    factory389 := thrift.NewTJSONProtocolFactory()
-    jsProt390 := factory389.GetProtocol(mbTrans387)
+    factory390 := thrift.NewTJSONProtocolFactory()
+    jsProt391 := factory390.GetProtocol(mbTrans388)
     argvalue0 := aurora.NewHosts()
-    err391 := argvalue0.Read(jsProt390)
-    if err391 != nil {
+    err392 := argvalue0.Read(jsProt391)
+    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)
-    mbTrans393 := thrift.NewTMemoryBufferLen(len(arg392))
-    defer mbTrans393.Close()
-    _, err394 := mbTrans393.WriteString(arg392)
-    if err394 != nil {
+    arg393 := flag.Arg(1)
+    mbTrans394 := thrift.NewTMemoryBufferLen(len(arg393))
+    defer mbTrans394.Close()
+    _, err395 := mbTrans394.WriteString(arg393)
+    if err395 != nil {
       Usage()
       return
     }
-    factory395 := thrift.NewTJSONProtocolFactory()
-    jsProt396 := factory395.GetProtocol(mbTrans393)
+    factory396 := thrift.NewTJSONProtocolFactory()
+    jsProt397 := factory396.GetProtocol(mbTrans394)
     argvalue0 := aurora.NewHosts()
-    err397 := argvalue0.Read(jsProt396)
-    if err397 != nil {
+    err398 := argvalue0.Read(jsProt397)
+    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)
-    mbTrans399 := thrift.NewTMemoryBufferLen(len(arg398))
-    defer mbTrans399.Close()
-    _, err400 := mbTrans399.WriteString(arg398)
-    if err400 != nil {
+    arg399 := flag.Arg(1)
+    mbTrans400 := thrift.NewTMemoryBufferLen(len(arg399))
+    defer mbTrans400.Close()
+    _, err401 := mbTrans400.WriteString(arg399)
+    if err401 != nil {
       Usage()
       return
     }
-    factory401 := thrift.NewTJSONProtocolFactory()
-    jsProt402 := factory401.GetProtocol(mbTrans399)
+    factory402 := thrift.NewTJSONProtocolFactory()
+    jsProt403 := factory402.GetProtocol(mbTrans400)
     argvalue0 := aurora.NewHosts()
-    err403 := argvalue0.Read(jsProt402)
-    if err403 != nil {
+    err404 := argvalue0.Read(jsProt403)
+    if err404 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg404 := flag.Arg(2)
-    mbTrans405 := thrift.NewTMemoryBufferLen(len(arg404))
-    defer mbTrans405.Close()
-    _, err406 := mbTrans405.WriteString(arg404)
-    if err406 != nil {
+    arg405 := flag.Arg(2)
+    mbTrans406 := thrift.NewTMemoryBufferLen(len(arg405))
+    defer mbTrans406.Close()
+    _, err407 := mbTrans406.WriteString(arg405)
+    if err407 != nil {
       Usage()
       return
     }
-    factory407 := thrift.NewTJSONProtocolFactory()
-    jsProt408 := factory407.GetProtocol(mbTrans405)
+    factory408 := thrift.NewTJSONProtocolFactory()
+    jsProt409 := factory408.GetProtocol(mbTrans406)
     argvalue1 := aurora.NewSlaPolicy()
-    err409 := argvalue1.Read(jsProt408)
-    if err409 != nil {
+    err410 := argvalue1.Read(jsProt409)
+    if err410 != nil {
       Usage()
       return
     }
     value1 := argvalue1
-    argvalue2, err410 := (strconv.ParseInt(flag.Arg(3), 10, 64))
-    if err410 != nil {
+    argvalue2, err411 := (strconv.ParseInt(flag.Arg(3), 10, 64))
+    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)
-    mbTrans412 := thrift.NewTMemoryBufferLen(len(arg411))
-    defer mbTrans412.Close()
-    _, err413 := mbTrans412.WriteString(arg411)
-    if err413 != nil {
+    arg412 := flag.Arg(1)
+    mbTrans413 := thrift.NewTMemoryBufferLen(len(arg412))
+    defer mbTrans413.Close()
+    _, err414 := mbTrans413.WriteString(arg412)
+    if err414 != nil {
       Usage()
       return
     }
-    factory414 := thrift.NewTJSONProtocolFactory()
-    jsProt415 := factory414.GetProtocol(mbTrans412)
+    factory415 := thrift.NewTJSONProtocolFactory()
+    jsProt416 := factory415.GetProtocol(mbTrans413)
     argvalue0 := aurora.NewExplicitReconciliationSettings()
-    err416 := argvalue0.Read(jsProt415)
-    if err416 != nil {
+    err417 := argvalue0.Read(jsProt416)
+    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)
-    mbTrans418 := thrift.NewTMemoryBufferLen(len(arg417))
-    defer mbTrans418.Close()
-    _, err419 := mbTrans418.WriteString(arg417)
-    if err419 != nil {
+    arg418 := flag.Arg(1)
+    mbTrans419 := thrift.NewTMemoryBufferLen(len(arg418))
+    defer mbTrans419.Close()
+    _, err420 := mbTrans419.WriteString(arg418)
+    if err420 != nil {
       Usage()
       return
     }
-    factory420 := thrift.NewTJSONProtocolFactory()
-    jsProt421 := factory420.GetProtocol(mbTrans418)
+    factory421 := thrift.NewTJSONProtocolFactory()
+    jsProt422 := factory421.GetProtocol(mbTrans419)
     argvalue0 := aurora.NewTaskQuery()
-    err422 := argvalue0.Read(jsProt421)
-    if err422 != nil {
+    err423 := argvalue0.Read(jsProt422)
+    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)
-    mbTrans424 := thrift.NewTMemoryBufferLen(len(arg423))
-    defer mbTrans424.Close()
-    _, err425 := mbTrans424.WriteString(arg423)
-    if err425 != nil {
+    arg424 := flag.Arg(1)
+    mbTrans425 := thrift.NewTMemoryBufferLen(len(arg424))
+    defer mbTrans425.Close()
+    _, err426 := mbTrans425.WriteString(arg424)
+    if err426 != nil {
       Usage()
       return
     }
-    factory426 := thrift.NewTJSONProtocolFactory()
-    jsProt427 := factory426.GetProtocol(mbTrans424)
+    factory427 := thrift.NewTJSONProtocolFactory()
+    jsProt428 := factory427.GetProtocol(mbTrans425)
     argvalue0 := aurora.NewJobConfiguration()
-    err428 := argvalue0.Read(jsProt427)
-    if err428 != nil {
+    err429 := argvalue0.Read(jsProt428)
+    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)
-    mbTrans430 := thrift.NewTMemoryBufferLen(len(arg429))
-    defer mbTrans430.Close()
-    _, err431 := mbTrans430.WriteString(arg429)
-    if err431 != nil {
+    arg430 := flag.Arg(1)
+    mbTrans431 := thrift.NewTMemoryBufferLen(len(arg430))
+    defer mbTrans431.Close()
+    _, err432 := mbTrans431.WriteString(arg430)
+    if err432 != nil {
       Usage()
       return
     }
-    factory432 := thrift.NewTJSONProtocolFactory()
-    jsProt433 := factory432.GetProtocol(mbTrans430)
+    factory433 := thrift.NewTJSONProtocolFactory()
+    jsProt434 := factory433.GetProtocol(mbTrans431)
     argvalue0 := aurora.NewJobConfiguration()
-    err434 := argvalue0.Read(jsProt433)
-    if err434 != nil {
+    err435 := argvalue0.Read(jsProt434)
+    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)
-    mbTrans436 := thrift.NewTMemoryBufferLen(len(arg435))
-    defer mbTrans436.Close()
-    _, err437 := mbTrans436.WriteString(arg435)
-    if err437 != nil {
+    arg436 := flag.Arg(1)
+    mbTrans437 := thrift.NewTMemoryBufferLen(len(arg436))
+    defer mbTrans437.Close()
+    _, err438 := mbTrans437.WriteString(arg436)
+    if err438 != nil {
       Usage()
       return
     }
-    factory438 := thrift.NewTJSONProtocolFactory()
-    jsProt439 := factory438.GetProtocol(mbTrans436)
+    factory439 := thrift.NewTJSONProtocolFactory()
+    jsProt440 := factory439.GetProtocol(mbTrans437)
     argvalue0 := aurora.NewJobKey()
-    err440 := argvalue0.Read(jsProt439)
-    if err440 != nil {
+    err441 := argvalue0.Read(jsProt440)
+    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)
-    mbTrans442 := thrift.NewTMemoryBufferLen(len(arg441))
-    defer mbTrans442.Close()
-    _, err443 := mbTrans442.WriteString(arg441)
-    if err443 != nil {
+    arg442 := flag.Arg(1)
+    mbTrans443 := thrift.NewTMemoryBufferLen(len(arg442))
+    defer mbTrans443.Close()
+    _, err444 := mbTrans443.WriteString(arg442)
+    if err444 != nil {
       Usage()
       return
     }
-    factory444 := thrift.NewTJSONProtocolFactory()
-    jsProt445 := factory444.GetProtocol(mbTrans442)
+    factory445 := thrift.NewTJSONProtocolFactory()
+    jsProt446 := factory445.GetProtocol(mbTrans443)
     argvalue0 := aurora.NewJobKey()
-    err446 := argvalue0.Read(jsProt445)
-    if err446 != nil {
+    err447 := argvalue0.Read(jsProt446)
+    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)
-    mbTrans448 := thrift.NewTMemoryBufferLen(len(arg447))
-    defer mbTrans448.Close()
-    _, err449 := mbTrans448.WriteString(arg447)
-    if err449 != nil {
+    arg448 := flag.Arg(1)
+    mbTrans449 := thrift.NewTMemoryBufferLen(len(arg448))
+    defer mbTrans449.Close()
+    _, err450 := mbTrans449.WriteString(arg448)
+    if err450 != nil {
       Usage()
       return
     }
-    factory450 := thrift.NewTJSONProtocolFactory()
-    jsProt451 := factory450.GetProtocol(mbTrans448)
+    factory451 := thrift.NewTJSONProtocolFactory()
+    jsProt452 := factory451.GetProtocol(mbTrans449)
     argvalue0 := aurora.NewJobKey()
-    err452 := argvalue0.Read(jsProt451)
-    if err452 != nil {
+    err453 := argvalue0.Read(jsProt452)
+    if err453 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg453 := flag.Arg(2)
-    mbTrans454 := thrift.NewTMemoryBufferLen(len(arg453))
-    defer mbTrans454.Close()
-    _, err455 := mbTrans454.WriteString(arg453)
-    if err455 != nil { 
+    arg454 := flag.Arg(2)
+    mbTrans455 := thrift.NewTMemoryBufferLen(len(arg454))
+    defer mbTrans455.Close()
+    _, err456 := mbTrans455.WriteString(arg454)
+    if err456 != nil { 
       Usage()
       return
     }
-    factory456 := thrift.NewTJSONProtocolFactory()
-    jsProt457 := factory456.GetProtocol(mbTrans454)
+    factory457 := thrift.NewTJSONProtocolFactory()
+    jsProt458 := factory457.GetProtocol(mbTrans455)
     containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
-    err458 := containerStruct1.ReadField2(jsProt457)
-    if err458 != nil {
+    err459 := containerStruct1.ReadField2(jsProt458)
+    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)
-    mbTrans460 := thrift.NewTMemoryBufferLen(len(arg459))
-    defer mbTrans460.Close()
-    _, err461 := mbTrans460.WriteString(arg459)
-    if err461 != nil {
+    arg460 := flag.Arg(1)
+    mbTrans461 := thrift.NewTMemoryBufferLen(len(arg460))
+    defer mbTrans461.Close()
+    _, err462 := mbTrans461.WriteString(arg460)
+    if err462 != nil {
       Usage()
       return
     }
-    factory462 := thrift.NewTJSONProtocolFactory()
-    jsProt463 := factory462.GetProtocol(mbTrans460)
+    factory463 := thrift.NewTJSONProtocolFactory()
+    jsProt464 := factory463.GetProtocol(mbTrans461)
     argvalue0 := aurora.NewJobKey()
-    err464 := argvalue0.Read(jsProt463)
-    if err464 != nil {
+    err465 := argvalue0.Read(jsProt464)
+    if err465 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg465 := flag.Arg(2)
-    mbTrans466 := thrift.NewTMemoryBufferLen(len(arg465))
-    defer mbTrans466.Close()
-    _, err467 := mbTrans466.WriteString(arg465)
-    if err467 != nil { 
+    arg466 := flag.Arg(2)
+    mbTrans467 := thrift.NewTMemoryBufferLen(len(arg466))
+    defer mbTrans467.Close()
+    _, err468 := mbTrans467.WriteString(arg466)
+    if err468 != nil { 
       Usage()
       return
     }
-    factory468 := thrift.NewTJSONProtocolFactory()
-    jsProt469 := factory468.GetProtocol(mbTrans466)
+    factory469 := thrift.NewTJSONProtocolFactory()
+    jsProt470 := factory469.GetProtocol(mbTrans467)
     containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
-    err470 := containerStruct1.ReadField2(jsProt469)
-    if err470 != nil {
+    err471 := containerStruct1.ReadField2(jsProt470)
+    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)
-    mbTrans473 := thrift.NewTMemoryBufferLen(len(arg472))
-    defer mbTrans473.Close()
-    _, err474 := mbTrans473.WriteString(arg472)
-    if err474 != nil {
+    arg473 := flag.Arg(1)
+    mbTrans474 := thrift.NewTMemoryBufferLen(len(arg473))
+    defer mbTrans474.Close()
+    _, err475 := mbTrans474.WriteString(arg473)
+    if err475 != nil {
       Usage()
       return
     }
-    factory475 := thrift.NewTJSONProtocolFactory()
-    jsProt476 := factory475.GetProtocol(mbTrans473)
+    factory476 := thrift.NewTJSONProtocolFactory()
+    jsProt477 := factory476.GetProtocol(mbTrans474)
     argvalue0 := aurora.NewInstanceKey()
-    err477 := argvalue0.Read(jsProt476)
-    if err477 != nil {
+    err478 := argvalue0.Read(jsProt477)
+    if err478 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    tmp1, err478 := (strconv.Atoi(flag.Arg(2)))
-    if err478 != nil {
+    tmp1, err479 := (strconv.Atoi(flag.Arg(2)))
+    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)
-    mbTrans480 := thrift.NewTMemoryBufferLen(len(arg479))
-    defer mbTrans480.Close()
-    _, err481 := mbTrans480.WriteString(arg479)
-    if err481 != nil {
+    arg480 := flag.Arg(1)
+    mbTrans481 := thrift.NewTMemoryBufferLen(len(arg480))
+    defer mbTrans481.Close()
+    _, err482 := mbTrans481.WriteString(arg480)
+    if err482 != nil {
       Usage()
       return
     }
-    factory482 := thrift.NewTJSONProtocolFactory()
-    jsProt483 := factory482.GetProtocol(mbTrans480)
+    factory483 := thrift.NewTJSONProtocolFactory()
+    jsProt484 := factory483.GetProtocol(mbTrans481)
     argvalue0 := aurora.NewJobConfiguration()
-    err484 := argvalue0.Read(jsProt483)
-    if err484 != nil {
+    err485 := argvalue0.Read(jsProt484)
+    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)
-    mbTrans486 := thrift.NewTMemoryBufferLen(len(arg485))
-    defer mbTrans486.Close()
-    _, err487 := mbTrans486.WriteString(arg485)
-    if err487 != nil {
+    arg486 := flag.Arg(1)
+    mbTrans487 := thrift.NewTMemoryBufferLen(len(arg486))
+    defer mbTrans487.Close()
+    _, err488 := mbTrans487.WriteString(arg486)
+    if err488 != nil {
       Usage()
       return
     }
-    factory488 := thrift.NewTJSONProtocolFactory()
-    jsProt489 := factory488.GetProtocol(mbTrans486)
+    factory489 := thrift.NewTJSONProtocolFactory()
+    jsProt490 := factory489.GetProtocol(mbTrans487)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err490 := argvalue0.Read(jsProt489)
-    if err490 != nil {
+    err491 := argvalue0.Read(jsProt490)
+    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)
-    mbTrans493 := thrift.NewTMemoryBufferLen(len(arg492))
-    defer mbTrans493.Close()
-    _, err494 := mbTrans493.WriteString(arg492)
-    if err494 != nil {
+    arg493 := flag.Arg(1)
+    mbTrans494 := thrift.NewTMemoryBufferLen(len(arg493))
+    defer mbTrans494.Close()
+    _, err495 := mbTrans494.WriteString(arg493)
+    if err495 != nil {
       Usage()
       return
     }
-    factory495 := thrift.NewTJSONProtocolFactory()
-    jsProt496 := factory495.GetProtocol(mbTrans493)
+    factory496 := thrift.NewTJSONProtocolFactory()
+    jsProt497 := factory496.GetProtocol(mbTrans494)
     argvalue0 := aurora.NewJobUpdateKey()
-    err497 := argvalue0.Read(jsProt496)
-    if err497 != nil {
+    err498 := argvalue0.Read(jsProt497)
+    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)
-    mbTrans500 := thrift.NewTMemoryBufferLen(len(arg499))
-    defer mbTrans500.Close()
-    _, err501 := mbTrans500.WriteString(arg499)
-    if err501 != nil {
+    arg500 := flag.Arg(1)
+    mbTrans501 := thrift.NewTMemoryBufferLen(len(arg500))
+    defer mbTrans501.Close()
+    _, err502 := mbTrans501.WriteString(arg500)
+    if err502 != nil {
       Usage()
       return
     }
-    factory502 := thrift.NewTJSONProtocolFactory()
-    jsProt503 := factory502.GetProtocol(mbTrans500)
+    factory503 := thrift.NewTJSONProtocolFactory()
+    jsProt504 := factory503.GetProtocol(mbTrans501)
     argvalue0 := aurora.NewJobUpdateKey()
-    err504 := argvalue0.Read(jsProt503)
-    if err504 != nil {
+    err505 := argvalue0.Read(jsProt504)
+    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)
-    mbTrans507 := thrift.NewTMemoryBufferLen(len(arg506))
-    defer mbTrans507.Close()
-    _, err508 := mbTrans507.WriteString(arg506)
-    if err508 != nil {
+    arg507 := flag.Arg(1)
+    mbTrans508 := thrift.NewTMemoryBufferLen(len(arg507))
+    defer mbTrans508.Close()
+    _, err509 := mbTrans508.WriteString(arg507)
+    if err509 != nil {
       Usage()
       return
     }
-    factory509 := thrift.NewTJSONProtocolFactory()
-    jsProt510 := factory509.GetProtocol(mbTrans507)
+    factory510 := thrift.NewTJSONProtocolFactory()
+    jsProt511 := factory510.GetProtocol(mbTrans508)
     argvalue0 := aurora.NewJobUpdateKey()
-    err511 := argvalue0.Read(jsProt510)
-    if err511 != nil {
+    err512 := argvalue0.Read(jsProt511)
+    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)
-    mbTrans514 := thrift.NewTMemoryBufferLen(len(arg513))
-    defer mbTrans514.Close()
-    _, err515 := mbTrans514.WriteString(arg513)
-    if err515 != nil {
+    arg514 := flag.Arg(1)
+    mbTrans515 := thrift.NewTMemoryBufferLen(len(arg514))
+    defer mbTrans515.Close()
+    _, err516 := mbTrans515.WriteString(arg514)
+    if err516 != nil {
       Usage()
       return
     }
-    factory516 := thrift.NewTJSONProtocolFactory()
-    jsProt517 := factory516.GetProtocol(mbTrans514)
+    factory517 := thrift.NewTJSONProtocolFactory()
+    jsProt518 := factory517.GetProtocol(mbTrans515)
     argvalue0 := aurora.NewJobUpdateKey()
-    err518 := argvalue0.Read(jsProt517)
-    if err518 != nil {
+    err519 := argvalue0.Read(jsProt518)
+    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)
-    mbTrans521 := thrift.NewTMemoryBufferLen(len(arg520))
-    defer mbTrans521.Close()
-    _, err522 := mbTrans521.WriteString(arg520)
-    if err522 != nil {
+    arg521 := flag.Arg(1)
+    mbTrans522 := thrift.NewTMemoryBufferLen(len(arg521))
+    defer mbTrans522.Close()
+    _, err523 := mbTrans522.WriteString(arg521)
+    if err523 != nil {
       Usage()
       return
     }
-    factory523 := thrift.NewTJSONProtocolFactory()
-    jsProt524 := factory523.GetProtocol(mbTrans521)
+    factory524 := thrift.NewTJSONProtocolFactory()
+    jsProt525 := factory524.GetProtocol(mbTrans522)
     argvalue0 := aurora.NewJobUpdateKey()
-    err525 := argvalue0.Read(jsProt524)
-    if err525 != nil {
+    err526 := argvalue0.Read(jsProt525)
+    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)
-    mbTrans528 := thrift.NewTMemoryBufferLen(len(arg527))
-    defer mbTrans528.Close()
-    _, err529 := mbTrans528.WriteString(arg527)
-    if err529 != nil {
+    arg528 := flag.Arg(1)
+    mbTrans529 := thrift.NewTMemoryBufferLen(len(arg528))
+    defer mbTrans529.Close()
+    _, err530 := mbTrans529.WriteString(arg528)
+    if err530 != nil {
       Usage()
       return
     }
-    factory530 := thrift.NewTJSONProtocolFactory()
-    jsProt531 := factory530.GetProtocol(mbTrans528)
+    factory531 := thrift.NewTJSONProtocolFactory()
+    jsProt532 := factory531.GetProtocol(mbTrans529)
     argvalue0 := aurora.NewTaskQuery()
-    err532 := argvalue0.Read(jsProt531)
-    if err532 != nil {
+    err533 := argvalue0.Read(jsProt532)
+    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)
-    mbTrans534 := thrift.NewTMemoryBufferLen(len(arg533))
-    defer mbTrans534.Close()
-    _, err535 := mbTrans534.WriteString(arg533)
-    if err535 != nil {
+    arg534 := flag.Arg(1)
+    mbTrans535 := thrift.NewTMemoryBufferLen(len(arg534))
+    defer mbTrans535.Close()
+    _, err536 := mbTrans535.WriteString(arg534)
+    if err536 != nil {
       Usage()
       return
     }
-    factory536 := thrift.NewTJSONProtocolFactory()
-    jsProt537 := factory536.GetProtocol(mbTrans534)
+    factory537 := thrift.NewTJSONProtocolFactory()
+    jsProt538 := factory537.GetProtocol(mbTrans535)
     argvalue0 := aurora.NewTaskQuery()
-    err538 := argvalue0.Read(jsProt537)
-    if err538 != nil {
+    err539 := argvalue0.Read(jsProt538)
+    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)
-    mbTrans540 := thrift.NewTMemoryBufferLen(len(arg539))
-    defer mbTrans540.Close()
-    _, err541 := mbTrans540.WriteString(arg539)
-    if err541 != nil {
+    arg540 := flag.Arg(1)
+    mbTrans541 := thrift.NewTMemoryBufferLen(len(arg540))
+    defer mbTrans541.Close()
+    _, err542 := mbTrans541.WriteString(arg540)
+    if err542 != nil {
       Usage()
       return
     }
-    factory542 := thrift.NewTJSONProtocolFactory()
-    jsProt543 := factory542.GetProtocol(mbTrans540)
+    factory543 := thrift.NewTJSONProtocolFactory()
+    jsProt544 := factory543.GetProtocol(mbTrans541)
     argvalue0 := aurora.NewTaskQuery()
-    err544 := argvalue0.Read(jsProt543)
-    if err544 != nil {
+    err545 := argvalue0.Read(jsProt544)
+    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)
-    mbTrans546 := thrift.NewTMemoryBufferLen(len(arg545))
-    defer mbTrans546.Close()
-    _, err547 := mbTrans546.WriteString(arg545)
-    if err547 != nil {
+    arg546 := flag.Arg(1)
+    mbTrans547 := thrift.NewTMemoryBufferLen(len(arg546))
+    defer mbTrans547.Close()
+    _, err548 := mbTrans547.WriteString(arg546)
+    if err548 != nil {
       Usage()
       return
     }
-    factory548 := thrift.NewTJSONProtocolFactory()
-    jsProt549 := factory548.GetProtocol(mbTrans546)
+    factory549 := thrift.NewTJSONProtocolFactory()
+    jsProt550 := factory549.GetProtocol(mbTrans547)
     argvalue0 := aurora.NewJobKey()
-    err550 := argvalue0.Read(jsProt549)
-    if err550 != nil {
+    err551 := argvalue0.Read(jsProt550)
+    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)
-    mbTrans554 := thrift.NewTMemoryBufferLen(len(arg553))
-    defer mbTrans554.Close()
-    _, err555 := mbTrans554.WriteString(arg553)
-    if err555 != nil {
+    arg554 := flag.Arg(1)
+    mbTrans555 := thrift.NewTMemoryBufferLen(len(arg554))
+    defer mbTrans555.Close()
+    _, err556 := mbTrans555.WriteString(arg554)
+    if err556 != nil {
       Usage()
       return
     }
-    factory556 := thrift.NewTJSONProtocolFactory()
-    jsProt557 := factory556.GetProtocol(mbTrans554)
+    factory557 := thrift.NewTJSONProtocolFactory()
+    jsProt558 := factory557.GetProtocol(mbTrans555)
     argvalue0 := aurora.NewJobConfiguration()
-    err558 := argvalue0.Read(jsProt557)
-    if err558 != nil {
+    err559 := argvalue0.Read(jsProt558)
+    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)
-    mbTrans560 := thrift.NewTMemoryBufferLen(len(arg559))
-    defer mbTrans560.Close()
-    _, err561 := mbTrans560.WriteString(arg559)
-    if err561 != nil {
+    arg560 := flag.Arg(1)
+    mbTrans561 := thrift.NewTMemoryBufferLen(len(arg560))
+    defer mbTrans561.Close()
+    _, err562 := mbTrans561.WriteString(arg560)
+    if err562 != nil {
       Usage()
       return
     }
-    factory562 := thrift.NewTJSONProtocolFactory()
-    jsProt563 := factory562.GetProtocol(mbTrans560)
+    factory563 := thrift.NewTJSONProtocolFactory()
+    jsProt564 := factory563.GetProtocol(mbTrans561)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err564 := argvalue0.Read(jsProt563)
-    if err564 != nil {
+    err565 := argvalue0.Read(jsProt564)
+    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)
-    mbTrans566 := thrift.NewTMemoryBufferLen(len(arg565))
-    defer mbTrans566.Close()
-    _, err567 := mbTrans566.WriteString(arg565)
-    if err567 != nil {
+    arg566 := flag.Arg(1)
+    mbTrans567 := thrift.NewTMemoryBufferLen(len(arg566))
+    defer mbTrans567.Close()
+    _, err568 := mbTrans567.WriteString(arg566)
+    if err568 != nil {
       Usage()
       return
     }
-    factory568 := thrift.NewTJSONProtocolFactory()
-    jsProt569 := factory568.GetProtocol(mbTrans566)
+    factory569 := thrift.NewTJSONProtocolFactory()
+    jsProt570 := factory569.GetProtocol(mbTrans567)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err570 := argvalue0.Read(jsProt569)
-    if err570 != nil {
+    err571 := argvalue0.Read(jsProt570)
+    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)
-    mbTrans572 := thrift.NewTMemoryBufferLen(len(arg571))
-    defer mbTrans572.Close()
-    _, err573 := mbTrans572.WriteString(arg571)
-    if err573 != nil {
+    arg572 := flag.Arg(1)
+    mbTrans573 := thrift.NewTMemoryBufferLen(len(arg572))
+    defer mbTrans573.Close()
+    _, err574 := mbTrans573.WriteString(arg572)
+    if err574 != nil {
       Usage()
       return
     }
-    factory574 := thrift.NewTJSONProtocolFactory()
-    jsProt575 := factory574.GetProtocol(mbTrans572)
+    factory575 := thrift.NewTJSONProtocolFactory()
+    jsProt576 := factory575.GetProtocol(mbTrans573)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err576 := argvalue0.Read(jsProt575)
-    if err576 != nil {
+    err577 := argvalue0.Read(jsProt576)
+    if err577 != nil {
       Usage()
       return
     }

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)
-    mbTrans163 := thrift.NewTMemoryBufferLen(len(arg162))
-    defer mbTrans163.Close()
-    _, err164 := mbTrans163.WriteString(arg162)
-    if err164 != nil {
+    arg163 := flag.Arg(1)
+    mbTrans164 := thrift.NewTMemoryBufferLen(len(arg163))
+    defer mbTrans164.Close()
+    _, err165 := mbTrans164.WriteString(arg163)
+    if err165 != nil {
       Usage()
       return
     }
-    factory165 := thrift.NewTJSONProtocolFactory()
-    jsProt166 := factory165.GetProtocol(mbTrans163)
+    factory166 := thrift.NewTJSONProtocolFactory()
+    jsProt167 := factory166.GetProtocol(mbTrans164)
     argvalue0 := aurora.NewJobConfiguration()
-    err167 := argvalue0.Read(jsProt166)
-    if err167 != nil {
+    err168 := argvalue0.Read(jsProt167)
+    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)
-    mbTrans169 := thrift.NewTMemoryBufferLen(len(arg168))
-    defer mbTrans169.Close()
-    _, err170 := mbTrans169.WriteString(arg168)
-    if err170 != nil {
+    arg169 := flag.Arg(1)
+    mbTrans170 := thrift.NewTMemoryBufferLen(len(arg169))
+    defer mbTrans170.Close()
+    _, err171 := mbTrans170.WriteString(arg169)
+    if err171 != nil {
       Usage()
       return
     }
-    factory171 := thrift.NewTJSONProtocolFactory()
-    jsProt172 := factory171.GetProtocol(mbTrans169)
+    factory172 := thrift.NewTJSONProtocolFactory()
+    jsProt173 := factory172.GetProtocol(mbTrans170)
     argvalue0 := aurora.NewJobConfiguration()
-    err173 := argvalue0.Read(jsProt172)
-    if err173 != nil {
+    err174 := argvalue0.Read(jsProt173)
+    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)
-    mbTrans175 := thrift.NewTMemoryBufferLen(len(arg174))
-    defer mbTrans175.Close()
-    _, err176 := mbTrans175.WriteString(arg174)
-    if err176 != nil {
+    arg175 := flag.Arg(1)
+    mbTrans176 := thrift.NewTMemoryBufferLen(len(arg175))
+    defer mbTrans176.Close()
+    _, err177 := mbTrans176.WriteString(arg175)
+    if err177 != nil {
       Usage()
       return
     }
-    factory177 := thrift.NewTJSONProtocolFactory()
-    jsProt178 := factory177.GetProtocol(mbTrans175)
+    factory178 := thrift.NewTJSONProtocolFactory()
+    jsProt179 := factory178.GetProtocol(mbTrans176)
     argvalue0 := aurora.NewJobKey()
-    err179 := argvalue0.Read(jsProt178)
-    if err179 != nil {
+    err180 := argvalue0.Read(jsProt179)
+    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)
-    mbTrans181 := thrift.NewTMemoryBufferLen(len(arg180))
-    defer mbTrans181.Close()
-    _, err182 := mbTrans181.WriteString(arg180)
-    if err182 != nil {
+    arg181 := flag.Arg(1)
+    mbTrans182 := thrift.NewTMemoryBufferLen(len(arg181))
+    defer mbTrans182.Close()
+    _, err183 := mbTrans182.WriteString(arg181)
+    if err183 != nil {
       Usage()
       return
     }
-    factory183 := thrift.NewTJSONProtocolFactory()
-    jsProt184 := factory183.GetProtocol(mbTrans181)
+    factory184 := thrift.NewTJSONProtocolFactory()
+    jsProt185 := factory184.GetProtocol(mbTrans182)
     argvalue0 := aurora.NewJobKey()
-    err185 := argvalue0.Read(jsProt184)
-    if err185 != nil {
+    err186 := argvalue0.Read(jsProt185)
+    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)
-    mbTrans187 := thrift.NewTMemoryBufferLen(len(arg186))
-    defer mbTrans187.Close()
-    _, err188 := mbTrans187.WriteString(arg186)
-    if err188 != nil {
+    arg187 := flag.Arg(1)
+    mbTrans188 := thrift.NewTMemoryBufferLen(len(arg187))
+    defer mbTrans188.Close()
+    _, err189 := mbTrans188.WriteString(arg187)
+    if err189 != nil {
       Usage()
       return
     }
-    factory189 := thrift.NewTJSONProtocolFactory()
-    jsProt190 := factory189.GetProtocol(mbTrans187)
+    factory190 := thrift.NewTJSONProtocolFactory()
+    jsProt191 := factory190.GetProtocol(mbTrans188)
     argvalue0 := aurora.NewJobKey()
-    err191 := argvalue0.Read(jsProt190)
-    if err191 != nil {
+    err192 := argvalue0.Read(jsProt191)
+    if err192 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg192 := flag.Arg(2)
-    mbTrans193 := thrift.NewTMemoryBufferLen(len(arg192))
-    defer mbTrans193.Close()
-    _, err194 := mbTrans193.WriteString(arg192)
-    if err194 != nil { 
+    arg193 := flag.Arg(2)
+    mbTrans194 := thrift.NewTMemoryBufferLen(len(arg193))
+    defer mbTrans194.Close()
+    _, err195 := mbTrans194.WriteString(arg193)
+    if err195 != nil { 
       Usage()
       return
     }
-    factory195 := thrift.NewTJSONProtocolFactory()
-    jsProt196 := factory195.GetProtocol(mbTrans193)
+    factory196 := thrift.NewTJSONProtocolFactory()
+    jsProt197 := factory196.GetProtocol(mbTrans194)
     containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
-    err197 := containerStruct1.ReadField2(jsProt196)
-    if err197 != nil {
+    err198 := containerStruct1.ReadField2(jsProt197)
+    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)
-    mbTrans199 := thrift.NewTMemoryBufferLen(len(arg198))
-    defer mbTrans199.Close()
-    _, err200 := mbTrans199.WriteString(arg198)
-    if err200 != nil {
+    arg199 := flag.Arg(1)
+    mbTrans200 := thrift.NewTMemoryBufferLen(len(arg199))
+    defer mbTrans200.Close()
+    _, err201 := mbTrans200.WriteString(arg199)
+    if err201 != nil {
       Usage()
       return
     }
-    factory201 := thrift.NewTJSONProtocolFactory()
-    jsProt202 := factory201.GetProtocol(mbTrans199)
+    factory202 := thrift.NewTJSONProtocolFactory()
+    jsProt203 := factory202.GetProtocol(mbTrans200)
     argvalue0 := aurora.NewJobKey()
-    err203 := argvalue0.Read(jsProt202)
-    if err203 != nil {
+    err204 := argvalue0.Read(jsProt203)
+    if err204 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg204 := flag.Arg(2)
-    mbTrans205 := thrift.NewTMemoryBufferLen(len(arg204))
-    defer mbTrans205.Close()
-    _, err206 := mbTrans205.WriteString(arg204)
-    if err206 != nil { 
+    arg205 := flag.Arg(2)
+    mbTrans206 := thrift.NewTMemoryBufferLen(len(arg205))
+    defer mbTrans206.Close()
+    _, err207 := mbTrans206.WriteString(arg205)
+    if err207 != nil { 
       Usage()
       return
     }
-    factory207 := thrift.NewTJSONProtocolFactory()
-    jsProt208 := factory207.GetProtocol(mbTrans205)
+    factory208 := thrift.NewTJSONProtocolFactory()
+    jsProt209 := factory208.GetProtocol(mbTrans206)
     containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
-    err209 := containerStruct1.ReadField2(jsProt208)
-    if err209 != nil {
+    err210 := containerStruct1.ReadField2(jsProt209)
+    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)
-    mbTrans212 := thrift.NewTMemoryBufferLen(len(arg211))
-    defer mbTrans212.Close()
-    _, err213 := mbTrans212.WriteString(arg211)
-    if err213 != nil {
+    arg212 := flag.Arg(1)
+    mbTrans213 := thrift.NewTMemoryBufferLen(len(arg212))
+    defer mbTrans213.Close()
+    _, err214 := mbTrans213.WriteString(arg212)
+    if err214 != nil {
       Usage()
       return
     }
-    factory214 := thrift.NewTJSONProtocolFactory()
-    jsProt215 := factory214.GetProtocol(mbTrans212)
+    factory215 := thrift.NewTJSONProtocolFactory()
+    jsProt216 := factory215.GetProtocol(mbTrans213)
     argvalue0 := aurora.NewInstanceKey()
-    err216 := argvalue0.Read(jsProt215)
-    if err216 != nil {
+    err217 := argvalue0.Read(jsProt216)
+    if err217 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    tmp1, err217 := (strconv.Atoi(flag.Arg(2)))
-    if err217 != nil {
+    tmp1, err218 := (strconv.Atoi(flag.Arg(2)))
+    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)
-    mbTrans219 := thrift.NewTMemoryBufferLen(len(arg218))
-    defer mbTrans219.Close()
-    _, err220 := mbTrans219.WriteString(arg218)
-    if err220 != nil {
+    arg219 := flag.Arg(1)
+    mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
+    defer mbTrans220.Close()
+    _, err221 := mbTrans220.WriteString(arg219)
+    if err221 != nil {
       Usage()
       return
     }
-    factory221 := thrift.NewTJSONProtocolFactory()
-    jsProt222 := factory221.GetProtocol(mbTrans219)
+    factory222 := thrift.NewTJSONProtocolFactory()
+    jsProt223 := factory222.GetProtocol(mbTrans220)
     argvalue0 := aurora.NewJobConfiguration()
-    err223 := argvalue0.Read(jsProt222)
-    if err223 != nil {
+    err224 := argvalue0.Read(jsProt223)
+    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)
-    mbTrans225 := thrift.NewTMemoryBufferLen(len(arg224))
-    defer mbTrans225.Close()
-    _, err226 := mbTrans225.WriteString(arg224)
-    if err226 != nil {
+    arg225 := flag.Arg(1)
+    mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
+    defer mbTrans226.Close()
+    _, err227 := mbTrans226.WriteString(arg225)
+    if err227 != nil {
       Usage()
       return
     }
-    factory227 := thrift.NewTJSONProtocolFactory()
-    jsProt228 := factory227.GetProtocol(mbTrans225)
+    factory228 := thrift.NewTJSONProtocolFactory()
+    jsProt229 := factory228.GetProtocol(mbTrans226)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err229 := argvalue0.Read(jsProt228)
-    if err229 != nil {
+    err230 := argvalue0.Read(jsProt229)
+    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)
-    mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
-    defer mbTrans232.Close()
-    _, err233 := mbTrans232.WriteString(arg231)
-    if err233 != nil {
+    arg232 := flag.Arg(1)
+    mbTrans233 := thrift.NewTMemoryBufferLen(len(arg232))
+    defer mbTrans233.Close()
+    _, err234 := mbTrans233.WriteString(arg232)
+    if err234 != nil {
       Usage()
       return
     }
-    factory234 := thrift.NewTJSONProtocolFactory()
-    jsProt235 := factory234.GetProtocol(mbTrans232)
+    factory235 := thrift.NewTJSONProtocolFactory()
+    jsProt236 := factory235.GetProtocol(mbTrans233)
     argvalue0 := aurora.NewJobUpdateKey()
-    err236 := argvalue0.Read(jsProt235)
-    if err236 != nil {
+    err237 := argvalue0.Read(jsProt236)
+    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)
-    mbTrans239 := thrift.NewTMemoryBufferLen(len(arg238))
-    defer mbTrans239.Close()
-    _, err240 := mbTrans239.WriteString(arg238)
-    if err240 != nil {
+    arg239 := flag.Arg(1)
+    mbTrans240 := thrift.NewTMemoryBufferLen(len(arg239))
+    defer mbTrans240.Close()
+    _, err241 := mbTrans240.WriteString(arg239)
+    if err241 != nil {
       Usage()
       return
     }
-    factory241 := thrift.NewTJSONProtocolFactory()
-    jsProt242 := factory241.GetProtocol(mbTrans239)
+    factory242 := thrift.NewTJSONProtocolFactory()
+    jsProt243 := factory242.GetProtocol(mbTrans240)
     argvalue0 := aurora.NewJobUpdateKey()
-    err243 := argvalue0.Read(jsProt242)
-    if err243 != nil {
+    err244 := argvalue0.Read(jsProt243)
+    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)
-    mbTrans246 := thrift.NewTMemoryBufferLen(len(arg245))
-    defer mbTrans246.Close()
-    _, err247 := mbTrans246.WriteString(arg245)
-    if err247 != nil {
+    arg246 := flag.Arg(1)
+    mbTrans247 := thrift.NewTMemoryBufferLen(len(arg246))
+    defer mbTrans247.Close()
+    _, err248 := mbTrans247.WriteString(arg246)
+    if err248 != nil {
       Usage()
       return
     }
-    factory248 := thrift.NewTJSONProtocolFactory()
-    jsProt249 := factory248.GetProtocol(mbTrans246)
+    factory249 := thrift.NewTJSONProtocolFactory()
+    jsProt250 := factory249.GetProtocol(mbTrans247)
     argvalue0 := aurora.NewJobUpdateKey()
-    err250 := argvalue0.Read(jsProt249)
-    if err250 != nil {
+    err251 := argvalue0.Read(jsProt250)
+    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)
-    mbTrans253 := thrift.NewTMemoryBufferLen(len(arg252))
-    defer mbTrans253.Close()
-    _, err254 := mbTrans253.WriteString(arg252)
-    if err254 != nil {
+    arg253 := flag.Arg(1)
+    mbTrans254 := thrift.NewTMemoryBufferLen(len(arg253))
+    defer mbTrans254.Close()
+    _, err255 := mbTrans254.WriteString(arg253)
+    if err255 != nil {
       Usage()
       return
     }
-    factory255 := thrift.NewTJSONProtocolFactory()
-    jsProt256 := factory255.GetProtocol(mbTrans253)
+    factory256 := thrift.NewTJSONProtocolFactory()
+    jsProt257 := factory256.GetProtocol(mbTrans254)
     argvalue0 := aurora.NewJobUpdateKey()
-    err257 := argvalue0.Read(jsProt256)
-    if err257 != nil {
+    err258 := argvalue0.Read(jsProt257)
+    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)
-    mbTrans260 := thrift.NewTMemoryBufferLen(len(arg259))
-    defer mbTrans260.Close()
-    _, err261 := mbTrans260.WriteString(arg259)
-    if err261 != nil {
+    arg260 := flag.Arg(1)
+    mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
+    defer mbTrans261.Close()
+    _, err262 := mbTrans261.WriteString(arg260)
+    if err262 != nil {
       Usage()
       return
     }
-    factory262 := thrift.NewTJSONProtocolFactory()
-    jsProt263 := factory262.GetProtocol(mbTrans260)
+    factory263 := thrift.NewTJSONProtocolFactory()
+    jsProt264 := factory263.GetProtocol(mbTrans261)
     argvalue0 := aurora.NewJobUpdateKey()
-    err264 := argvalue0.Read(jsProt263)
-    if err264 != nil {
+    err265 := argvalue0.Read(jsProt264)
+    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)
-    mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
-    defer mbTrans267.Close()
-    _, err268 := mbTrans267.WriteString(arg266)
-    if err268 != nil {
+    arg267 := flag.Arg(1)
+    mbTrans268 := thrift.NewTMemoryBufferLen(len(arg267))
+    defer mbTrans268.Close()
+    _, err269 := mbTrans268.WriteString(arg267)
+    if err269 != nil {
       Usage()
       return
     }
-    factory269 := thrift.NewTJSONProtocolFactory()
-    jsProt270 := factory269.GetProtocol(mbTrans267)
+    factory270 := thrift.NewTJSONProtocolFactory()
+    jsProt271 := factory270.GetProtocol(mbTrans268)
     argvalue0 := aurora.NewTaskQuery()
-    err271 := argvalue0.Read(jsProt270)
-    if err271 != nil {
+    err272 := argvalue0.Read(jsProt271)
+    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)
-    mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
-    defer mbTrans273.Close()
-    _, err274 := mbTrans273.WriteString(arg272)
-    if err274 != nil {
+    arg273 := flag.Arg(1)
+    mbTrans274 := thrift.NewTMemoryBufferLen(len(arg273))
+    defer mbTrans274.Close()
+    _, err275 := mbTrans274.WriteString(arg273)
+    if err275 != nil {
       Usage()
       return
     }
-    factory275 := thrift.NewTJSONProtocolFactory()
-    jsProt276 := factory275.GetProtocol(mbTrans273)
+    factory276 := thrift.NewTJSONProtocolFactory()
+    jsProt277 := factory276.GetProtocol(mbTrans274)
     argvalue0 := aurora.NewTaskQuery()
-    err277 := argvalue0.Read(jsProt276)
-    if err277 != nil {
+    err278 := argvalue0.Read(jsProt277)
+    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)
-    mbTrans279 := thrift.NewTMemoryBufferLen(len(arg278))
-    defer mbTrans279.Close()
-    _, err280 := mbTrans279.WriteString(arg278)
-    if err280 != nil {
+    arg279 := flag.Arg(1)
+    mbTrans280 := thrift.NewTMemoryBufferLen(len(arg279))
+    defer mbTrans280.Close()
+    _, err281 := mbTrans280.WriteString(arg279)
+    if err281 != nil {
       Usage()
       return
     }
-    factory281 := thrift.NewTJSONProtocolFactory()
-    jsProt282 := factory281.GetProtocol(mbTrans279)
+    factory282 := thrift.NewTJSONProtocolFactory()
+    jsProt283 := factory282.GetProtocol(mbTrans280)
     argvalue0 := aurora.NewTaskQuery()
-    err283 := argvalue0.Read(jsProt282)
-    if err283 != nil {
+    err284 := argvalue0.Read(jsProt283)
+    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)
-    mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
-    defer mbTrans285.Close()
-    _, err286 := mbTrans285.WriteString(arg284)
-    if err286 != nil {
+    arg285 := flag.Arg(1)
+    mbTrans286 := thrift.NewTMemoryBufferLen(len(arg285))
+    defer mbTrans286.Close()
+    _, err287 := mbTrans286.WriteString(arg285)
+    if err287 != nil {
       Usage()
       return
     }
-    factory287 := thrift.NewTJSONProtocolFactory()
-    jsProt288 := factory287.GetProtocol(mbTrans285)
+    factory288 := thrift.NewTJSONProtocolFactory()
+    jsProt289 := factory288.GetProtocol(mbTrans286)
     argvalue0 := aurora.NewJobKey()
-    err289 := argvalue0.Read(jsProt288)
-    if err289 != nil {
+    err290 := argvalue0.Read(jsProt289)
+    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)
-    mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
-    defer mbTrans293.Close()
-    _, err294 := mbTrans293.WriteString(arg292)
-    if err294 != nil {
+    arg293 := flag.Arg(1)
+    mbTrans294 := thrift.NewTMemoryBufferLen(len(arg293))
+    defer mbTrans294.Close()
+    _, err295 := mbTrans294.WriteString(arg293)
+    if err295 != nil {
       Usage()
       return
     }
-    factory295 := thrift.NewTJSONProtocolFactory()
-    jsProt296 := factory295.GetProtocol(mbTrans293)
+    factory296 := thrift.NewTJSONProtocolFactory()
+    jsProt297 := factory296.GetProtocol(mbTrans294)
     argvalue0 := aurora.NewJobConfiguration()
-    err297 := argvalue0.Read(jsProt296)
-    if err297 != nil {
+    err298 := argvalue0.Read(jsProt297)
+    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)
-    mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
-    defer mbTrans299.Close()
-    _, err300 := mbTrans299.WriteString(arg298)
-    if err300 != nil {
+    arg299 := flag.Arg(1)
+    mbTrans300 := thrift.NewTMemoryBufferLen(len(arg299))
+    defer mbTrans300.Close()
+    _, err301 := mbTrans300.WriteString(arg299)
+    if err301 != nil {
       Usage()
       return
     }
-    factory301 := thrift.NewTJSONProtocolFactory()
-    jsProt302 := factory301.GetProtocol(mbTrans299)
+    factory302 := thrift.NewTJSONProtocolFactory()
+    jsProt303 := factory302.GetProtocol(mbTrans300)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err303 := argvalue0.Read(jsProt302)
-    if err303 != nil {
+    err304 := argvalue0.Read(jsProt303)
+    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)
-    mbTrans305 := thrift.NewTMemoryBufferLen(len(arg304))
-    defer mbTrans305.Close()
-    _, err306 := mbTrans305.WriteString(arg304)
-    if err306 != nil {
+    arg305 := flag.Arg(1)
+    mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
+    defer mbTrans306.Close()
+    _, err307 := mbTrans306.WriteString(arg305)
+    if err307 != nil {
       Usage()
       return
     }
-    factory307 := thrift.NewTJSONProtocolFactory()
-    jsProt308 := factory307.GetProtocol(mbTrans305)
+    factory308 := thrift.NewTJSONProtocolFactory()
+    jsProt309 := factory308.GetProtocol(mbTrans306)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err309 := argvalue0.Read(jsProt308)
-    if err309 != nil {
+    err310 := argvalue0.Read(jsProt309)
+    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)
-    mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
-    defer mbTrans311.Close()
-    _, err312 := mbTrans311.WriteString(arg310)
-    if err312 != nil {
+    arg311 := flag.Arg(1)
+    mbTrans312 := thrift.NewTMemoryBufferLen(len(arg311))
+    defer mbTrans312.Close()
+    _, err313 := mbTrans312.WriteString(arg311)
+    if err313 != nil {
       Usage()
       return
     }
-    factory313 := thrift.NewTJSONProtocolFactory()
-    jsProt314 := factory313.GetProtocol(mbTrans311)
+    factory314 := thrift.NewTJSONProtocolFactory()
+    jsProt315 := factory314.GetProtocol(mbTrans312)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err315 := argvalue0.Read(jsProt314)
-    if err315 != nil {
+    err316 := argvalue0.Read(jsProt315)
+    if err316 != nil {
       Usage()
       return
     }

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)
-    mbTrans82 := thrift.NewTMemoryBufferLen(len(arg81))
-    defer mbTrans82.Close()
-    _, err83 := mbTrans82.WriteString(arg81)
-    if err83 != nil {
+    arg82 := flag.Arg(1)
+    mbTrans83 := thrift.NewTMemoryBufferLen(len(arg82))
+    defer mbTrans83.Close()
+    _, err84 := mbTrans83.WriteString(arg82)
+    if err84 != nil {
       Usage()
       return
     }
-    factory84 := thrift.NewTJSONProtocolFactory()
-    jsProt85 := factory84.GetProtocol(mbTrans82)
+    factory85 := thrift.NewTJSONProtocolFactory()
+    jsProt86 := factory85.GetProtocol(mbTrans83)
     argvalue0 := aurora.NewTaskQuery()
-    err86 := argvalue0.Read(jsProt85)
-    if err86 != nil {
+    err87 := argvalue0.Read(jsProt86)
+    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)
-    mbTrans88 := thrift.NewTMemoryBufferLen(len(arg87))
-    defer mbTrans88.Close()
-    _, err89 := mbTrans88.WriteString(arg87)
-    if err89 != nil {
+    arg88 := flag.Arg(1)
+    mbTrans89 := thrift.NewTMemoryBufferLen(len(arg88))
+    defer mbTrans89.Close()
+    _, err90 := mbTrans89.WriteString(arg88)
+    if err90 != nil {
       Usage()
       return
     }
-    factory90 := thrift.NewTJSONProtocolFactory()
-    jsProt91 := factory90.GetProtocol(mbTrans88)
+    factory91 := thrift.NewTJSONProtocolFactory()
+    jsProt92 := factory91.GetProtocol(mbTrans89)
     argvalue0 := aurora.NewTaskQuery()
-    err92 := argvalue0.Read(jsProt91)
-    if err92 != nil {
+    err93 := argvalue0.Read(jsProt92)
+    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)
-    mbTrans94 := thrift.NewTMemoryBufferLen(len(arg93))
-    defer mbTrans94.Close()
-    _, err95 := mbTrans94.WriteString(arg93)
-    if err95 != nil {
+    arg94 := flag.Arg(1)
+    mbTrans95 := thrift.NewTMemoryBufferLen(len(arg94))
+    defer mbTrans95.Close()
+    _, err96 := mbTrans95.WriteString(arg94)
+    if err96 != nil {
       Usage()
       return
     }
-    factory96 := thrift.NewTJSONProtocolFactory()
-    jsProt97 := factory96.GetProtocol(mbTrans94)
+    factory97 := thrift.NewTJSONProtocolFactory()
+    jsProt98 := factory97.GetProtocol(mbTrans95)
     argvalue0 := aurora.NewTaskQuery()
-    err98 := argvalue0.Read(jsProt97)
-    if err98 != nil {
+    err99 := argvalue0.Read(jsProt98)
+    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)
-    mbTrans100 := thrift.NewTMemoryBufferLen(len(arg99))
-    defer mbTrans100.Close()
-    _, err101 := mbTrans100.WriteString(arg99)
-    if err101 != nil {
+    arg100 := flag.Arg(1)
+    mbTrans101 := thrift.NewTMemoryBufferLen(len(arg100))
+    defer mbTrans101.Close()
+    _, err102 := mbTrans101.WriteString(arg100)
+    if err102 != nil {
       Usage()
       return
     }
-    factory102 := thrift.NewTJSONProtocolFactory()
-    jsProt103 := factory102.GetProtocol(mbTrans100)
+    factory103 := thrift.NewTJSONProtocolFactory()
+    jsProt104 := factory103.GetProtocol(mbTrans101)
     argvalue0 := aurora.NewJobKey()
-    err104 := argvalue0.Read(jsProt103)
-    if err104 != nil {
+    err105 := argvalue0.Read(jsProt104)
+    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)
-    mbTrans108 := thrift.NewTMemoryBufferLen(len(arg107))
-    defer mbTrans108.Close()
-    _, err109 := mbTrans108.WriteString(arg107)
-    if err109 != nil {
+    arg108 := flag.Arg(1)
+    mbTrans109 := thrift.NewTMemoryBufferLen(len(arg108))
+    defer mbTrans109.Close()
+    _, err110 := mbTrans109.WriteString(arg108)
+    if err110 != nil {
       Usage()
       return
     }
-    factory110 := thrift.NewTJSONProtocolFactory()
-    jsProt111 := factory110.GetProtocol(mbTrans108)
+    factory111 := thrift.NewTJSONProtocolFactory()
+    jsProt112 := factory111.GetProtocol(mbTrans109)
     argvalue0 := aurora.NewJobConfiguration()
-    err112 := argvalue0.Read(jsProt111)
-    if err112 != nil {
+    err113 := argvalue0.Read(jsProt112)
+    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)
-    mbTrans114 := thrift.NewTMemoryBufferLen(len(arg113))
-    defer mbTrans114.Close()
-    _, err115 := mbTrans114.WriteString(arg113)
-    if err115 != nil {
+    arg114 := flag.Arg(1)
+    mbTrans115 := thrift.NewTMemoryBufferLen(len(arg114))
+    defer mbTrans115.Close()
+    _, err116 := mbTrans115.WriteString(arg114)
+    if err116 != nil {
       Usage()
       return
     }
-    factory116 := thrift.NewTJSONProtocolFactory()
-    jsProt117 := factory116.GetProtocol(mbTrans114)
+    factory117 := thrift.NewTJSONProtocolFactory()
+    jsProt118 := factory117.GetProtocol(mbTrans115)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err118 := argvalue0.Read(jsProt117)
-    if err118 != nil {
+    err119 := argvalue0.Read(jsProt118)
+    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)
-    mbTrans120 := thrift.NewTMemoryBufferLen(len(arg119))
-    defer mbTrans120.Close()
-    _, err121 := mbTrans120.WriteString(arg119)
-    if err121 != nil {
+    arg120 := flag.Arg(1)
+    mbTrans121 := thrift.NewTMemoryBufferLen(len(arg120))
+    defer mbTrans121.Close()
+    _, err122 := mbTrans121.WriteString(arg120)
+    if err122 != nil {
       Usage()
       return
     }
-    factory122 := thrift.NewTJSONProtocolFactory()
-    jsProt123 := factory122.GetProtocol(mbTrans120)
+    factory123 := thrift.NewTJSONProtocolFactory()
+    jsProt124 := factory123.GetProtocol(mbTrans121)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err124 := argvalue0.Read(jsProt123)
-    if err124 != nil {
+    err125 := argvalue0.Read(jsProt124)
+    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)
-    mbTrans126 := thrift.NewTMemoryBufferLen(len(arg125))
-    defer mbTrans126.Close()
-    _, err127 := mbTrans126.WriteString(arg125)
-    if err127 != nil {
+    arg126 := flag.Arg(1)
+    mbTrans127 := thrift.NewTMemoryBufferLen(len(arg126))
+    defer mbTrans127.Close()
+    _, err128 := mbTrans127.WriteString(arg126)
+    if err128 != nil {
       Usage()
       return
     }
-    factory128 := thrift.NewTJSONProtocolFactory()
-    jsProt129 := factory128.GetProtocol(mbTrans126)
+    factory129 := thrift.NewTJSONProtocolFactory()
+    jsProt130 := factory129.GetProtocol(mbTrans127)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err130 := argvalue0.Read(jsProt129)
-    if err130 != nil {
+    err131 := argvalue0.Read(jsProt130)
+    if err131 != nil {
       Usage()
       return
     }

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;

realis_e2e_test.go

@@ -916,3 +916,70 @@ 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)
+		})
+	}
+}

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