diff --git a/auroraAPI.thrift b/auroraAPI.thrift
index 6236523..3d3d5bc 100644
--- a/auroraAPI.thrift
+++ b/auroraAPI.thrift
@@ -706,14 +706,25 @@ struct JobUpdateSettings {
    */
   8: bool waitForBatchCompletion
 
- /**
+  /**
   * If set, requires external calls to pulseJobUpdate RPC within the specified rate for the
   * update to make progress. If no pulses received within specified interval the update will
   * block. A blocked update is unable to continue but retains its current status. It may only get
   * unblocked by a fresh pulseJobUpdate call.
   */
   9: optional i32 blockIfNoPulsesAfterMs
-}
+
+  /**
+   * This list contains the number of instances that each batch will complete before moving on to
+   * the next. This field can only be used with waitForBatchCompletion set as true.
+  **/
+  10: optional list<i32> variableUpdateGroupSize
+
+  /**
+   * Pauses the deployment of further tasks after each batch completes
+   * until the user sends an resume call.
+   **/
+  11: bool autoPause}
 
 /** Event marking a state transition in job update lifecycle. */
 struct JobUpdateEvent {
diff --git a/examples/client.go b/examples/client.go
index 7162408..41a9145 100644
--- a/examples/client.go
+++ b/examples/client.go
@@ -191,7 +191,8 @@ func main() {
 		// Create a service with three instances using the update API instead of the createJob API
 		fmt.Println("Creating service")
 		settings := realis.NewUpdateSettings()
-		job.InstanceCount(3)
+		settings.VariableUpdateGroupSize = []int32{1, 2, 3}
+		job.InstanceCount(6).RAM(16).CPU(.1)
 		resp, result, err := r.CreateService(job, settings)
 		if err != nil {
 			fmt.Println("error: ", err)
@@ -416,8 +417,8 @@ func main() {
 			fmt.Println(err)
 			os.Exit(1)
 		}
-		updateJob := realis.NewDefaultUpdateJob(taskConfig)
-		updateJob.InstanceCount(5).RAM(128)
+		updateJob := realis.NewDefaultUpdateJob(taskConfig).WaitForBatchCompletion(true).BatchSize(2)
+		updateJob.InstanceCount(6).RAM(32).CPU(.2)
 
 		resp, err := r.StartJobUpdate(updateJob, "")
 		if err != nil {
diff --git a/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go b/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
index 3afe684..74d5cac 100755
--- a/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
+++ b/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
@@ -165,19 +165,19 @@ func main() {
 		}
 		argvalue0 := flag.Arg(1)
 		value0 := argvalue0
-		arg353 := flag.Arg(2)
-		mbTrans354 := thrift.NewTMemoryBufferLen(len(arg353))
-		defer mbTrans354.Close()
-		_, err355 := mbTrans354.WriteString(arg353)
-		if err355 != nil {
+		arg354 := flag.Arg(2)
+		mbTrans355 := thrift.NewTMemoryBufferLen(len(arg354))
+		defer mbTrans355.Close()
+		_, err356 := mbTrans355.WriteString(arg354)
+		if err356 != nil {
 			Usage()
 			return
 		}
-		factory356 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt357 := factory356.GetProtocol(mbTrans354)
+		factory357 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt358 := factory357.GetProtocol(mbTrans355)
 		argvalue1 := aurora.NewResourceAggregate()
-		err358 := argvalue1.Read(jsProt357)
-		if err358 != nil {
+		err359 := argvalue1.Read(jsProt358)
+		if err359 != nil {
 			Usage()
 			return
 		}
@@ -233,19 +233,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "QueryRecovery requires 1 args")
 			flag.Usage()
 		}
-		arg361 := flag.Arg(1)
-		mbTrans362 := thrift.NewTMemoryBufferLen(len(arg361))
-		defer mbTrans362.Close()
-		_, err363 := mbTrans362.WriteString(arg361)
-		if err363 != nil {
+		arg362 := flag.Arg(1)
+		mbTrans363 := thrift.NewTMemoryBufferLen(len(arg362))
+		defer mbTrans363.Close()
+		_, err364 := mbTrans363.WriteString(arg362)
+		if err364 != nil {
 			Usage()
 			return
 		}
-		factory364 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt365 := factory364.GetProtocol(mbTrans362)
+		factory365 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt366 := factory365.GetProtocol(mbTrans363)
 		argvalue0 := aurora.NewTaskQuery()
-		err366 := argvalue0.Read(jsProt365)
-		if err366 != nil {
+		err367 := argvalue0.Read(jsProt366)
+		if err367 != nil {
 			Usage()
 			return
 		}
@@ -258,19 +258,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DeleteRecoveryTasks requires 1 args")
 			flag.Usage()
 		}
-		arg367 := flag.Arg(1)
-		mbTrans368 := thrift.NewTMemoryBufferLen(len(arg367))
-		defer mbTrans368.Close()
-		_, err369 := mbTrans368.WriteString(arg367)
-		if err369 != nil {
+		arg368 := flag.Arg(1)
+		mbTrans369 := thrift.NewTMemoryBufferLen(len(arg368))
+		defer mbTrans369.Close()
+		_, err370 := mbTrans369.WriteString(arg368)
+		if err370 != nil {
 			Usage()
 			return
 		}
-		factory370 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt371 := factory370.GetProtocol(mbTrans368)
+		factory371 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt372 := factory371.GetProtocol(mbTrans369)
 		argvalue0 := aurora.NewTaskQuery()
-		err372 := argvalue0.Read(jsProt371)
-		if err372 != nil {
+		err373 := argvalue0.Read(jsProt372)
+		if err373 != nil {
 			Usage()
 			return
 		}
@@ -299,19 +299,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg373 := flag.Arg(1)
-		mbTrans374 := thrift.NewTMemoryBufferLen(len(arg373))
-		defer mbTrans374.Close()
-		_, err375 := mbTrans374.WriteString(arg373)
-		if err375 != nil {
+		arg374 := flag.Arg(1)
+		mbTrans375 := thrift.NewTMemoryBufferLen(len(arg374))
+		defer mbTrans375.Close()
+		_, err376 := mbTrans375.WriteString(arg374)
+		if err376 != nil {
 			Usage()
 			return
 		}
-		factory376 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt377 := factory376.GetProtocol(mbTrans374)
+		factory377 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt378 := factory377.GetProtocol(mbTrans375)
 		argvalue0 := aurora.NewHosts()
-		err378 := argvalue0.Read(jsProt377)
-		if err378 != nil {
+		err379 := argvalue0.Read(jsProt378)
+		if err379 != nil {
 			Usage()
 			return
 		}
@@ -324,19 +324,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DrainHosts requires 1 args")
 			flag.Usage()
 		}
-		arg379 := flag.Arg(1)
-		mbTrans380 := thrift.NewTMemoryBufferLen(len(arg379))
-		defer mbTrans380.Close()
-		_, err381 := mbTrans380.WriteString(arg379)
-		if err381 != nil {
+		arg380 := flag.Arg(1)
+		mbTrans381 := thrift.NewTMemoryBufferLen(len(arg380))
+		defer mbTrans381.Close()
+		_, err382 := mbTrans381.WriteString(arg380)
+		if err382 != nil {
 			Usage()
 			return
 		}
-		factory382 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt383 := factory382.GetProtocol(mbTrans380)
+		factory383 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt384 := factory383.GetProtocol(mbTrans381)
 		argvalue0 := aurora.NewHosts()
-		err384 := argvalue0.Read(jsProt383)
-		if err384 != nil {
+		err385 := argvalue0.Read(jsProt384)
+		if err385 != nil {
 			Usage()
 			return
 		}
@@ -349,19 +349,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "MaintenanceStatus requires 1 args")
 			flag.Usage()
 		}
-		arg385 := flag.Arg(1)
-		mbTrans386 := thrift.NewTMemoryBufferLen(len(arg385))
-		defer mbTrans386.Close()
-		_, err387 := mbTrans386.WriteString(arg385)
-		if err387 != nil {
+		arg386 := flag.Arg(1)
+		mbTrans387 := thrift.NewTMemoryBufferLen(len(arg386))
+		defer mbTrans387.Close()
+		_, err388 := mbTrans387.WriteString(arg386)
+		if err388 != nil {
 			Usage()
 			return
 		}
-		factory388 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt389 := factory388.GetProtocol(mbTrans386)
+		factory389 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt390 := factory389.GetProtocol(mbTrans387)
 		argvalue0 := aurora.NewHosts()
-		err390 := argvalue0.Read(jsProt389)
-		if err390 != nil {
+		err391 := argvalue0.Read(jsProt390)
+		if err391 != nil {
 			Usage()
 			return
 		}
@@ -374,19 +374,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "EndMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg391 := flag.Arg(1)
-		mbTrans392 := thrift.NewTMemoryBufferLen(len(arg391))
-		defer mbTrans392.Close()
-		_, err393 := mbTrans392.WriteString(arg391)
-		if err393 != nil {
+		arg392 := flag.Arg(1)
+		mbTrans393 := thrift.NewTMemoryBufferLen(len(arg392))
+		defer mbTrans393.Close()
+		_, err394 := mbTrans393.WriteString(arg392)
+		if err394 != nil {
 			Usage()
 			return
 		}
-		factory394 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt395 := factory394.GetProtocol(mbTrans392)
+		factory395 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt396 := factory395.GetProtocol(mbTrans393)
 		argvalue0 := aurora.NewHosts()
-		err396 := argvalue0.Read(jsProt395)
-		if err396 != nil {
+		err397 := argvalue0.Read(jsProt396)
+		if err397 != nil {
 			Usage()
 			return
 		}
@@ -407,19 +407,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "TriggerExplicitTaskReconciliation requires 1 args")
 			flag.Usage()
 		}
-		arg397 := flag.Arg(1)
-		mbTrans398 := thrift.NewTMemoryBufferLen(len(arg397))
-		defer mbTrans398.Close()
-		_, err399 := mbTrans398.WriteString(arg397)
-		if err399 != nil {
+		arg398 := flag.Arg(1)
+		mbTrans399 := thrift.NewTMemoryBufferLen(len(arg398))
+		defer mbTrans399.Close()
+		_, err400 := mbTrans399.WriteString(arg398)
+		if err400 != nil {
 			Usage()
 			return
 		}
-		factory400 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt401 := factory400.GetProtocol(mbTrans398)
+		factory401 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt402 := factory401.GetProtocol(mbTrans399)
 		argvalue0 := aurora.NewExplicitReconciliationSettings()
-		err402 := argvalue0.Read(jsProt401)
-		if err402 != nil {
+		err403 := argvalue0.Read(jsProt402)
+		if err403 != nil {
 			Usage()
 			return
 		}
@@ -440,19 +440,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PruneTasks requires 1 args")
 			flag.Usage()
 		}
-		arg403 := flag.Arg(1)
-		mbTrans404 := thrift.NewTMemoryBufferLen(len(arg403))
-		defer mbTrans404.Close()
-		_, err405 := mbTrans404.WriteString(arg403)
-		if err405 != nil {
+		arg404 := flag.Arg(1)
+		mbTrans405 := thrift.NewTMemoryBufferLen(len(arg404))
+		defer mbTrans405.Close()
+		_, err406 := mbTrans405.WriteString(arg404)
+		if err406 != nil {
 			Usage()
 			return
 		}
-		factory406 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt407 := factory406.GetProtocol(mbTrans404)
+		factory407 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt408 := factory407.GetProtocol(mbTrans405)
 		argvalue0 := aurora.NewTaskQuery()
-		err408 := argvalue0.Read(jsProt407)
-		if err408 != nil {
+		err409 := argvalue0.Read(jsProt408)
+		if err409 != nil {
 			Usage()
 			return
 		}
@@ -465,19 +465,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
 			flag.Usage()
 		}
-		arg409 := flag.Arg(1)
-		mbTrans410 := thrift.NewTMemoryBufferLen(len(arg409))
-		defer mbTrans410.Close()
-		_, err411 := mbTrans410.WriteString(arg409)
-		if err411 != nil {
+		arg410 := flag.Arg(1)
+		mbTrans411 := thrift.NewTMemoryBufferLen(len(arg410))
+		defer mbTrans411.Close()
+		_, err412 := mbTrans411.WriteString(arg410)
+		if err412 != nil {
 			Usage()
 			return
 		}
-		factory412 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt413 := factory412.GetProtocol(mbTrans410)
+		factory413 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt414 := factory413.GetProtocol(mbTrans411)
 		argvalue0 := aurora.NewJobConfiguration()
-		err414 := argvalue0.Read(jsProt413)
-		if err414 != nil {
+		err415 := argvalue0.Read(jsProt414)
+		if err415 != nil {
 			Usage()
 			return
 		}
@@ -490,19 +490,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg415 := flag.Arg(1)
-		mbTrans416 := thrift.NewTMemoryBufferLen(len(arg415))
-		defer mbTrans416.Close()
-		_, err417 := mbTrans416.WriteString(arg415)
-		if err417 != nil {
+		arg416 := flag.Arg(1)
+		mbTrans417 := thrift.NewTMemoryBufferLen(len(arg416))
+		defer mbTrans417.Close()
+		_, err418 := mbTrans417.WriteString(arg416)
+		if err418 != nil {
 			Usage()
 			return
 		}
-		factory418 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt419 := factory418.GetProtocol(mbTrans416)
+		factory419 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt420 := factory419.GetProtocol(mbTrans417)
 		argvalue0 := aurora.NewJobConfiguration()
-		err420 := argvalue0.Read(jsProt419)
-		if err420 != nil {
+		err421 := argvalue0.Read(jsProt420)
+		if err421 != nil {
 			Usage()
 			return
 		}
@@ -515,19 +515,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg421 := flag.Arg(1)
-		mbTrans422 := thrift.NewTMemoryBufferLen(len(arg421))
-		defer mbTrans422.Close()
-		_, err423 := mbTrans422.WriteString(arg421)
-		if err423 != nil {
+		arg422 := flag.Arg(1)
+		mbTrans423 := thrift.NewTMemoryBufferLen(len(arg422))
+		defer mbTrans423.Close()
+		_, err424 := mbTrans423.WriteString(arg422)
+		if err424 != nil {
 			Usage()
 			return
 		}
-		factory424 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt425 := factory424.GetProtocol(mbTrans422)
+		factory425 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt426 := factory425.GetProtocol(mbTrans423)
 		argvalue0 := aurora.NewJobKey()
-		err426 := argvalue0.Read(jsProt425)
-		if err426 != nil {
+		err427 := argvalue0.Read(jsProt426)
+		if err427 != nil {
 			Usage()
 			return
 		}
@@ -540,19 +540,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg427 := flag.Arg(1)
-		mbTrans428 := thrift.NewTMemoryBufferLen(len(arg427))
-		defer mbTrans428.Close()
-		_, err429 := mbTrans428.WriteString(arg427)
-		if err429 != nil {
+		arg428 := flag.Arg(1)
+		mbTrans429 := thrift.NewTMemoryBufferLen(len(arg428))
+		defer mbTrans429.Close()
+		_, err430 := mbTrans429.WriteString(arg428)
+		if err430 != nil {
 			Usage()
 			return
 		}
-		factory430 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt431 := factory430.GetProtocol(mbTrans428)
+		factory431 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt432 := factory431.GetProtocol(mbTrans429)
 		argvalue0 := aurora.NewJobKey()
-		err432 := argvalue0.Read(jsProt431)
-		if err432 != nil {
+		err433 := argvalue0.Read(jsProt432)
+		if err433 != nil {
 			Usage()
 			return
 		}
@@ -565,36 +565,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
 			flag.Usage()
 		}
-		arg433 := flag.Arg(1)
-		mbTrans434 := thrift.NewTMemoryBufferLen(len(arg433))
-		defer mbTrans434.Close()
-		_, err435 := mbTrans434.WriteString(arg433)
-		if err435 != nil {
+		arg434 := flag.Arg(1)
+		mbTrans435 := thrift.NewTMemoryBufferLen(len(arg434))
+		defer mbTrans435.Close()
+		_, err436 := mbTrans435.WriteString(arg434)
+		if err436 != nil {
 			Usage()
 			return
 		}
-		factory436 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt437 := factory436.GetProtocol(mbTrans434)
+		factory437 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt438 := factory437.GetProtocol(mbTrans435)
 		argvalue0 := aurora.NewJobKey()
-		err438 := argvalue0.Read(jsProt437)
-		if err438 != nil {
+		err439 := argvalue0.Read(jsProt438)
+		if err439 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg439 := flag.Arg(2)
-		mbTrans440 := thrift.NewTMemoryBufferLen(len(arg439))
-		defer mbTrans440.Close()
-		_, err441 := mbTrans440.WriteString(arg439)
-		if err441 != nil {
+		arg440 := flag.Arg(2)
+		mbTrans441 := thrift.NewTMemoryBufferLen(len(arg440))
+		defer mbTrans441.Close()
+		_, err442 := mbTrans441.WriteString(arg440)
+		if err442 != nil {
 			Usage()
 			return
 		}
-		factory442 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt443 := factory442.GetProtocol(mbTrans440)
+		factory443 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt444 := factory443.GetProtocol(mbTrans441)
 		containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
-		err444 := containerStruct1.ReadField2(jsProt443)
-		if err444 != nil {
+		err445 := containerStruct1.ReadField2(jsProt444)
+		if err445 != nil {
 			Usage()
 			return
 		}
@@ -608,36 +608,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
 			flag.Usage()
 		}
-		arg445 := flag.Arg(1)
-		mbTrans446 := thrift.NewTMemoryBufferLen(len(arg445))
-		defer mbTrans446.Close()
-		_, err447 := mbTrans446.WriteString(arg445)
-		if err447 != nil {
+		arg446 := flag.Arg(1)
+		mbTrans447 := thrift.NewTMemoryBufferLen(len(arg446))
+		defer mbTrans447.Close()
+		_, err448 := mbTrans447.WriteString(arg446)
+		if err448 != nil {
 			Usage()
 			return
 		}
-		factory448 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt449 := factory448.GetProtocol(mbTrans446)
+		factory449 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt450 := factory449.GetProtocol(mbTrans447)
 		argvalue0 := aurora.NewJobKey()
-		err450 := argvalue0.Read(jsProt449)
-		if err450 != nil {
+		err451 := argvalue0.Read(jsProt450)
+		if err451 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg451 := flag.Arg(2)
-		mbTrans452 := thrift.NewTMemoryBufferLen(len(arg451))
-		defer mbTrans452.Close()
-		_, err453 := mbTrans452.WriteString(arg451)
-		if err453 != nil {
+		arg452 := flag.Arg(2)
+		mbTrans453 := thrift.NewTMemoryBufferLen(len(arg452))
+		defer mbTrans453.Close()
+		_, err454 := mbTrans453.WriteString(arg452)
+		if err454 != nil {
 			Usage()
 			return
 		}
-		factory454 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt455 := factory454.GetProtocol(mbTrans452)
+		factory455 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt456 := factory455.GetProtocol(mbTrans453)
 		containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
-		err456 := containerStruct1.ReadField2(jsProt455)
-		if err456 != nil {
+		err457 := containerStruct1.ReadField2(jsProt456)
+		if err457 != nil {
 			Usage()
 			return
 		}
@@ -653,25 +653,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg458 := flag.Arg(1)
-		mbTrans459 := thrift.NewTMemoryBufferLen(len(arg458))
-		defer mbTrans459.Close()
-		_, err460 := mbTrans459.WriteString(arg458)
-		if err460 != nil {
+		arg459 := flag.Arg(1)
+		mbTrans460 := thrift.NewTMemoryBufferLen(len(arg459))
+		defer mbTrans460.Close()
+		_, err461 := mbTrans460.WriteString(arg459)
+		if err461 != nil {
 			Usage()
 			return
 		}
-		factory461 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt462 := factory461.GetProtocol(mbTrans459)
+		factory462 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt463 := factory462.GetProtocol(mbTrans460)
 		argvalue0 := aurora.NewInstanceKey()
-		err463 := argvalue0.Read(jsProt462)
-		if err463 != nil {
+		err464 := argvalue0.Read(jsProt463)
+		if err464 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err464 := (strconv.Atoi(flag.Arg(2)))
-		if err464 != nil {
+		tmp1, err465 := (strconv.Atoi(flag.Arg(2)))
+		if err465 != nil {
 			Usage()
 			return
 		}
@@ -685,19 +685,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg465 := flag.Arg(1)
-		mbTrans466 := thrift.NewTMemoryBufferLen(len(arg465))
-		defer mbTrans466.Close()
-		_, err467 := mbTrans466.WriteString(arg465)
-		if err467 != nil {
+		arg466 := flag.Arg(1)
+		mbTrans467 := thrift.NewTMemoryBufferLen(len(arg466))
+		defer mbTrans467.Close()
+		_, err468 := mbTrans467.WriteString(arg466)
+		if err468 != nil {
 			Usage()
 			return
 		}
-		factory468 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt469 := factory468.GetProtocol(mbTrans466)
+		factory469 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt470 := factory469.GetProtocol(mbTrans467)
 		argvalue0 := aurora.NewJobConfiguration()
-		err470 := argvalue0.Read(jsProt469)
-		if err470 != nil {
+		err471 := argvalue0.Read(jsProt470)
+		if err471 != nil {
 			Usage()
 			return
 		}
@@ -710,19 +710,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg471 := flag.Arg(1)
-		mbTrans472 := thrift.NewTMemoryBufferLen(len(arg471))
-		defer mbTrans472.Close()
-		_, err473 := mbTrans472.WriteString(arg471)
-		if err473 != nil {
+		arg472 := flag.Arg(1)
+		mbTrans473 := thrift.NewTMemoryBufferLen(len(arg472))
+		defer mbTrans473.Close()
+		_, err474 := mbTrans473.WriteString(arg472)
+		if err474 != nil {
 			Usage()
 			return
 		}
-		factory474 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt475 := factory474.GetProtocol(mbTrans472)
+		factory475 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt476 := factory475.GetProtocol(mbTrans473)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err476 := argvalue0.Read(jsProt475)
-		if err476 != nil {
+		err477 := argvalue0.Read(jsProt476)
+		if err477 != nil {
 			Usage()
 			return
 		}
@@ -737,19 +737,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg478 := flag.Arg(1)
-		mbTrans479 := thrift.NewTMemoryBufferLen(len(arg478))
-		defer mbTrans479.Close()
-		_, err480 := mbTrans479.WriteString(arg478)
-		if err480 != nil {
+		arg479 := flag.Arg(1)
+		mbTrans480 := thrift.NewTMemoryBufferLen(len(arg479))
+		defer mbTrans480.Close()
+		_, err481 := mbTrans480.WriteString(arg479)
+		if err481 != nil {
 			Usage()
 			return
 		}
-		factory481 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt482 := factory481.GetProtocol(mbTrans479)
+		factory482 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt483 := factory482.GetProtocol(mbTrans480)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err483 := argvalue0.Read(jsProt482)
-		if err483 != nil {
+		err484 := argvalue0.Read(jsProt483)
+		if err484 != nil {
 			Usage()
 			return
 		}
@@ -764,19 +764,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate 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.NewTSimpleJSONProtocolFactory()
-		jsProt489 := factory488.GetProtocol(mbTrans486)
+		factory489 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt490 := factory489.GetProtocol(mbTrans487)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err490 := argvalue0.Read(jsProt489)
-		if err490 != nil {
+		err491 := argvalue0.Read(jsProt490)
+		if err491 != nil {
 			Usage()
 			return
 		}
@@ -791,19 +791,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate 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.NewTSimpleJSONProtocolFactory()
-		jsProt496 := factory495.GetProtocol(mbTrans493)
+		factory496 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt497 := factory496.GetProtocol(mbTrans494)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err497 := argvalue0.Read(jsProt496)
-		if err497 != nil {
+		err498 := argvalue0.Read(jsProt497)
+		if err498 != nil {
 			Usage()
 			return
 		}
@@ -818,19 +818,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RollbackJobUpdate 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.NewTSimpleJSONProtocolFactory()
-		jsProt503 := factory502.GetProtocol(mbTrans500)
+		factory503 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt504 := factory503.GetProtocol(mbTrans501)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err504 := argvalue0.Read(jsProt503)
-		if err504 != nil {
+		err505 := argvalue0.Read(jsProt504)
+		if err505 != nil {
 			Usage()
 			return
 		}
@@ -845,19 +845,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 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.NewTSimpleJSONProtocolFactory()
-		jsProt510 := factory509.GetProtocol(mbTrans507)
+		factory510 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt511 := factory510.GetProtocol(mbTrans508)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err511 := argvalue0.Read(jsProt510)
-		if err511 != nil {
+		err512 := argvalue0.Read(jsProt511)
+		if err512 != nil {
 			Usage()
 			return
 		}
@@ -888,19 +888,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 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.NewTSimpleJSONProtocolFactory()
-		jsProt517 := factory516.GetProtocol(mbTrans514)
+		factory517 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt518 := factory517.GetProtocol(mbTrans515)
 		argvalue0 := aurora.NewTaskQuery()
-		err518 := argvalue0.Read(jsProt517)
-		if err518 != nil {
+		err519 := argvalue0.Read(jsProt518)
+		if err519 != nil {
 			Usage()
 			return
 		}
@@ -913,19 +913,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg519 := flag.Arg(1)
-		mbTrans520 := thrift.NewTMemoryBufferLen(len(arg519))
-		defer mbTrans520.Close()
-		_, err521 := mbTrans520.WriteString(arg519)
-		if err521 != nil {
+		arg520 := flag.Arg(1)
+		mbTrans521 := thrift.NewTMemoryBufferLen(len(arg520))
+		defer mbTrans521.Close()
+		_, err522 := mbTrans521.WriteString(arg520)
+		if err522 != nil {
 			Usage()
 			return
 		}
-		factory522 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt523 := factory522.GetProtocol(mbTrans520)
+		factory523 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt524 := factory523.GetProtocol(mbTrans521)
 		argvalue0 := aurora.NewTaskQuery()
-		err524 := argvalue0.Read(jsProt523)
-		if err524 != nil {
+		err525 := argvalue0.Read(jsProt524)
+		if err525 != nil {
 			Usage()
 			return
 		}
@@ -938,19 +938,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg525 := flag.Arg(1)
-		mbTrans526 := thrift.NewTMemoryBufferLen(len(arg525))
-		defer mbTrans526.Close()
-		_, err527 := mbTrans526.WriteString(arg525)
-		if err527 != nil {
+		arg526 := flag.Arg(1)
+		mbTrans527 := thrift.NewTMemoryBufferLen(len(arg526))
+		defer mbTrans527.Close()
+		_, err528 := mbTrans527.WriteString(arg526)
+		if err528 != nil {
 			Usage()
 			return
 		}
-		factory528 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt529 := factory528.GetProtocol(mbTrans526)
+		factory529 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt530 := factory529.GetProtocol(mbTrans527)
 		argvalue0 := aurora.NewTaskQuery()
-		err530 := argvalue0.Read(jsProt529)
-		if err530 != nil {
+		err531 := argvalue0.Read(jsProt530)
+		if err531 != nil {
 			Usage()
 			return
 		}
@@ -963,19 +963,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg531 := flag.Arg(1)
-		mbTrans532 := thrift.NewTMemoryBufferLen(len(arg531))
-		defer mbTrans532.Close()
-		_, err533 := mbTrans532.WriteString(arg531)
-		if err533 != nil {
+		arg532 := flag.Arg(1)
+		mbTrans533 := thrift.NewTMemoryBufferLen(len(arg532))
+		defer mbTrans533.Close()
+		_, err534 := mbTrans533.WriteString(arg532)
+		if err534 != nil {
 			Usage()
 			return
 		}
-		factory534 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt535 := factory534.GetProtocol(mbTrans532)
+		factory535 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt536 := factory535.GetProtocol(mbTrans533)
 		argvalue0 := aurora.NewJobKey()
-		err536 := argvalue0.Read(jsProt535)
-		if err536 != nil {
+		err537 := argvalue0.Read(jsProt536)
+		if err537 != nil {
 			Usage()
 			return
 		}
@@ -1008,19 +1008,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig 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.NewTSimpleJSONProtocolFactory()
-		jsProt543 := factory542.GetProtocol(mbTrans540)
+		factory543 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt544 := factory543.GetProtocol(mbTrans541)
 		argvalue0 := aurora.NewJobConfiguration()
-		err544 := argvalue0.Read(jsProt543)
-		if err544 != nil {
+		err545 := argvalue0.Read(jsProt544)
+		if err545 != nil {
 			Usage()
 			return
 		}
@@ -1033,19 +1033,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries 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.NewTSimpleJSONProtocolFactory()
-		jsProt549 := factory548.GetProtocol(mbTrans546)
+		factory549 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt550 := factory549.GetProtocol(mbTrans547)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err550 := argvalue0.Read(jsProt549)
-		if err550 != nil {
+		err551 := argvalue0.Read(jsProt550)
+		if err551 != nil {
 			Usage()
 			return
 		}
@@ -1058,19 +1058,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg551 := flag.Arg(1)
-		mbTrans552 := thrift.NewTMemoryBufferLen(len(arg551))
-		defer mbTrans552.Close()
-		_, err553 := mbTrans552.WriteString(arg551)
-		if err553 != nil {
+		arg552 := flag.Arg(1)
+		mbTrans553 := thrift.NewTMemoryBufferLen(len(arg552))
+		defer mbTrans553.Close()
+		_, err554 := mbTrans553.WriteString(arg552)
+		if err554 != nil {
 			Usage()
 			return
 		}
-		factory554 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt555 := factory554.GetProtocol(mbTrans552)
+		factory555 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt556 := factory555.GetProtocol(mbTrans553)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err556 := argvalue0.Read(jsProt555)
-		if err556 != nil {
+		err557 := argvalue0.Read(jsProt556)
+		if err557 != nil {
 			Usage()
 			return
 		}
@@ -1083,19 +1083,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg557 := flag.Arg(1)
-		mbTrans558 := thrift.NewTMemoryBufferLen(len(arg557))
-		defer mbTrans558.Close()
-		_, err559 := mbTrans558.WriteString(arg557)
-		if err559 != nil {
+		arg558 := flag.Arg(1)
+		mbTrans559 := thrift.NewTMemoryBufferLen(len(arg558))
+		defer mbTrans559.Close()
+		_, err560 := mbTrans559.WriteString(arg558)
+		if err560 != nil {
 			Usage()
 			return
 		}
-		factory560 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt561 := factory560.GetProtocol(mbTrans558)
+		factory561 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt562 := factory561.GetProtocol(mbTrans559)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err562 := argvalue0.Read(jsProt561)
-		if err562 != nil {
+		err563 := argvalue0.Read(jsProt562)
+		if err563 != nil {
 			Usage()
 			return
 		}
diff --git 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
index 463e867..05e12e0 100755
--- 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
@@ -146,19 +146,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
 			flag.Usage()
 		}
-		arg163 := flag.Arg(1)
-		mbTrans164 := thrift.NewTMemoryBufferLen(len(arg163))
-		defer mbTrans164.Close()
-		_, err165 := mbTrans164.WriteString(arg163)
-		if err165 != nil {
+		arg164 := flag.Arg(1)
+		mbTrans165 := thrift.NewTMemoryBufferLen(len(arg164))
+		defer mbTrans165.Close()
+		_, err166 := mbTrans165.WriteString(arg164)
+		if err166 != nil {
 			Usage()
 			return
 		}
-		factory166 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt167 := factory166.GetProtocol(mbTrans164)
+		factory167 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt168 := factory167.GetProtocol(mbTrans165)
 		argvalue0 := aurora.NewJobConfiguration()
-		err168 := argvalue0.Read(jsProt167)
-		if err168 != nil {
+		err169 := argvalue0.Read(jsProt168)
+		if err169 != nil {
 			Usage()
 			return
 		}
@@ -171,19 +171,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg169 := flag.Arg(1)
-		mbTrans170 := thrift.NewTMemoryBufferLen(len(arg169))
-		defer mbTrans170.Close()
-		_, err171 := mbTrans170.WriteString(arg169)
-		if err171 != nil {
+		arg170 := flag.Arg(1)
+		mbTrans171 := thrift.NewTMemoryBufferLen(len(arg170))
+		defer mbTrans171.Close()
+		_, err172 := mbTrans171.WriteString(arg170)
+		if err172 != nil {
 			Usage()
 			return
 		}
-		factory172 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt173 := factory172.GetProtocol(mbTrans170)
+		factory173 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt174 := factory173.GetProtocol(mbTrans171)
 		argvalue0 := aurora.NewJobConfiguration()
-		err174 := argvalue0.Read(jsProt173)
-		if err174 != nil {
+		err175 := argvalue0.Read(jsProt174)
+		if err175 != nil {
 			Usage()
 			return
 		}
@@ -196,19 +196,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg175 := flag.Arg(1)
-		mbTrans176 := thrift.NewTMemoryBufferLen(len(arg175))
-		defer mbTrans176.Close()
-		_, err177 := mbTrans176.WriteString(arg175)
-		if err177 != nil {
+		arg176 := flag.Arg(1)
+		mbTrans177 := thrift.NewTMemoryBufferLen(len(arg176))
+		defer mbTrans177.Close()
+		_, err178 := mbTrans177.WriteString(arg176)
+		if err178 != nil {
 			Usage()
 			return
 		}
-		factory178 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt179 := factory178.GetProtocol(mbTrans176)
+		factory179 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt180 := factory179.GetProtocol(mbTrans177)
 		argvalue0 := aurora.NewJobKey()
-		err180 := argvalue0.Read(jsProt179)
-		if err180 != nil {
+		err181 := argvalue0.Read(jsProt180)
+		if err181 != nil {
 			Usage()
 			return
 		}
@@ -221,19 +221,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg181 := flag.Arg(1)
-		mbTrans182 := thrift.NewTMemoryBufferLen(len(arg181))
-		defer mbTrans182.Close()
-		_, err183 := mbTrans182.WriteString(arg181)
-		if err183 != nil {
+		arg182 := flag.Arg(1)
+		mbTrans183 := thrift.NewTMemoryBufferLen(len(arg182))
+		defer mbTrans183.Close()
+		_, err184 := mbTrans183.WriteString(arg182)
+		if err184 != nil {
 			Usage()
 			return
 		}
-		factory184 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt185 := factory184.GetProtocol(mbTrans182)
+		factory185 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt186 := factory185.GetProtocol(mbTrans183)
 		argvalue0 := aurora.NewJobKey()
-		err186 := argvalue0.Read(jsProt185)
-		if err186 != nil {
+		err187 := argvalue0.Read(jsProt186)
+		if err187 != nil {
 			Usage()
 			return
 		}
@@ -246,36 +246,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
 			flag.Usage()
 		}
-		arg187 := flag.Arg(1)
-		mbTrans188 := thrift.NewTMemoryBufferLen(len(arg187))
-		defer mbTrans188.Close()
-		_, err189 := mbTrans188.WriteString(arg187)
-		if err189 != nil {
+		arg188 := flag.Arg(1)
+		mbTrans189 := thrift.NewTMemoryBufferLen(len(arg188))
+		defer mbTrans189.Close()
+		_, err190 := mbTrans189.WriteString(arg188)
+		if err190 != nil {
 			Usage()
 			return
 		}
-		factory190 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt191 := factory190.GetProtocol(mbTrans188)
+		factory191 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt192 := factory191.GetProtocol(mbTrans189)
 		argvalue0 := aurora.NewJobKey()
-		err192 := argvalue0.Read(jsProt191)
-		if err192 != nil {
+		err193 := argvalue0.Read(jsProt192)
+		if err193 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg193 := flag.Arg(2)
-		mbTrans194 := thrift.NewTMemoryBufferLen(len(arg193))
-		defer mbTrans194.Close()
-		_, err195 := mbTrans194.WriteString(arg193)
-		if err195 != nil {
+		arg194 := flag.Arg(2)
+		mbTrans195 := thrift.NewTMemoryBufferLen(len(arg194))
+		defer mbTrans195.Close()
+		_, err196 := mbTrans195.WriteString(arg194)
+		if err196 != nil {
 			Usage()
 			return
 		}
-		factory196 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt197 := factory196.GetProtocol(mbTrans194)
+		factory197 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt198 := factory197.GetProtocol(mbTrans195)
 		containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
-		err198 := containerStruct1.ReadField2(jsProt197)
-		if err198 != nil {
+		err199 := containerStruct1.ReadField2(jsProt198)
+		if err199 != nil {
 			Usage()
 			return
 		}
@@ -289,36 +289,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
 			flag.Usage()
 		}
-		arg199 := flag.Arg(1)
-		mbTrans200 := thrift.NewTMemoryBufferLen(len(arg199))
-		defer mbTrans200.Close()
-		_, err201 := mbTrans200.WriteString(arg199)
-		if err201 != nil {
+		arg200 := flag.Arg(1)
+		mbTrans201 := thrift.NewTMemoryBufferLen(len(arg200))
+		defer mbTrans201.Close()
+		_, err202 := mbTrans201.WriteString(arg200)
+		if err202 != nil {
 			Usage()
 			return
 		}
-		factory202 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt203 := factory202.GetProtocol(mbTrans200)
+		factory203 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt204 := factory203.GetProtocol(mbTrans201)
 		argvalue0 := aurora.NewJobKey()
-		err204 := argvalue0.Read(jsProt203)
-		if err204 != nil {
+		err205 := argvalue0.Read(jsProt204)
+		if err205 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg205 := flag.Arg(2)
-		mbTrans206 := thrift.NewTMemoryBufferLen(len(arg205))
-		defer mbTrans206.Close()
-		_, err207 := mbTrans206.WriteString(arg205)
-		if err207 != nil {
+		arg206 := flag.Arg(2)
+		mbTrans207 := thrift.NewTMemoryBufferLen(len(arg206))
+		defer mbTrans207.Close()
+		_, err208 := mbTrans207.WriteString(arg206)
+		if err208 != nil {
 			Usage()
 			return
 		}
-		factory208 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt209 := factory208.GetProtocol(mbTrans206)
+		factory209 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt210 := factory209.GetProtocol(mbTrans207)
 		containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
-		err210 := containerStruct1.ReadField2(jsProt209)
-		if err210 != nil {
+		err211 := containerStruct1.ReadField2(jsProt210)
+		if err211 != nil {
 			Usage()
 			return
 		}
@@ -334,25 +334,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg212 := flag.Arg(1)
-		mbTrans213 := thrift.NewTMemoryBufferLen(len(arg212))
-		defer mbTrans213.Close()
-		_, err214 := mbTrans213.WriteString(arg212)
-		if err214 != nil {
+		arg213 := flag.Arg(1)
+		mbTrans214 := thrift.NewTMemoryBufferLen(len(arg213))
+		defer mbTrans214.Close()
+		_, err215 := mbTrans214.WriteString(arg213)
+		if err215 != nil {
 			Usage()
 			return
 		}
-		factory215 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt216 := factory215.GetProtocol(mbTrans213)
+		factory216 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt217 := factory216.GetProtocol(mbTrans214)
 		argvalue0 := aurora.NewInstanceKey()
-		err217 := argvalue0.Read(jsProt216)
-		if err217 != nil {
+		err218 := argvalue0.Read(jsProt217)
+		if err218 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err218 := (strconv.Atoi(flag.Arg(2)))
-		if err218 != nil {
+		tmp1, err219 := (strconv.Atoi(flag.Arg(2)))
+		if err219 != nil {
 			Usage()
 			return
 		}
@@ -366,19 +366,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg219 := flag.Arg(1)
-		mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
-		defer mbTrans220.Close()
-		_, err221 := mbTrans220.WriteString(arg219)
-		if err221 != nil {
+		arg220 := flag.Arg(1)
+		mbTrans221 := thrift.NewTMemoryBufferLen(len(arg220))
+		defer mbTrans221.Close()
+		_, err222 := mbTrans221.WriteString(arg220)
+		if err222 != nil {
 			Usage()
 			return
 		}
-		factory222 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt223 := factory222.GetProtocol(mbTrans220)
+		factory223 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt224 := factory223.GetProtocol(mbTrans221)
 		argvalue0 := aurora.NewJobConfiguration()
-		err224 := argvalue0.Read(jsProt223)
-		if err224 != nil {
+		err225 := argvalue0.Read(jsProt224)
+		if err225 != nil {
 			Usage()
 			return
 		}
@@ -391,19 +391,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg225 := flag.Arg(1)
-		mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
-		defer mbTrans226.Close()
-		_, err227 := mbTrans226.WriteString(arg225)
-		if err227 != nil {
+		arg226 := flag.Arg(1)
+		mbTrans227 := thrift.NewTMemoryBufferLen(len(arg226))
+		defer mbTrans227.Close()
+		_, err228 := mbTrans227.WriteString(arg226)
+		if err228 != nil {
 			Usage()
 			return
 		}
-		factory228 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt229 := factory228.GetProtocol(mbTrans226)
+		factory229 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt230 := factory229.GetProtocol(mbTrans227)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err230 := argvalue0.Read(jsProt229)
-		if err230 != nil {
+		err231 := argvalue0.Read(jsProt230)
+		if err231 != nil {
 			Usage()
 			return
 		}
@@ -418,19 +418,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg232 := flag.Arg(1)
-		mbTrans233 := thrift.NewTMemoryBufferLen(len(arg232))
-		defer mbTrans233.Close()
-		_, err234 := mbTrans233.WriteString(arg232)
-		if err234 != nil {
+		arg233 := flag.Arg(1)
+		mbTrans234 := thrift.NewTMemoryBufferLen(len(arg233))
+		defer mbTrans234.Close()
+		_, err235 := mbTrans234.WriteString(arg233)
+		if err235 != nil {
 			Usage()
 			return
 		}
-		factory235 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt236 := factory235.GetProtocol(mbTrans233)
+		factory236 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt237 := factory236.GetProtocol(mbTrans234)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err237 := argvalue0.Read(jsProt236)
-		if err237 != nil {
+		err238 := argvalue0.Read(jsProt237)
+		if err238 != nil {
 			Usage()
 			return
 		}
@@ -445,19 +445,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg239 := flag.Arg(1)
-		mbTrans240 := thrift.NewTMemoryBufferLen(len(arg239))
-		defer mbTrans240.Close()
-		_, err241 := mbTrans240.WriteString(arg239)
-		if err241 != nil {
+		arg240 := flag.Arg(1)
+		mbTrans241 := thrift.NewTMemoryBufferLen(len(arg240))
+		defer mbTrans241.Close()
+		_, err242 := mbTrans241.WriteString(arg240)
+		if err242 != nil {
 			Usage()
 			return
 		}
-		factory242 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt243 := factory242.GetProtocol(mbTrans240)
+		factory243 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt244 := factory243.GetProtocol(mbTrans241)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err244 := argvalue0.Read(jsProt243)
-		if err244 != nil {
+		err245 := argvalue0.Read(jsProt244)
+		if err245 != nil {
 			Usage()
 			return
 		}
@@ -472,19 +472,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg246 := flag.Arg(1)
-		mbTrans247 := thrift.NewTMemoryBufferLen(len(arg246))
-		defer mbTrans247.Close()
-		_, err248 := mbTrans247.WriteString(arg246)
-		if err248 != nil {
+		arg247 := flag.Arg(1)
+		mbTrans248 := thrift.NewTMemoryBufferLen(len(arg247))
+		defer mbTrans248.Close()
+		_, err249 := mbTrans248.WriteString(arg247)
+		if err249 != nil {
 			Usage()
 			return
 		}
-		factory249 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt250 := factory249.GetProtocol(mbTrans247)
+		factory250 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt251 := factory250.GetProtocol(mbTrans248)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err251 := argvalue0.Read(jsProt250)
-		if err251 != nil {
+		err252 := argvalue0.Read(jsProt251)
+		if err252 != nil {
 			Usage()
 			return
 		}
@@ -499,19 +499,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg253 := flag.Arg(1)
-		mbTrans254 := thrift.NewTMemoryBufferLen(len(arg253))
-		defer mbTrans254.Close()
-		_, err255 := mbTrans254.WriteString(arg253)
-		if err255 != nil {
+		arg254 := flag.Arg(1)
+		mbTrans255 := thrift.NewTMemoryBufferLen(len(arg254))
+		defer mbTrans255.Close()
+		_, err256 := mbTrans255.WriteString(arg254)
+		if err256 != nil {
 			Usage()
 			return
 		}
-		factory256 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt257 := factory256.GetProtocol(mbTrans254)
+		factory257 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt258 := factory257.GetProtocol(mbTrans255)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err258 := argvalue0.Read(jsProt257)
-		if err258 != nil {
+		err259 := argvalue0.Read(jsProt258)
+		if err259 != nil {
 			Usage()
 			return
 		}
@@ -526,19 +526,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
 			flag.Usage()
 		}
-		arg260 := flag.Arg(1)
-		mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
-		defer mbTrans261.Close()
-		_, err262 := mbTrans261.WriteString(arg260)
-		if err262 != nil {
+		arg261 := flag.Arg(1)
+		mbTrans262 := thrift.NewTMemoryBufferLen(len(arg261))
+		defer mbTrans262.Close()
+		_, err263 := mbTrans262.WriteString(arg261)
+		if err263 != nil {
 			Usage()
 			return
 		}
-		factory263 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt264 := factory263.GetProtocol(mbTrans261)
+		factory264 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt265 := factory264.GetProtocol(mbTrans262)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err265 := argvalue0.Read(jsProt264)
-		if err265 != nil {
+		err266 := argvalue0.Read(jsProt265)
+		if err266 != nil {
 			Usage()
 			return
 		}
@@ -569,19 +569,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg267 := flag.Arg(1)
-		mbTrans268 := thrift.NewTMemoryBufferLen(len(arg267))
-		defer mbTrans268.Close()
-		_, err269 := mbTrans268.WriteString(arg267)
-		if err269 != nil {
+		arg268 := flag.Arg(1)
+		mbTrans269 := thrift.NewTMemoryBufferLen(len(arg268))
+		defer mbTrans269.Close()
+		_, err270 := mbTrans269.WriteString(arg268)
+		if err270 != nil {
 			Usage()
 			return
 		}
-		factory270 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt271 := factory270.GetProtocol(mbTrans268)
+		factory271 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt272 := factory271.GetProtocol(mbTrans269)
 		argvalue0 := aurora.NewTaskQuery()
-		err272 := argvalue0.Read(jsProt271)
-		if err272 != nil {
+		err273 := argvalue0.Read(jsProt272)
+		if err273 != nil {
 			Usage()
 			return
 		}
@@ -594,19 +594,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg273 := flag.Arg(1)
-		mbTrans274 := thrift.NewTMemoryBufferLen(len(arg273))
-		defer mbTrans274.Close()
-		_, err275 := mbTrans274.WriteString(arg273)
-		if err275 != nil {
+		arg274 := flag.Arg(1)
+		mbTrans275 := thrift.NewTMemoryBufferLen(len(arg274))
+		defer mbTrans275.Close()
+		_, err276 := mbTrans275.WriteString(arg274)
+		if err276 != nil {
 			Usage()
 			return
 		}
-		factory276 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt277 := factory276.GetProtocol(mbTrans274)
+		factory277 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt278 := factory277.GetProtocol(mbTrans275)
 		argvalue0 := aurora.NewTaskQuery()
-		err278 := argvalue0.Read(jsProt277)
-		if err278 != nil {
+		err279 := argvalue0.Read(jsProt278)
+		if err279 != nil {
 			Usage()
 			return
 		}
@@ -619,19 +619,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg279 := flag.Arg(1)
-		mbTrans280 := thrift.NewTMemoryBufferLen(len(arg279))
-		defer mbTrans280.Close()
-		_, err281 := mbTrans280.WriteString(arg279)
-		if err281 != nil {
+		arg280 := flag.Arg(1)
+		mbTrans281 := thrift.NewTMemoryBufferLen(len(arg280))
+		defer mbTrans281.Close()
+		_, err282 := mbTrans281.WriteString(arg280)
+		if err282 != nil {
 			Usage()
 			return
 		}
-		factory282 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt283 := factory282.GetProtocol(mbTrans280)
+		factory283 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt284 := factory283.GetProtocol(mbTrans281)
 		argvalue0 := aurora.NewTaskQuery()
-		err284 := argvalue0.Read(jsProt283)
-		if err284 != nil {
+		err285 := argvalue0.Read(jsProt284)
+		if err285 != nil {
 			Usage()
 			return
 		}
@@ -644,19 +644,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg285 := flag.Arg(1)
-		mbTrans286 := thrift.NewTMemoryBufferLen(len(arg285))
-		defer mbTrans286.Close()
-		_, err287 := mbTrans286.WriteString(arg285)
-		if err287 != nil {
+		arg286 := flag.Arg(1)
+		mbTrans287 := thrift.NewTMemoryBufferLen(len(arg286))
+		defer mbTrans287.Close()
+		_, err288 := mbTrans287.WriteString(arg286)
+		if err288 != nil {
 			Usage()
 			return
 		}
-		factory288 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt289 := factory288.GetProtocol(mbTrans286)
+		factory289 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt290 := factory289.GetProtocol(mbTrans287)
 		argvalue0 := aurora.NewJobKey()
-		err290 := argvalue0.Read(jsProt289)
-		if err290 != nil {
+		err291 := argvalue0.Read(jsProt290)
+		if err291 != nil {
 			Usage()
 			return
 		}
@@ -689,19 +689,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg293 := flag.Arg(1)
-		mbTrans294 := thrift.NewTMemoryBufferLen(len(arg293))
-		defer mbTrans294.Close()
-		_, err295 := mbTrans294.WriteString(arg293)
-		if err295 != nil {
+		arg294 := flag.Arg(1)
+		mbTrans295 := thrift.NewTMemoryBufferLen(len(arg294))
+		defer mbTrans295.Close()
+		_, err296 := mbTrans295.WriteString(arg294)
+		if err296 != nil {
 			Usage()
 			return
 		}
-		factory296 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt297 := factory296.GetProtocol(mbTrans294)
+		factory297 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt298 := factory297.GetProtocol(mbTrans295)
 		argvalue0 := aurora.NewJobConfiguration()
-		err298 := argvalue0.Read(jsProt297)
-		if err298 != nil {
+		err299 := argvalue0.Read(jsProt298)
+		if err299 != nil {
 			Usage()
 			return
 		}
@@ -714,19 +714,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg299 := flag.Arg(1)
-		mbTrans300 := thrift.NewTMemoryBufferLen(len(arg299))
-		defer mbTrans300.Close()
-		_, err301 := mbTrans300.WriteString(arg299)
-		if err301 != nil {
+		arg300 := flag.Arg(1)
+		mbTrans301 := thrift.NewTMemoryBufferLen(len(arg300))
+		defer mbTrans301.Close()
+		_, err302 := mbTrans301.WriteString(arg300)
+		if err302 != nil {
 			Usage()
 			return
 		}
-		factory302 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt303 := factory302.GetProtocol(mbTrans300)
+		factory303 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt304 := factory303.GetProtocol(mbTrans301)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err304 := argvalue0.Read(jsProt303)
-		if err304 != nil {
+		err305 := argvalue0.Read(jsProt304)
+		if err305 != nil {
 			Usage()
 			return
 		}
@@ -739,19 +739,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg305 := flag.Arg(1)
-		mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
-		defer mbTrans306.Close()
-		_, err307 := mbTrans306.WriteString(arg305)
-		if err307 != nil {
+		arg306 := flag.Arg(1)
+		mbTrans307 := thrift.NewTMemoryBufferLen(len(arg306))
+		defer mbTrans307.Close()
+		_, err308 := mbTrans307.WriteString(arg306)
+		if err308 != nil {
 			Usage()
 			return
 		}
-		factory308 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt309 := factory308.GetProtocol(mbTrans306)
+		factory309 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt310 := factory309.GetProtocol(mbTrans307)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err310 := argvalue0.Read(jsProt309)
-		if err310 != nil {
+		err311 := argvalue0.Read(jsProt310)
+		if err311 != nil {
 			Usage()
 			return
 		}
@@ -764,19 +764,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg311 := flag.Arg(1)
-		mbTrans312 := thrift.NewTMemoryBufferLen(len(arg311))
-		defer mbTrans312.Close()
-		_, err313 := mbTrans312.WriteString(arg311)
-		if err313 != nil {
+		arg312 := flag.Arg(1)
+		mbTrans313 := thrift.NewTMemoryBufferLen(len(arg312))
+		defer mbTrans313.Close()
+		_, err314 := mbTrans313.WriteString(arg312)
+		if err314 != nil {
 			Usage()
 			return
 		}
-		factory314 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt315 := factory314.GetProtocol(mbTrans312)
+		factory315 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt316 := factory315.GetProtocol(mbTrans313)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err316 := argvalue0.Read(jsProt315)
-		if err316 != nil {
+		err317 := argvalue0.Read(jsProt316)
+		if err317 != nil {
 			Usage()
 			return
 		}
diff --git a/gen-go/apache/aurora/auroraadmin.go b/gen-go/apache/aurora/auroraadmin.go
index 3956e5f..d508e9b 100644
--- a/gen-go/apache/aurora/auroraadmin.go
+++ b/gen-go/apache/aurora/auroraadmin.go
@@ -158,16 +158,16 @@ func (p *AuroraAdminClient) recvSetQuota() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error317 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error318 error
-		error318, err = error317.Read(iprot)
+		error318 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error319 error
+		error319, err = error318.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error318
+		err = error319
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -241,16 +241,16 @@ func (p *AuroraAdminClient) recvForceTaskState() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error319 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error320 error
-		error320, err = error319.Read(iprot)
+		error320 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error321 error
+		error321, err = error320.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error320
+		err = error321
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -315,16 +315,16 @@ func (p *AuroraAdminClient) recvPerformBackup() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error321 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error322 error
-		error322, err = error321.Read(iprot)
+		error322 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error323 error
+		error323, err = error322.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error322
+		err = error323
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -389,16 +389,16 @@ func (p *AuroraAdminClient) recvListBackups() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error323 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error324 error
-		error324, err = error323.Read(iprot)
+		error324 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error325 error
+		error325, err = error324.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error324
+		err = error325
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -468,16 +468,16 @@ func (p *AuroraAdminClient) recvStageRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error325 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error326 error
-		error326, err = error325.Read(iprot)
+		error326 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error327 error
+		error327, err = error326.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error326
+		err = error327
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -547,16 +547,16 @@ func (p *AuroraAdminClient) recvQueryRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error327 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error328 error
-		error328, err = error327.Read(iprot)
+		error328 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error329 error
+		error329, err = error328.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error328
+		err = error329
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -626,16 +626,16 @@ func (p *AuroraAdminClient) recvDeleteRecoveryTasks() (value *Response, err erro
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error329 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error330 error
-		error330, err = error329.Read(iprot)
+		error330 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error331 error
+		error331, err = error330.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error330
+		err = error331
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -700,16 +700,16 @@ func (p *AuroraAdminClient) recvCommitRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error331 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error332 error
-		error332, err = error331.Read(iprot)
+		error332 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error333 error
+		error333, err = error332.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error332
+		err = error333
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -774,16 +774,16 @@ func (p *AuroraAdminClient) recvUnloadRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error333 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error334 error
-		error334, err = error333.Read(iprot)
+		error334 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error335 error
+		error335, err = error334.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error334
+		err = error335
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -853,16 +853,16 @@ func (p *AuroraAdminClient) recvStartMaintenance() (value *Response, err error)
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error335 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error336 error
-		error336, err = error335.Read(iprot)
+		error336 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error337 error
+		error337, err = error336.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error336
+		err = error337
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -932,16 +932,16 @@ func (p *AuroraAdminClient) recvDrainHosts() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error337 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error338 error
-		error338, err = error337.Read(iprot)
+		error338 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error339 error
+		error339, err = error338.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error338
+		err = error339
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1011,16 +1011,16 @@ func (p *AuroraAdminClient) recvMaintenanceStatus() (value *Response, err error)
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error339 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error340 error
-		error340, err = error339.Read(iprot)
+		error340 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error341 error
+		error341, err = error340.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error340
+		err = error341
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1090,16 +1090,16 @@ func (p *AuroraAdminClient) recvEndMaintenance() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error341 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error342 error
-		error342, err = error341.Read(iprot)
+		error342 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error343 error
+		error343, err = error342.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error342
+		err = error343
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1164,16 +1164,16 @@ func (p *AuroraAdminClient) recvSnapshot() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error343 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error344 error
-		error344, err = error343.Read(iprot)
+		error344 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error345 error
+		error345, err = error344.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error344
+		err = error345
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1243,16 +1243,16 @@ func (p *AuroraAdminClient) recvTriggerExplicitTaskReconciliation() (value *Resp
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error345 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error346 error
-		error346, err = error345.Read(iprot)
+		error346 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error347 error
+		error347, err = error346.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error346
+		err = error347
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1317,16 +1317,16 @@ func (p *AuroraAdminClient) recvTriggerImplicitTaskReconciliation() (value *Resp
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error347 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error348 error
-		error348, err = error347.Read(iprot)
+		error348 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error349 error
+		error349, err = error348.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error348
+		err = error349
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1398,16 +1398,16 @@ func (p *AuroraAdminClient) recvPruneTasks() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error349 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error350 error
-		error350, err = error349.Read(iprot)
+		error350 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error351 error
+		error351, err = error350.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error350
+		err = error351
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1430,25 +1430,25 @@ type AuroraAdminProcessor struct {
 }
 
 func NewAuroraAdminProcessor(handler AuroraAdmin) *AuroraAdminProcessor {
-	self351 := &AuroraAdminProcessor{NewAuroraSchedulerManagerProcessor(handler)}
-	self351.AddToProcessorMap("setQuota", &auroraAdminProcessorSetQuota{handler: handler})
-	self351.AddToProcessorMap("forceTaskState", &auroraAdminProcessorForceTaskState{handler: handler})
-	self351.AddToProcessorMap("performBackup", &auroraAdminProcessorPerformBackup{handler: handler})
-	self351.AddToProcessorMap("listBackups", &auroraAdminProcessorListBackups{handler: handler})
-	self351.AddToProcessorMap("stageRecovery", &auroraAdminProcessorStageRecovery{handler: handler})
-	self351.AddToProcessorMap("queryRecovery", &auroraAdminProcessorQueryRecovery{handler: handler})
-	self351.AddToProcessorMap("deleteRecoveryTasks", &auroraAdminProcessorDeleteRecoveryTasks{handler: handler})
-	self351.AddToProcessorMap("commitRecovery", &auroraAdminProcessorCommitRecovery{handler: handler})
-	self351.AddToProcessorMap("unloadRecovery", &auroraAdminProcessorUnloadRecovery{handler: handler})
-	self351.AddToProcessorMap("startMaintenance", &auroraAdminProcessorStartMaintenance{handler: handler})
-	self351.AddToProcessorMap("drainHosts", &auroraAdminProcessorDrainHosts{handler: handler})
-	self351.AddToProcessorMap("maintenanceStatus", &auroraAdminProcessorMaintenanceStatus{handler: handler})
-	self351.AddToProcessorMap("endMaintenance", &auroraAdminProcessorEndMaintenance{handler: handler})
-	self351.AddToProcessorMap("snapshot", &auroraAdminProcessorSnapshot{handler: handler})
-	self351.AddToProcessorMap("triggerExplicitTaskReconciliation", &auroraAdminProcessorTriggerExplicitTaskReconciliation{handler: handler})
-	self351.AddToProcessorMap("triggerImplicitTaskReconciliation", &auroraAdminProcessorTriggerImplicitTaskReconciliation{handler: handler})
-	self351.AddToProcessorMap("pruneTasks", &auroraAdminProcessorPruneTasks{handler: handler})
-	return self351
+	self352 := &AuroraAdminProcessor{NewAuroraSchedulerManagerProcessor(handler)}
+	self352.AddToProcessorMap("setQuota", &auroraAdminProcessorSetQuota{handler: handler})
+	self352.AddToProcessorMap("forceTaskState", &auroraAdminProcessorForceTaskState{handler: handler})
+	self352.AddToProcessorMap("performBackup", &auroraAdminProcessorPerformBackup{handler: handler})
+	self352.AddToProcessorMap("listBackups", &auroraAdminProcessorListBackups{handler: handler})
+	self352.AddToProcessorMap("stageRecovery", &auroraAdminProcessorStageRecovery{handler: handler})
+	self352.AddToProcessorMap("queryRecovery", &auroraAdminProcessorQueryRecovery{handler: handler})
+	self352.AddToProcessorMap("deleteRecoveryTasks", &auroraAdminProcessorDeleteRecoveryTasks{handler: handler})
+	self352.AddToProcessorMap("commitRecovery", &auroraAdminProcessorCommitRecovery{handler: handler})
+	self352.AddToProcessorMap("unloadRecovery", &auroraAdminProcessorUnloadRecovery{handler: handler})
+	self352.AddToProcessorMap("startMaintenance", &auroraAdminProcessorStartMaintenance{handler: handler})
+	self352.AddToProcessorMap("drainHosts", &auroraAdminProcessorDrainHosts{handler: handler})
+	self352.AddToProcessorMap("maintenanceStatus", &auroraAdminProcessorMaintenanceStatus{handler: handler})
+	self352.AddToProcessorMap("endMaintenance", &auroraAdminProcessorEndMaintenance{handler: handler})
+	self352.AddToProcessorMap("snapshot", &auroraAdminProcessorSnapshot{handler: handler})
+	self352.AddToProcessorMap("triggerExplicitTaskReconciliation", &auroraAdminProcessorTriggerExplicitTaskReconciliation{handler: handler})
+	self352.AddToProcessorMap("triggerImplicitTaskReconciliation", &auroraAdminProcessorTriggerImplicitTaskReconciliation{handler: handler})
+	self352.AddToProcessorMap("pruneTasks", &auroraAdminProcessorPruneTasks{handler: handler})
+	return self352
 }
 
 type auroraAdminProcessorSetQuota struct {
diff --git a/gen-go/apache/aurora/auroraschedulermanager.go b/gen-go/apache/aurora/auroraschedulermanager.go
index 33757e8..cbdfcab 100644
--- a/gen-go/apache/aurora/auroraschedulermanager.go
+++ b/gen-go/apache/aurora/auroraschedulermanager.go
@@ -171,16 +171,16 @@ func (p *AuroraSchedulerManagerClient) recvCreateJob() (value *Response, err err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error132 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error133 error
-		error133, err = error132.Read(iprot)
+		error133 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error134 error
+		error134, err = error133.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error133
+		err = error134
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -252,16 +252,16 @@ func (p *AuroraSchedulerManagerClient) recvScheduleCronJob() (value *Response, e
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error134 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error135 error
-		error135, err = error134.Read(iprot)
+		error135 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error136 error
+		error136, err = error135.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error135
+		err = error136
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -332,16 +332,16 @@ func (p *AuroraSchedulerManagerClient) recvDescheduleCronJob() (value *Response,
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error136 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error137 error
-		error137, err = error136.Read(iprot)
+		error137 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error138 error
+		error138, err = error137.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error137
+		err = error138
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -412,16 +412,16 @@ func (p *AuroraSchedulerManagerClient) recvStartCronJob() (value *Response, err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error138 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error139 error
-		error139, err = error138.Read(iprot)
+		error139 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error140 error
+		error140, err = error139.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error139
+		err = error140
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -493,16 +493,16 @@ func (p *AuroraSchedulerManagerClient) recvRestartShards() (value *Response, err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error140 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error141 error
-		error141, err = error140.Read(iprot)
+		error141 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error142 error
+		error142, err = error141.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error141
+		err = error142
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -576,16 +576,16 @@ func (p *AuroraSchedulerManagerClient) recvKillTasks() (value *Response, err err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error142 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error143 error
-		error143, err = error142.Read(iprot)
+		error143 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error144 error
+		error144, err = error143.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error143
+		err = error144
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -657,16 +657,16 @@ func (p *AuroraSchedulerManagerClient) recvAddInstances() (value *Response, err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error144 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error145 error
-		error145, err = error144.Read(iprot)
+		error145 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error146 error
+		error146, err = error145.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error145
+		err = error146
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -737,16 +737,16 @@ func (p *AuroraSchedulerManagerClient) recvReplaceCronTemplate() (value *Respons
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error146 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error147 error
-		error147, err = error146.Read(iprot)
+		error147 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error148 error
+		error148, err = error147.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error147
+		err = error148
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -818,16 +818,16 @@ func (p *AuroraSchedulerManagerClient) recvStartJobUpdate() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error148 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error149 error
-		error149, err = error148.Read(iprot)
+		error149 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error150 error
+		error150, err = error149.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error149
+		err = error150
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -899,16 +899,16 @@ func (p *AuroraSchedulerManagerClient) recvPauseJobUpdate() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error150 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error151 error
-		error151, err = error150.Read(iprot)
+		error151 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error152 error
+		error152, err = error151.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error151
+		err = error152
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -980,16 +980,16 @@ func (p *AuroraSchedulerManagerClient) recvResumeJobUpdate() (value *Response, e
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error152 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error153 error
-		error153, err = error152.Read(iprot)
+		error153 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error154 error
+		error154, err = error153.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error153
+		err = error154
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1061,16 +1061,16 @@ func (p *AuroraSchedulerManagerClient) recvAbortJobUpdate() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error154 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error155 error
-		error155, err = error154.Read(iprot)
+		error155 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error156 error
+		error156, err = error155.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error155
+		err = error156
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1142,16 +1142,16 @@ func (p *AuroraSchedulerManagerClient) recvRollbackJobUpdate() (value *Response,
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error156 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error157 error
-		error157, err = error156.Read(iprot)
+		error157 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error158 error
+		error158, err = error157.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error157
+		err = error158
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1223,16 +1223,16 @@ func (p *AuroraSchedulerManagerClient) recvPulseJobUpdate() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error158 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error159 error
-		error159, err = error158.Read(iprot)
+		error159 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error160 error
+		error160, err = error159.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error159
+		err = error160
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1255,22 +1255,22 @@ type AuroraSchedulerManagerProcessor struct {
 }
 
 func NewAuroraSchedulerManagerProcessor(handler AuroraSchedulerManager) *AuroraSchedulerManagerProcessor {
-	self160 := &AuroraSchedulerManagerProcessor{NewReadOnlySchedulerProcessor(handler)}
-	self160.AddToProcessorMap("createJob", &auroraSchedulerManagerProcessorCreateJob{handler: handler})
-	self160.AddToProcessorMap("scheduleCronJob", &auroraSchedulerManagerProcessorScheduleCronJob{handler: handler})
-	self160.AddToProcessorMap("descheduleCronJob", &auroraSchedulerManagerProcessorDescheduleCronJob{handler: handler})
-	self160.AddToProcessorMap("startCronJob", &auroraSchedulerManagerProcessorStartCronJob{handler: handler})
-	self160.AddToProcessorMap("restartShards", &auroraSchedulerManagerProcessorRestartShards{handler: handler})
-	self160.AddToProcessorMap("killTasks", &auroraSchedulerManagerProcessorKillTasks{handler: handler})
-	self160.AddToProcessorMap("addInstances", &auroraSchedulerManagerProcessorAddInstances{handler: handler})
-	self160.AddToProcessorMap("replaceCronTemplate", &auroraSchedulerManagerProcessorReplaceCronTemplate{handler: handler})
-	self160.AddToProcessorMap("startJobUpdate", &auroraSchedulerManagerProcessorStartJobUpdate{handler: handler})
-	self160.AddToProcessorMap("pauseJobUpdate", &auroraSchedulerManagerProcessorPauseJobUpdate{handler: handler})
-	self160.AddToProcessorMap("resumeJobUpdate", &auroraSchedulerManagerProcessorResumeJobUpdate{handler: handler})
-	self160.AddToProcessorMap("abortJobUpdate", &auroraSchedulerManagerProcessorAbortJobUpdate{handler: handler})
-	self160.AddToProcessorMap("rollbackJobUpdate", &auroraSchedulerManagerProcessorRollbackJobUpdate{handler: handler})
-	self160.AddToProcessorMap("pulseJobUpdate", &auroraSchedulerManagerProcessorPulseJobUpdate{handler: handler})
-	return self160
+	self161 := &AuroraSchedulerManagerProcessor{NewReadOnlySchedulerProcessor(handler)}
+	self161.AddToProcessorMap("createJob", &auroraSchedulerManagerProcessorCreateJob{handler: handler})
+	self161.AddToProcessorMap("scheduleCronJob", &auroraSchedulerManagerProcessorScheduleCronJob{handler: handler})
+	self161.AddToProcessorMap("descheduleCronJob", &auroraSchedulerManagerProcessorDescheduleCronJob{handler: handler})
+	self161.AddToProcessorMap("startCronJob", &auroraSchedulerManagerProcessorStartCronJob{handler: handler})
+	self161.AddToProcessorMap("restartShards", &auroraSchedulerManagerProcessorRestartShards{handler: handler})
+	self161.AddToProcessorMap("killTasks", &auroraSchedulerManagerProcessorKillTasks{handler: handler})
+	self161.AddToProcessorMap("addInstances", &auroraSchedulerManagerProcessorAddInstances{handler: handler})
+	self161.AddToProcessorMap("replaceCronTemplate", &auroraSchedulerManagerProcessorReplaceCronTemplate{handler: handler})
+	self161.AddToProcessorMap("startJobUpdate", &auroraSchedulerManagerProcessorStartJobUpdate{handler: handler})
+	self161.AddToProcessorMap("pauseJobUpdate", &auroraSchedulerManagerProcessorPauseJobUpdate{handler: handler})
+	self161.AddToProcessorMap("resumeJobUpdate", &auroraSchedulerManagerProcessorResumeJobUpdate{handler: handler})
+	self161.AddToProcessorMap("abortJobUpdate", &auroraSchedulerManagerProcessorAbortJobUpdate{handler: handler})
+	self161.AddToProcessorMap("rollbackJobUpdate", &auroraSchedulerManagerProcessorRollbackJobUpdate{handler: handler})
+	self161.AddToProcessorMap("pulseJobUpdate", &auroraSchedulerManagerProcessorPulseJobUpdate{handler: handler})
+	return self161
 }
 
 type auroraSchedulerManagerProcessorCreateJob struct {
@@ -2832,13 +2832,13 @@ func (p *AuroraSchedulerManagerRestartShardsArgs) readField3(iprot thrift.TProto
 	tSet := make(map[int32]bool, size)
 	p.ShardIds = tSet
 	for i := 0; i < size; i++ {
-		var _elem161 int32
+		var _elem162 int32
 		if v, err := iprot.ReadI32(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem161 = v
+			_elem162 = v
 		}
-		p.ShardIds[_elem161] = true
+		p.ShardIds[_elem162] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -3099,13 +3099,13 @@ func (p *AuroraSchedulerManagerKillTasksArgs) readField5(iprot thrift.TProtocol)
 	tSet := make(map[int32]bool, size)
 	p.Instances = tSet
 	for i := 0; i < size; i++ {
-		var _elem162 int32
+		var _elem163 int32
 		if v, err := iprot.ReadI32(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem162 = v
+			_elem163 = v
 		}
-		p.Instances[_elem162] = true
+		p.Instances[_elem163] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
diff --git 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
index b9c3d90..b10e262 100755
--- 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
@@ -150,19 +150,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg82 := flag.Arg(1)
-		mbTrans83 := thrift.NewTMemoryBufferLen(len(arg82))
-		defer mbTrans83.Close()
-		_, err84 := mbTrans83.WriteString(arg82)
-		if err84 != nil {
+		arg83 := flag.Arg(1)
+		mbTrans84 := thrift.NewTMemoryBufferLen(len(arg83))
+		defer mbTrans84.Close()
+		_, err85 := mbTrans84.WriteString(arg83)
+		if err85 != nil {
 			Usage()
 			return
 		}
-		factory85 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt86 := factory85.GetProtocol(mbTrans83)
+		factory86 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt87 := factory86.GetProtocol(mbTrans84)
 		argvalue0 := aurora.NewTaskQuery()
-		err87 := argvalue0.Read(jsProt86)
-		if err87 != nil {
+		err88 := argvalue0.Read(jsProt87)
+		if err88 != nil {
 			Usage()
 			return
 		}
@@ -175,19 +175,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg88 := flag.Arg(1)
-		mbTrans89 := thrift.NewTMemoryBufferLen(len(arg88))
-		defer mbTrans89.Close()
-		_, err90 := mbTrans89.WriteString(arg88)
-		if err90 != nil {
+		arg89 := flag.Arg(1)
+		mbTrans90 := thrift.NewTMemoryBufferLen(len(arg89))
+		defer mbTrans90.Close()
+		_, err91 := mbTrans90.WriteString(arg89)
+		if err91 != nil {
 			Usage()
 			return
 		}
-		factory91 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt92 := factory91.GetProtocol(mbTrans89)
+		factory92 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt93 := factory92.GetProtocol(mbTrans90)
 		argvalue0 := aurora.NewTaskQuery()
-		err93 := argvalue0.Read(jsProt92)
-		if err93 != nil {
+		err94 := argvalue0.Read(jsProt93)
+		if err94 != nil {
 			Usage()
 			return
 		}
@@ -200,19 +200,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg94 := flag.Arg(1)
-		mbTrans95 := thrift.NewTMemoryBufferLen(len(arg94))
-		defer mbTrans95.Close()
-		_, err96 := mbTrans95.WriteString(arg94)
-		if err96 != nil {
+		arg95 := flag.Arg(1)
+		mbTrans96 := thrift.NewTMemoryBufferLen(len(arg95))
+		defer mbTrans96.Close()
+		_, err97 := mbTrans96.WriteString(arg95)
+		if err97 != nil {
 			Usage()
 			return
 		}
-		factory97 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt98 := factory97.GetProtocol(mbTrans95)
+		factory98 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt99 := factory98.GetProtocol(mbTrans96)
 		argvalue0 := aurora.NewTaskQuery()
-		err99 := argvalue0.Read(jsProt98)
-		if err99 != nil {
+		err100 := argvalue0.Read(jsProt99)
+		if err100 != nil {
 			Usage()
 			return
 		}
@@ -225,19 +225,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg100 := flag.Arg(1)
-		mbTrans101 := thrift.NewTMemoryBufferLen(len(arg100))
-		defer mbTrans101.Close()
-		_, err102 := mbTrans101.WriteString(arg100)
-		if err102 != nil {
+		arg101 := flag.Arg(1)
+		mbTrans102 := thrift.NewTMemoryBufferLen(len(arg101))
+		defer mbTrans102.Close()
+		_, err103 := mbTrans102.WriteString(arg101)
+		if err103 != nil {
 			Usage()
 			return
 		}
-		factory103 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt104 := factory103.GetProtocol(mbTrans101)
+		factory104 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt105 := factory104.GetProtocol(mbTrans102)
 		argvalue0 := aurora.NewJobKey()
-		err105 := argvalue0.Read(jsProt104)
-		if err105 != nil {
+		err106 := argvalue0.Read(jsProt105)
+		if err106 != nil {
 			Usage()
 			return
 		}
@@ -270,19 +270,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg108 := flag.Arg(1)
-		mbTrans109 := thrift.NewTMemoryBufferLen(len(arg108))
-		defer mbTrans109.Close()
-		_, err110 := mbTrans109.WriteString(arg108)
-		if err110 != nil {
+		arg109 := flag.Arg(1)
+		mbTrans110 := thrift.NewTMemoryBufferLen(len(arg109))
+		defer mbTrans110.Close()
+		_, err111 := mbTrans110.WriteString(arg109)
+		if err111 != nil {
 			Usage()
 			return
 		}
-		factory111 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt112 := factory111.GetProtocol(mbTrans109)
+		factory112 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt113 := factory112.GetProtocol(mbTrans110)
 		argvalue0 := aurora.NewJobConfiguration()
-		err113 := argvalue0.Read(jsProt112)
-		if err113 != nil {
+		err114 := argvalue0.Read(jsProt113)
+		if err114 != nil {
 			Usage()
 			return
 		}
@@ -295,19 +295,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg114 := flag.Arg(1)
-		mbTrans115 := thrift.NewTMemoryBufferLen(len(arg114))
-		defer mbTrans115.Close()
-		_, err116 := mbTrans115.WriteString(arg114)
-		if err116 != nil {
+		arg115 := flag.Arg(1)
+		mbTrans116 := thrift.NewTMemoryBufferLen(len(arg115))
+		defer mbTrans116.Close()
+		_, err117 := mbTrans116.WriteString(arg115)
+		if err117 != nil {
 			Usage()
 			return
 		}
-		factory117 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt118 := factory117.GetProtocol(mbTrans115)
+		factory118 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt119 := factory118.GetProtocol(mbTrans116)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err119 := argvalue0.Read(jsProt118)
-		if err119 != nil {
+		err120 := argvalue0.Read(jsProt119)
+		if err120 != nil {
 			Usage()
 			return
 		}
@@ -320,19 +320,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg120 := flag.Arg(1)
-		mbTrans121 := thrift.NewTMemoryBufferLen(len(arg120))
-		defer mbTrans121.Close()
-		_, err122 := mbTrans121.WriteString(arg120)
-		if err122 != nil {
+		arg121 := flag.Arg(1)
+		mbTrans122 := thrift.NewTMemoryBufferLen(len(arg121))
+		defer mbTrans122.Close()
+		_, err123 := mbTrans122.WriteString(arg121)
+		if err123 != nil {
 			Usage()
 			return
 		}
-		factory123 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt124 := factory123.GetProtocol(mbTrans121)
+		factory124 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt125 := factory124.GetProtocol(mbTrans122)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err125 := argvalue0.Read(jsProt124)
-		if err125 != nil {
+		err126 := argvalue0.Read(jsProt125)
+		if err126 != nil {
 			Usage()
 			return
 		}
@@ -345,19 +345,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg126 := flag.Arg(1)
-		mbTrans127 := thrift.NewTMemoryBufferLen(len(arg126))
-		defer mbTrans127.Close()
-		_, err128 := mbTrans127.WriteString(arg126)
-		if err128 != nil {
+		arg127 := flag.Arg(1)
+		mbTrans128 := thrift.NewTMemoryBufferLen(len(arg127))
+		defer mbTrans128.Close()
+		_, err129 := mbTrans128.WriteString(arg127)
+		if err129 != nil {
 			Usage()
 			return
 		}
-		factory129 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt130 := factory129.GetProtocol(mbTrans127)
+		factory130 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt131 := factory130.GetProtocol(mbTrans128)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err131 := argvalue0.Read(jsProt130)
-		if err131 != nil {
+		err132 := argvalue0.Read(jsProt131)
+		if err132 != nil {
 			Usage()
 			return
 		}
diff --git a/gen-go/apache/aurora/readonlyscheduler.go b/gen-go/apache/aurora/readonlyscheduler.go
index e87a66d..f459207 100644
--- a/gen-go/apache/aurora/readonlyscheduler.go
+++ b/gen-go/apache/aurora/readonlyscheduler.go
@@ -152,16 +152,16 @@ func (p *ReadOnlySchedulerClient) recvGetRoleSummary() (value *Response, err err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error53 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error54 error
-		error54, err = error53.Read(iprot)
+		error54 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error55 error
+		error55, err = error54.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error54
+		err = error55
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -231,16 +231,16 @@ func (p *ReadOnlySchedulerClient) recvGetJobSummary() (value *Response, err erro
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error55 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error56 error
-		error56, err = error55.Read(iprot)
+		error56 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error57 error
+		error57, err = error56.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error56
+		err = error57
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -310,16 +310,16 @@ func (p *ReadOnlySchedulerClient) recvGetTasksStatus() (value *Response, err err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error57 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error58 error
-		error58, err = error57.Read(iprot)
+		error58 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error59 error
+		error59, err = error58.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error58
+		err = error59
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -390,16 +390,16 @@ func (p *ReadOnlySchedulerClient) recvGetTasksWithoutConfigs() (value *Response,
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error59 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error60 error
-		error60, err = error59.Read(iprot)
+		error60 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error61 error
+		error61, err = error60.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error60
+		err = error61
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -469,16 +469,16 @@ func (p *ReadOnlySchedulerClient) recvGetPendingReason() (value *Response, err e
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error61 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error62 error
-		error62, err = error61.Read(iprot)
+		error62 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error63 error
+		error63, err = error62.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error62
+		err = error63
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -548,16 +548,16 @@ func (p *ReadOnlySchedulerClient) recvGetConfigSummary() (value *Response, err e
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error63 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error64 error
-		error64, err = error63.Read(iprot)
+		error64 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error65 error
+		error65, err = error64.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error64
+		err = error65
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -628,16 +628,16 @@ func (p *ReadOnlySchedulerClient) recvGetJobs() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error65 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error66 error
-		error66, err = error65.Read(iprot)
+		error66 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error67 error
+		error67, err = error66.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error66
+		err = error67
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -707,16 +707,16 @@ func (p *ReadOnlySchedulerClient) recvGetQuota() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error67 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error68 error
-		error68, err = error67.Read(iprot)
+		error68 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error69 error
+		error69, err = error68.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error68
+		err = error69
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -787,16 +787,16 @@ func (p *ReadOnlySchedulerClient) recvPopulateJobConfig() (value *Response, err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error69 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error70 error
-		error70, err = error69.Read(iprot)
+		error70 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error71 error
+		error71, err = error70.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error70
+		err = error71
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -866,16 +866,16 @@ func (p *ReadOnlySchedulerClient) recvGetJobUpdateSummaries() (value *Response,
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error71 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error72 error
-		error72, err = error71.Read(iprot)
+		error72 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error73 error
+		error73, err = error72.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error72
+		err = error73
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -945,16 +945,16 @@ func (p *ReadOnlySchedulerClient) recvGetJobUpdateDetails() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error73 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error74 error
-		error74, err = error73.Read(iprot)
+		error74 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error75 error
+		error75, err = error74.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error74
+		err = error75
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1024,16 +1024,16 @@ func (p *ReadOnlySchedulerClient) recvGetJobUpdateDiff() (value *Response, err e
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error75 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error76 error
-		error76, err = error75.Read(iprot)
+		error76 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error77 error
+		error77, err = error76.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error76
+		err = error77
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1098,16 +1098,16 @@ func (p *ReadOnlySchedulerClient) recvGetTierConfigs() (value *Response, err err
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error77 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error78 error
-		error78, err = error77.Read(iprot)
+		error78 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error79 error
+		error79, err = error78.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error78
+		err = error79
 		return
 	}
 	if mTypeId != thrift.REPLY {
@@ -1145,21 +1145,21 @@ func (p *ReadOnlySchedulerProcessor) ProcessorMap() map[string]thrift.TProcessor
 
 func NewReadOnlySchedulerProcessor(handler ReadOnlyScheduler) *ReadOnlySchedulerProcessor {
 
-	self79 := &ReadOnlySchedulerProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
-	self79.processorMap["getRoleSummary"] = &readOnlySchedulerProcessorGetRoleSummary{handler: handler}
-	self79.processorMap["getJobSummary"] = &readOnlySchedulerProcessorGetJobSummary{handler: handler}
-	self79.processorMap["getTasksStatus"] = &readOnlySchedulerProcessorGetTasksStatus{handler: handler}
-	self79.processorMap["getTasksWithoutConfigs"] = &readOnlySchedulerProcessorGetTasksWithoutConfigs{handler: handler}
-	self79.processorMap["getPendingReason"] = &readOnlySchedulerProcessorGetPendingReason{handler: handler}
-	self79.processorMap["getConfigSummary"] = &readOnlySchedulerProcessorGetConfigSummary{handler: handler}
-	self79.processorMap["getJobs"] = &readOnlySchedulerProcessorGetJobs{handler: handler}
-	self79.processorMap["getQuota"] = &readOnlySchedulerProcessorGetQuota{handler: handler}
-	self79.processorMap["populateJobConfig"] = &readOnlySchedulerProcessorPopulateJobConfig{handler: handler}
-	self79.processorMap["getJobUpdateSummaries"] = &readOnlySchedulerProcessorGetJobUpdateSummaries{handler: handler}
-	self79.processorMap["getJobUpdateDetails"] = &readOnlySchedulerProcessorGetJobUpdateDetails{handler: handler}
-	self79.processorMap["getJobUpdateDiff"] = &readOnlySchedulerProcessorGetJobUpdateDiff{handler: handler}
-	self79.processorMap["getTierConfigs"] = &readOnlySchedulerProcessorGetTierConfigs{handler: handler}
-	return self79
+	self80 := &ReadOnlySchedulerProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
+	self80.processorMap["getRoleSummary"] = &readOnlySchedulerProcessorGetRoleSummary{handler: handler}
+	self80.processorMap["getJobSummary"] = &readOnlySchedulerProcessorGetJobSummary{handler: handler}
+	self80.processorMap["getTasksStatus"] = &readOnlySchedulerProcessorGetTasksStatus{handler: handler}
+	self80.processorMap["getTasksWithoutConfigs"] = &readOnlySchedulerProcessorGetTasksWithoutConfigs{handler: handler}
+	self80.processorMap["getPendingReason"] = &readOnlySchedulerProcessorGetPendingReason{handler: handler}
+	self80.processorMap["getConfigSummary"] = &readOnlySchedulerProcessorGetConfigSummary{handler: handler}
+	self80.processorMap["getJobs"] = &readOnlySchedulerProcessorGetJobs{handler: handler}
+	self80.processorMap["getQuota"] = &readOnlySchedulerProcessorGetQuota{handler: handler}
+	self80.processorMap["populateJobConfig"] = &readOnlySchedulerProcessorPopulateJobConfig{handler: handler}
+	self80.processorMap["getJobUpdateSummaries"] = &readOnlySchedulerProcessorGetJobUpdateSummaries{handler: handler}
+	self80.processorMap["getJobUpdateDetails"] = &readOnlySchedulerProcessorGetJobUpdateDetails{handler: handler}
+	self80.processorMap["getJobUpdateDiff"] = &readOnlySchedulerProcessorGetJobUpdateDiff{handler: handler}
+	self80.processorMap["getTierConfigs"] = &readOnlySchedulerProcessorGetTierConfigs{handler: handler}
+	return self80
 }
 
 func (p *ReadOnlySchedulerProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
@@ -1172,12 +1172,12 @@ func (p *ReadOnlySchedulerProcessor) Process(iprot, oprot thrift.TProtocol) (suc
 	}
 	iprot.Skip(thrift.STRUCT)
 	iprot.ReadMessageEnd()
-	x80 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
+	x81 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
 	oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
-	x80.Write(oprot)
+	x81.Write(oprot)
 	oprot.WriteMessageEnd()
 	oprot.Flush()
-	return false, x80
+	return false, x81
 
 }
 
diff --git a/gen-go/apache/aurora/ttypes.go b/gen-go/apache/aurora/ttypes.go
index 4d8fa54..deaaa37 100644
--- a/gen-go/apache/aurora/ttypes.go
+++ b/gen-go/apache/aurora/ttypes.go
@@ -9198,6 +9198,12 @@ func (p *JobUpdateKey) String() string {
 // update to make progress. If no pulses received within specified interval the update will
 // block. A blocked update is unable to continue but retains its current status. It may only get
 // unblocked by a fresh pulseJobUpdate call.
+//  - VariableUpdateGroupSize:  * This list contains the number of instances that each batch will complete before moving on to
+//  * the next. This field can only be used with waitForBatchCompletion set as true.
+// *
+//  - AutoPause: Pauses the deployment of further tasks after each batch completes
+// until the user sends an resume call.
+//
 type JobUpdateSettings struct {
 	UpdateGroupSize        int32 `thrift:"updateGroupSize,1" json:"updateGroupSize"`
 	MaxPerInstanceFailures int32 `thrift:"maxPerInstanceFailures,2" json:"maxPerInstanceFailures"`
@@ -9208,6 +9214,8 @@ type JobUpdateSettings struct {
 	UpdateOnlyTheseInstances   map[*Range]bool `thrift:"updateOnlyTheseInstances,7" json:"updateOnlyTheseInstances"`
 	WaitForBatchCompletion     bool            `thrift:"waitForBatchCompletion,8" json:"waitForBatchCompletion"`
 	BlockIfNoPulsesAfterMs     *int32          `thrift:"blockIfNoPulsesAfterMs,9" json:"blockIfNoPulsesAfterMs,omitempty"`
+	VariableUpdateGroupSize    []int32         `thrift:"variableUpdateGroupSize,10" json:"variableUpdateGroupSize,omitempty"`
+	AutoPause                  bool            `thrift:"autoPause,11" json:"autoPause"`
 }
 
 func NewJobUpdateSettings() *JobUpdateSettings {
@@ -9250,10 +9258,24 @@ func (p *JobUpdateSettings) GetBlockIfNoPulsesAfterMs() int32 {
 	}
 	return *p.BlockIfNoPulsesAfterMs
 }
+
+var JobUpdateSettings_VariableUpdateGroupSize_DEFAULT []int32
+
+func (p *JobUpdateSettings) GetVariableUpdateGroupSize() []int32 {
+	return p.VariableUpdateGroupSize
+}
+
+func (p *JobUpdateSettings) GetAutoPause() bool {
+	return p.AutoPause
+}
 func (p *JobUpdateSettings) IsSetBlockIfNoPulsesAfterMs() bool {
 	return p.BlockIfNoPulsesAfterMs != nil
 }
 
+func (p *JobUpdateSettings) IsSetVariableUpdateGroupSize() bool {
+	return p.VariableUpdateGroupSize != nil
+}
+
 func (p *JobUpdateSettings) Read(iprot thrift.TProtocol) error {
 	if _, err := iprot.ReadStructBegin(); err != nil {
 		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
@@ -9300,6 +9322,14 @@ func (p *JobUpdateSettings) Read(iprot thrift.TProtocol) error {
 			if err := p.readField9(iprot); err != nil {
 				return err
 			}
+		case 10:
+			if err := p.readField10(iprot); err != nil {
+				return err
+			}
+		case 11:
+			if err := p.readField11(iprot); err != nil {
+				return err
+			}
 		default:
 			if err := iprot.Skip(fieldTypeId); err != nil {
 				return err
@@ -9398,6 +9428,37 @@ func (p *JobUpdateSettings) readField9(iprot thrift.TProtocol) error {
 	return nil
 }
 
+func (p *JobUpdateSettings) readField10(iprot thrift.TProtocol) error {
+	_, size, err := iprot.ReadListBegin()
+	if err != nil {
+		return thrift.PrependError("error reading list begin: ", err)
+	}
+	tSlice := make([]int32, 0, size)
+	p.VariableUpdateGroupSize = tSlice
+	for i := 0; i < size; i++ {
+		var _elem27 int32
+		if v, err := iprot.ReadI32(); err != nil {
+			return thrift.PrependError("error reading field 0: ", err)
+		} else {
+			_elem27 = v
+		}
+		p.VariableUpdateGroupSize = append(p.VariableUpdateGroupSize, _elem27)
+	}
+	if err := iprot.ReadListEnd(); err != nil {
+		return thrift.PrependError("error reading list end: ", err)
+	}
+	return nil
+}
+
+func (p *JobUpdateSettings) readField11(iprot thrift.TProtocol) error {
+	if v, err := iprot.ReadBool(); err != nil {
+		return thrift.PrependError("error reading field 11: ", err)
+	} else {
+		p.AutoPause = v
+	}
+	return nil
+}
+
 func (p *JobUpdateSettings) Write(oprot thrift.TProtocol) error {
 	if err := oprot.WriteStructBegin("JobUpdateSettings"); err != nil {
 		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
@@ -9426,6 +9487,12 @@ func (p *JobUpdateSettings) Write(oprot thrift.TProtocol) error {
 	if err := p.writeField9(oprot); err != nil {
 		return err
 	}
+	if err := p.writeField10(oprot); err != nil {
+		return err
+	}
+	if err := p.writeField11(oprot); err != nil {
+		return err
+	}
 	if err := oprot.WriteFieldStop(); err != nil {
 		return thrift.PrependError("write field stop error: ", err)
 	}
@@ -9549,6 +9616,42 @@ func (p *JobUpdateSettings) writeField9(oprot thrift.TProtocol) (err error) {
 	return err
 }
 
+func (p *JobUpdateSettings) writeField10(oprot thrift.TProtocol) (err error) {
+	if p.IsSetVariableUpdateGroupSize() {
+		if err := oprot.WriteFieldBegin("variableUpdateGroupSize", thrift.LIST, 10); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:variableUpdateGroupSize: ", p), err)
+		}
+		if err := oprot.WriteListBegin(thrift.I32, len(p.VariableUpdateGroupSize)); err != nil {
+			return thrift.PrependError("error writing list begin: ", err)
+		}
+		for _, v := range p.VariableUpdateGroupSize {
+			if err := oprot.WriteI32(int32(v)); err != nil {
+				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
+			}
+		}
+		if err := oprot.WriteListEnd(); err != nil {
+			return thrift.PrependError("error writing list end: ", err)
+		}
+		if err := oprot.WriteFieldEnd(); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T write field end error 10:variableUpdateGroupSize: ", p), err)
+		}
+	}
+	return err
+}
+
+func (p *JobUpdateSettings) writeField11(oprot thrift.TProtocol) (err error) {
+	if err := oprot.WriteFieldBegin("autoPause", thrift.BOOL, 11); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:autoPause: ", p), err)
+	}
+	if err := oprot.WriteBool(bool(p.AutoPause)); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T.autoPause (11) field write error: ", p), err)
+	}
+	if err := oprot.WriteFieldEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field end error 11:autoPause: ", p), err)
+	}
+	return err
+}
+
 func (p *JobUpdateSettings) String() string {
 	if p == nil {
 		return "<nil>"
@@ -10025,11 +10128,11 @@ func (p *InstanceTaskConfig) readField2(iprot thrift.TProtocol) error {
 	tSet := make(map[*Range]bool, size)
 	p.Instances = tSet
 	for i := 0; i < size; i++ {
-		_elem27 := &Range{}
-		if err := _elem27.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem27), err)
+		_elem28 := &Range{}
+		if err := _elem28.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem28), err)
 		}
-		p.Instances[_elem27] = true
+		p.Instances[_elem28] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -10397,11 +10500,11 @@ func (p *JobUpdateSummary) readField6(iprot thrift.TProtocol) error {
 	tSet := make(map[*Metadata]bool, size)
 	p.Metadata = tSet
 	for i := 0; i < size; i++ {
-		_elem28 := &Metadata{}
-		if err := _elem28.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem28), err)
+		_elem29 := &Metadata{}
+		if err := _elem29.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem29), err)
 		}
-		p.Metadata[_elem28] = true
+		p.Metadata[_elem29] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -10597,11 +10700,11 @@ func (p *JobUpdateInstructions) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*InstanceTaskConfig]bool, size)
 	p.InitialState = tSet
 	for i := 0; i < size; i++ {
-		_elem29 := &InstanceTaskConfig{}
-		if err := _elem29.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem29), err)
+		_elem30 := &InstanceTaskConfig{}
+		if err := _elem30.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem30), err)
 		}
-		p.InitialState[_elem29] = true
+		p.InitialState[_elem30] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -10936,11 +11039,11 @@ func (p *JobUpdateDetails) readField2(iprot thrift.TProtocol) error {
 	tSlice := make([]*JobUpdateEvent, 0, size)
 	p.UpdateEvents = tSlice
 	for i := 0; i < size; i++ {
-		_elem30 := &JobUpdateEvent{}
-		if err := _elem30.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem30), err)
+		_elem31 := &JobUpdateEvent{}
+		if err := _elem31.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem31), err)
 		}
-		p.UpdateEvents = append(p.UpdateEvents, _elem30)
+		p.UpdateEvents = append(p.UpdateEvents, _elem31)
 	}
 	if err := iprot.ReadListEnd(); err != nil {
 		return thrift.PrependError("error reading list end: ", err)
@@ -10956,11 +11059,11 @@ func (p *JobUpdateDetails) readField3(iprot thrift.TProtocol) error {
 	tSlice := make([]*JobInstanceUpdateEvent, 0, size)
 	p.InstanceEvents = tSlice
 	for i := 0; i < size; i++ {
-		_elem31 := &JobInstanceUpdateEvent{}
-		if err := _elem31.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem31), err)
+		_elem32 := &JobInstanceUpdateEvent{}
+		if err := _elem32.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem32), err)
 		}
-		p.InstanceEvents = append(p.InstanceEvents, _elem31)
+		p.InstanceEvents = append(p.InstanceEvents, _elem32)
 	}
 	if err := iprot.ReadListEnd(); err != nil {
 		return thrift.PrependError("error reading list end: ", err)
@@ -11187,11 +11290,11 @@ func (p *JobUpdateRequest) readField4(iprot thrift.TProtocol) error {
 	tSet := make(map[*Metadata]bool, size)
 	p.Metadata = tSet
 	for i := 0; i < size; i++ {
-		_elem32 := &Metadata{}
-		if err := _elem32.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem32), err)
+		_elem33 := &Metadata{}
+		if err := _elem33.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem33), err)
 		}
-		p.Metadata[_elem32] = true
+		p.Metadata[_elem33] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -11487,14 +11590,14 @@ func (p *JobUpdateQuery) readField5(iprot thrift.TProtocol) error {
 	tSet := make(map[JobUpdateStatus]bool, size)
 	p.UpdateStatuses = tSet
 	for i := 0; i < size; i++ {
-		var _elem33 JobUpdateStatus
+		var _elem34 JobUpdateStatus
 		if v, err := iprot.ReadI32(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
 			temp := JobUpdateStatus(v)
-			_elem33 = temp
+			_elem34 = temp
 		}
-		p.UpdateStatuses[_elem33] = true
+		p.UpdateStatuses[_elem34] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -11724,13 +11827,13 @@ func (p *ListBackupsResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[string]bool, size)
 	p.Backups = tSet
 	for i := 0; i < size; i++ {
-		var _elem34 string
+		var _elem35 string
 		if v, err := iprot.ReadString(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem34 = v
+			_elem35 = v
 		}
-		p.Backups[_elem34] = true
+		p.Backups[_elem35] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -11836,11 +11939,11 @@ func (p *StartMaintenanceResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*HostStatus]bool, size)
 	p.Statuses = tSet
 	for i := 0; i < size; i++ {
-		_elem35 := &HostStatus{}
-		if err := _elem35.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem35), err)
+		_elem36 := &HostStatus{}
+		if err := _elem36.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem36), err)
 		}
-		p.Statuses[_elem35] = true
+		p.Statuses[_elem36] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -11946,11 +12049,11 @@ func (p *DrainHostsResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*HostStatus]bool, size)
 	p.Statuses = tSet
 	for i := 0; i < size; i++ {
-		_elem36 := &HostStatus{}
-		if err := _elem36.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem36), err)
+		_elem37 := &HostStatus{}
+		if err := _elem37.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem37), err)
 		}
-		p.Statuses[_elem36] = true
+		p.Statuses[_elem37] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12056,11 +12159,11 @@ func (p *QueryRecoveryResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*ScheduledTask]bool, size)
 	p.Tasks = tSet
 	for i := 0; i < size; i++ {
-		_elem37 := &ScheduledTask{}
-		if err := _elem37.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem37), err)
+		_elem38 := &ScheduledTask{}
+		if err := _elem38.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem38), err)
 		}
-		p.Tasks[_elem37] = true
+		p.Tasks[_elem38] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12166,11 +12269,11 @@ func (p *MaintenanceStatusResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*HostStatus]bool, size)
 	p.Statuses = tSet
 	for i := 0; i < size; i++ {
-		_elem38 := &HostStatus{}
-		if err := _elem38.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem38), err)
+		_elem39 := &HostStatus{}
+		if err := _elem39.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem39), err)
 		}
-		p.Statuses[_elem38] = true
+		p.Statuses[_elem39] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12276,11 +12379,11 @@ func (p *EndMaintenanceResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*HostStatus]bool, size)
 	p.Statuses = tSet
 	for i := 0; i < size; i++ {
-		_elem39 := &HostStatus{}
-		if err := _elem39.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem39), err)
+		_elem40 := &HostStatus{}
+		if err := _elem40.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem40), err)
 		}
-		p.Statuses[_elem39] = true
+		p.Statuses[_elem40] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12386,11 +12489,11 @@ func (p *RoleSummaryResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*RoleSummary]bool, size)
 	p.Summaries = tSet
 	for i := 0; i < size; i++ {
-		_elem40 := &RoleSummary{}
-		if err := _elem40.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem40), err)
+		_elem41 := &RoleSummary{}
+		if err := _elem41.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem41), err)
 		}
-		p.Summaries[_elem40] = true
+		p.Summaries[_elem41] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12496,11 +12599,11 @@ func (p *JobSummaryResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*JobSummary]bool, size)
 	p.Summaries = tSet
 	for i := 0; i < size; i++ {
-		_elem41 := &JobSummary{}
-		if err := _elem41.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem41), err)
+		_elem42 := &JobSummary{}
+		if err := _elem42.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem42), err)
 		}
-		p.Summaries[_elem41] = true
+		p.Summaries[_elem42] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12705,11 +12808,11 @@ func (p *GetPendingReasonResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*PendingReason]bool, size)
 	p.Reasons = tSet
 	for i := 0; i < size; i++ {
-		_elem42 := &PendingReason{}
-		if err := _elem42.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem42), err)
+		_elem43 := &PendingReason{}
+		if err := _elem43.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem43), err)
 		}
-		p.Reasons[_elem42] = true
+		p.Reasons[_elem43] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -12963,11 +13066,11 @@ func (p *GetJobUpdateSummariesResult_) readField1(iprot thrift.TProtocol) error
 	tSlice := make([]*JobUpdateSummary, 0, size)
 	p.UpdateSummaries = tSlice
 	for i := 0; i < size; i++ {
-		_elem43 := &JobUpdateSummary{}
-		if err := _elem43.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem43), err)
+		_elem44 := &JobUpdateSummary{}
+		if err := _elem44.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem44), err)
 		}
-		p.UpdateSummaries = append(p.UpdateSummaries, _elem43)
+		p.UpdateSummaries = append(p.UpdateSummaries, _elem44)
 	}
 	if err := iprot.ReadListEnd(); err != nil {
 		return thrift.PrependError("error reading list end: ", err)
@@ -13102,11 +13205,11 @@ func (p *GetJobUpdateDetailsResult_) readField2(iprot thrift.TProtocol) error {
 	tSlice := make([]*JobUpdateDetails, 0, size)
 	p.DetailsList = tSlice
 	for i := 0; i < size; i++ {
-		_elem44 := &JobUpdateDetails{}
-		if err := _elem44.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem44), err)
+		_elem45 := &JobUpdateDetails{}
+		if err := _elem45.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem45), err)
 		}
-		p.DetailsList = append(p.DetailsList, _elem44)
+		p.DetailsList = append(p.DetailsList, _elem45)
 	}
 	if err := iprot.ReadListEnd(); err != nil {
 		return thrift.PrependError("error reading list end: ", err)
@@ -13352,11 +13455,11 @@ func (p *GetJobUpdateDiffResult_) readField1(iprot thrift.TProtocol) error {
 	tSet := make(map[*ConfigGroup]bool, size)
 	p.Add = tSet
 	for i := 0; i < size; i++ {
-		_elem45 := &ConfigGroup{}
-		if err := _elem45.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem45), err)
+		_elem46 := &ConfigGroup{}
+		if err := _elem46.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem46), err)
 		}
-		p.Add[_elem45] = true
+		p.Add[_elem46] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -13372,11 +13475,11 @@ func (p *GetJobUpdateDiffResult_) readField2(iprot thrift.TProtocol) error {
 	tSet := make(map[*ConfigGroup]bool, size)
 	p.Remove = tSet
 	for i := 0; i < size; i++ {
-		_elem46 := &ConfigGroup{}
-		if err := _elem46.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem46), err)
+		_elem47 := &ConfigGroup{}
+		if err := _elem47.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem47), err)
 		}
-		p.Remove[_elem46] = true
+		p.Remove[_elem47] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -13392,11 +13495,11 @@ func (p *GetJobUpdateDiffResult_) readField3(iprot thrift.TProtocol) error {
 	tSet := make(map[*ConfigGroup]bool, size)
 	p.Update = tSet
 	for i := 0; i < size; i++ {
-		_elem47 := &ConfigGroup{}
-		if err := _elem47.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem47), err)
+		_elem48 := &ConfigGroup{}
+		if err := _elem48.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem48), err)
 		}
-		p.Update[_elem47] = true
+		p.Update[_elem48] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -13412,11 +13515,11 @@ func (p *GetJobUpdateDiffResult_) readField4(iprot thrift.TProtocol) error {
 	tSet := make(map[*ConfigGroup]bool, size)
 	p.Unchanged = tSet
 	for i := 0; i < size; i++ {
-		_elem48 := &ConfigGroup{}
-		if err := _elem48.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem48), err)
+		_elem49 := &ConfigGroup{}
+		if err := _elem49.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem49), err)
 		}
-		p.Unchanged[_elem48] = true
+		p.Unchanged[_elem49] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -13615,19 +13718,19 @@ func (p *TierConfig) readField2(iprot thrift.TProtocol) error {
 	tMap := make(map[string]string, size)
 	p.Settings = tMap
 	for i := 0; i < size; i++ {
-		var _key49 string
+		var _key50 string
 		if v, err := iprot.ReadString(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_key49 = v
+			_key50 = v
 		}
-		var _val50 string
+		var _val51 string
 		if v, err := iprot.ReadString(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_val50 = v
+			_val51 = v
 		}
-		p.Settings[_key49] = _val50
+		p.Settings[_key50] = _val51
 	}
 	if err := iprot.ReadMapEnd(); err != nil {
 		return thrift.PrependError("error reading map end: ", err)
@@ -13773,11 +13876,11 @@ func (p *GetTierConfigResult_) readField2(iprot thrift.TProtocol) error {
 	tSet := make(map[*TierConfig]bool, size)
 	p.Tiers = tSet
 	for i := 0; i < size; i++ {
-		_elem51 := &TierConfig{}
-		if err := _elem51.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem51), err)
+		_elem52 := &TierConfig{}
+		if err := _elem52.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem52), err)
 		}
-		p.Tiers[_elem51] = true
+		p.Tiers[_elem52] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@@ -15224,11 +15327,11 @@ func (p *Response) readField6(iprot thrift.TProtocol) error {
 	tSlice := make([]*ResponseDetail, 0, size)
 	p.Details = tSlice
 	for i := 0; i < size; i++ {
-		_elem52 := &ResponseDetail{}
-		if err := _elem52.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem52), err)
+		_elem53 := &ResponseDetail{}
+		if err := _elem53.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem53), err)
 		}
-		p.Details = append(p.Details, _elem52)
+		p.Details = append(p.Details, _elem53)
 	}
 	if err := iprot.ReadListEnd(); err != nil {
 		return thrift.PrependError("error reading list end: ", err)
diff --git a/realis.go b/realis.go
index c9291d1..954d618 100644
--- a/realis.go
+++ b/realis.go
@@ -587,7 +587,6 @@ func (r *realisClient) CreateService(auroraJob Job, settings *aurora.JobUpdateSe
 	// Create a new job update object and ship it to the StartJobUpdate api
 	update := NewUpdateJob(auroraJob.TaskConfig(), settings)
 	update.InstanceCount(auroraJob.GetInstanceCount())
-	update.BatchSize(auroraJob.GetInstanceCount())
 
 	resp, err := r.StartJobUpdate(update, "")
 	if err != nil {
diff --git a/updatejob.go b/updatejob.go
index 4ee4f14..c6f1377 100644
--- a/updatejob.go
+++ b/updatejob.go
@@ -60,6 +60,7 @@ func NewDefaultUpdateJob(config *aurora.TaskConfig) *UpdateJob {
 	req.Settings.MaxPerInstanceFailures = 0
 	req.Settings.MaxFailedInstances = 0
 	req.Settings.RollbackOnFailure = true
+	req.Settings.VariableUpdateGroupSize = []int32{1, 2, 3}
 
 	//TODO(rdelvalle): Deep copy job struct to avoid unexpected behavior
 	return &UpdateJob{Job: job, req: req}