Thrift API update and Pull Request template. (#43)

* Adding a Pull request template to serve as a reminder of what
to do before creating the pull request.

* Updating our thrift API to match changes made by Aurora.

* Update go bindings to match update thrift API.

.auroraversion

@@ -1 +1 @@
-0.16.0
+0.19.0

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,11 @@
+Before submitting, please make sure you run a vagrant box running Aurora with the latest version shown in .auroraversion
+and run go test from the project root.
+
+To run an Aurora Vagrant image, follow the instructions here:
+http://aurora.apache.org/documentation/latest/getting-started/vagrant/
+
+* Have you run goformat on the project before submitting?
+
+* Have you run go test on the project before submitting? Do all tests pass?
+
+* Does the Pull Request require a test to be added to the end to end tests? If so, has it been added?

auroraAPI.thrift

@@ -27,8 +27,8 @@ enum ResponseCode {
   ERROR           = 2,
   WARNING         = 3,
   AUTH_FAILED     = 4,
-  /** Raised when a Lock-protected operation failed due to lock validation. */
-  LOCK_ERROR      = 5,
+  /** Raised when an operation was unable to proceed due to an in-progress job update. */
+  JOB_UPDATING_ERROR = 5,
   /** Raised when a scheduler is transiently unavailable and later retry is recommended. */
   ERROR_TRANSIENT = 6
 }
@@ -203,6 +203,8 @@ union Image {
 struct MesosContainer {
   /** the optional filesystem image to use when launching this task. */
   1: optional Image image
+  /** the optional list of volumes to mount into the task. */
+  2: optional list<Volume> volumes
 }
 
 /** Describes a parameter passed to docker cli */
@@ -618,6 +620,10 @@ const set<JobUpdateStatus> ACTIVE_JOB_UPDATE_STATES = [JobUpdateStatus.ROLLING_F
                                                        JobUpdateStatus.ROLL_FORWARD_AWAITING_PULSE,
                                                        JobUpdateStatus.ROLL_BACK_AWAITING_PULSE]
 
+/** States the job update can be in while waiting for a pulse. */
+const set<JobUpdateStatus> AWAITNG_PULSE_JOB_UPDATE_STATES = [JobUpdateStatus.ROLL_FORWARD_AWAITING_PULSE,
+                                                              JobUpdateStatus.ROLL_BACK_AWAITING_PULSE]
+
 /** Job update actions that can be applied to job instances. */
 enum JobUpdateAction {
   /**
@@ -1073,7 +1079,7 @@ service AuroraSchedulerManager extends ReadOnlyScheduler {
   Response restartShards(5: JobKey job, 3: set<i32> shardIds)
 
   /** Initiates a kill on tasks. */
-  Response killTasks(4: JobKey job, 5: set<i32> instances)
+  Response killTasks(4: JobKey job, 5: set<i32> instances, 6: string message)
 
   /**
    * Adds new instances with the TaskConfig of the existing instance pointed by the key.
@@ -1134,31 +1140,6 @@ service AuroraSchedulerManager extends ReadOnlyScheduler {
   Response pulseJobUpdate(1: JobUpdateKey key)
 }
 
-struct InstanceConfigRewrite {
-  /** Key for the task to rewrite. */
-  1: InstanceKey instanceKey
-  /** The original configuration. */
-  2: TaskConfig oldTask
-  /** The rewritten configuration. */
-  3: TaskConfig rewrittenTask
-}
-
-struct JobConfigRewrite {
-  /** The original job configuration. */
-  1: JobConfiguration oldJob
-  /** The rewritten job configuration. */
-  2: JobConfiguration rewrittenJob
-}
-
-union ConfigRewrite {
-  1: JobConfigRewrite jobRewrite
-  2: InstanceConfigRewrite instanceRewrite
-}
-
-struct RewriteConfigsRequest {
-  1: list<ConfigRewrite> rewriteCommands
-}
-
 struct ExplicitReconciliationSettings {
   1: optional i32 batchSize
 }
@@ -1214,20 +1195,18 @@ service AuroraAdmin extends AuroraSchedulerManager {
   /** Start a storage snapshot and block until it completes. */
   Response snapshot()
 
-  /**
-   * Forcibly rewrites the stored definition of user configurations.  This is intended to be used
-   * in a controlled setting, primarily to migrate pieces of configurations that are opaque to the
-   * scheduler (e.g. executorConfig).
-   * The scheduler may do some validation of the rewritten configurations, but it is important
-   * that the caller take care to provide valid input and alter only necessary fields.
-   */
-  Response rewriteConfigs(1: RewriteConfigsRequest request)
-
   /** Tell scheduler to trigger an explicit task reconciliation with the given settings. */
   Response triggerExplicitTaskReconciliation(1: ExplicitReconciliationSettings settings)
 
   /** Tell scheduler to trigger an implicit task reconciliation. */
   Response triggerImplicitTaskReconciliation()
+
+  /**
+   * Force prune any (terminal) tasks that match the query. If no statuses are supplied with the
+   * query, it will default to all terminal task states. If statuses are supplied, they must be
+   * terminal states.
+   */
+  Response pruneTasks(1: TaskQuery query)
 }
 
 // The name of the header that should be sent to bypass leader redirection in the Scheduler.
@@ -1235,4 +1214,4 @@ const string BYPASS_LEADER_REDIRECT_HEADER_NAME = 'Bypass-Leader-Redirect'
 
 // The path under which a task's filesystem should be mounted when using images and the Mesos
 // unified containerizer.
-const string TASK_FILESYSTEM_MOUNT_POINT = 'taskfs'
+const string TASK_FILESYSTEM_MOUNT_POINT = 'taskfs'

gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go

@@ -34,15 +34,15 @@ func Usage() {
 	fmt.Fprintln(os.Stderr, "  Response maintenanceStatus(Hosts hosts)")
 	fmt.Fprintln(os.Stderr, "  Response endMaintenance(Hosts hosts)")
 	fmt.Fprintln(os.Stderr, "  Response snapshot()")
-	fmt.Fprintln(os.Stderr, "  Response rewriteConfigs(RewriteConfigsRequest request)")
 	fmt.Fprintln(os.Stderr, "  Response triggerExplicitTaskReconciliation(ExplicitReconciliationSettings settings)")
 	fmt.Fprintln(os.Stderr, "  Response triggerImplicitTaskReconciliation()")
+	fmt.Fprintln(os.Stderr, "  Response pruneTasks(TaskQuery query)")
 	fmt.Fprintln(os.Stderr, "  Response createJob(JobConfiguration description)")
 	fmt.Fprintln(os.Stderr, "  Response scheduleCronJob(JobConfiguration description)")
 	fmt.Fprintln(os.Stderr, "  Response descheduleCronJob(JobKey job)")
 	fmt.Fprintln(os.Stderr, "  Response startCronJob(JobKey job)")
 	fmt.Fprintln(os.Stderr, "  Response restartShards(JobKey job,  shardIds)")
-	fmt.Fprintln(os.Stderr, "  Response killTasks(JobKey job,  instances)")
+	fmt.Fprintln(os.Stderr, "  Response killTasks(JobKey job,  instances, string message)")
 	fmt.Fprintln(os.Stderr, "  Response addInstances(InstanceKey key, i32 count)")
 	fmt.Fprintln(os.Stderr, "  Response replaceCronTemplate(JobConfiguration config)")
 	fmt.Fprintln(os.Stderr, "  Response startJobUpdate(JobUpdateRequest request, string message)")
@@ -165,19 +165,19 @@ func main() {
 		}
 		argvalue0 := flag.Arg(1)
 		value0 := argvalue0
-		arg352 := flag.Arg(2)
-		mbTrans353 := thrift.NewTMemoryBufferLen(len(arg352))
-		defer mbTrans353.Close()
-		_, err354 := mbTrans353.WriteString(arg352)
-		if err354 != nil {
+		arg353 := flag.Arg(2)
+		mbTrans354 := thrift.NewTMemoryBufferLen(len(arg353))
+		defer mbTrans354.Close()
+		_, err355 := mbTrans354.WriteString(arg353)
+		if err355 != nil {
 			Usage()
 			return
 		}
-		factory355 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt356 := factory355.GetProtocol(mbTrans353)
+		factory356 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt357 := factory356.GetProtocol(mbTrans354)
 		argvalue1 := aurora.NewResourceAggregate()
-		err357 := argvalue1.Read(jsProt356)
-		if err357 != nil {
+		err358 := argvalue1.Read(jsProt357)
+		if err358 != nil {
 			Usage()
 			return
 		}
@@ -233,19 +233,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "QueryRecovery requires 1 args")
 			flag.Usage()
 		}
-		arg360 := flag.Arg(1)
-		mbTrans361 := thrift.NewTMemoryBufferLen(len(arg360))
-		defer mbTrans361.Close()
-		_, err362 := mbTrans361.WriteString(arg360)
-		if err362 != nil {
+		arg361 := flag.Arg(1)
+		mbTrans362 := thrift.NewTMemoryBufferLen(len(arg361))
+		defer mbTrans362.Close()
+		_, err363 := mbTrans362.WriteString(arg361)
+		if err363 != nil {
 			Usage()
 			return
 		}
-		factory363 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt364 := factory363.GetProtocol(mbTrans361)
+		factory364 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt365 := factory364.GetProtocol(mbTrans362)
 		argvalue0 := aurora.NewTaskQuery()
-		err365 := argvalue0.Read(jsProt364)
-		if err365 != nil {
+		err366 := argvalue0.Read(jsProt365)
+		if err366 != nil {
 			Usage()
 			return
 		}
@@ -258,19 +258,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DeleteRecoveryTasks requires 1 args")
 			flag.Usage()
 		}
-		arg366 := flag.Arg(1)
-		mbTrans367 := thrift.NewTMemoryBufferLen(len(arg366))
-		defer mbTrans367.Close()
-		_, err368 := mbTrans367.WriteString(arg366)
-		if err368 != nil {
+		arg367 := flag.Arg(1)
+		mbTrans368 := thrift.NewTMemoryBufferLen(len(arg367))
+		defer mbTrans368.Close()
+		_, err369 := mbTrans368.WriteString(arg367)
+		if err369 != nil {
 			Usage()
 			return
 		}
-		factory369 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt370 := factory369.GetProtocol(mbTrans367)
+		factory370 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt371 := factory370.GetProtocol(mbTrans368)
 		argvalue0 := aurora.NewTaskQuery()
-		err371 := argvalue0.Read(jsProt370)
-		if err371 != nil {
+		err372 := argvalue0.Read(jsProt371)
+		if err372 != nil {
 			Usage()
 			return
 		}
@@ -299,19 +299,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg372 := flag.Arg(1)
-		mbTrans373 := thrift.NewTMemoryBufferLen(len(arg372))
-		defer mbTrans373.Close()
-		_, err374 := mbTrans373.WriteString(arg372)
-		if err374 != nil {
+		arg373 := flag.Arg(1)
+		mbTrans374 := thrift.NewTMemoryBufferLen(len(arg373))
+		defer mbTrans374.Close()
+		_, err375 := mbTrans374.WriteString(arg373)
+		if err375 != nil {
 			Usage()
 			return
 		}
-		factory375 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt376 := factory375.GetProtocol(mbTrans373)
+		factory376 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt377 := factory376.GetProtocol(mbTrans374)
 		argvalue0 := aurora.NewHosts()
-		err377 := argvalue0.Read(jsProt376)
-		if err377 != nil {
+		err378 := argvalue0.Read(jsProt377)
+		if err378 != nil {
 			Usage()
 			return
 		}
@@ -324,19 +324,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DrainHosts requires 1 args")
 			flag.Usage()
 		}
-		arg378 := flag.Arg(1)
-		mbTrans379 := thrift.NewTMemoryBufferLen(len(arg378))
-		defer mbTrans379.Close()
-		_, err380 := mbTrans379.WriteString(arg378)
-		if err380 != nil {
+		arg379 := flag.Arg(1)
+		mbTrans380 := thrift.NewTMemoryBufferLen(len(arg379))
+		defer mbTrans380.Close()
+		_, err381 := mbTrans380.WriteString(arg379)
+		if err381 != nil {
 			Usage()
 			return
 		}
-		factory381 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt382 := factory381.GetProtocol(mbTrans379)
+		factory382 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt383 := factory382.GetProtocol(mbTrans380)
 		argvalue0 := aurora.NewHosts()
-		err383 := argvalue0.Read(jsProt382)
-		if err383 != nil {
+		err384 := argvalue0.Read(jsProt383)
+		if err384 != nil {
 			Usage()
 			return
 		}
@@ -349,19 +349,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "MaintenanceStatus requires 1 args")
 			flag.Usage()
 		}
-		arg384 := flag.Arg(1)
-		mbTrans385 := thrift.NewTMemoryBufferLen(len(arg384))
-		defer mbTrans385.Close()
-		_, err386 := mbTrans385.WriteString(arg384)
-		if err386 != nil {
+		arg385 := flag.Arg(1)
+		mbTrans386 := thrift.NewTMemoryBufferLen(len(arg385))
+		defer mbTrans386.Close()
+		_, err387 := mbTrans386.WriteString(arg385)
+		if err387 != nil {
 			Usage()
 			return
 		}
-		factory387 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt388 := factory387.GetProtocol(mbTrans385)
+		factory388 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt389 := factory388.GetProtocol(mbTrans386)
 		argvalue0 := aurora.NewHosts()
-		err389 := argvalue0.Read(jsProt388)
-		if err389 != nil {
+		err390 := argvalue0.Read(jsProt389)
+		if err390 != nil {
 			Usage()
 			return
 		}
@@ -374,19 +374,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "EndMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg390 := flag.Arg(1)
-		mbTrans391 := thrift.NewTMemoryBufferLen(len(arg390))
-		defer mbTrans391.Close()
-		_, err392 := mbTrans391.WriteString(arg390)
-		if err392 != nil {
+		arg391 := flag.Arg(1)
+		mbTrans392 := thrift.NewTMemoryBufferLen(len(arg391))
+		defer mbTrans392.Close()
+		_, err393 := mbTrans392.WriteString(arg391)
+		if err393 != nil {
 			Usage()
 			return
 		}
-		factory393 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt394 := factory393.GetProtocol(mbTrans391)
+		factory394 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt395 := factory394.GetProtocol(mbTrans392)
 		argvalue0 := aurora.NewHosts()
-		err395 := argvalue0.Read(jsProt394)
-		if err395 != nil {
+		err396 := argvalue0.Read(jsProt395)
+		if err396 != nil {
 			Usage()
 			return
 		}
@@ -402,49 +402,24 @@ func main() {
 		fmt.Print(client.Snapshot())
 		fmt.Print("\n")
 		break
-	case "rewriteConfigs":
-		if flag.NArg()-1 != 1 {
-			fmt.Fprintln(os.Stderr, "RewriteConfigs requires 1 args")
-			flag.Usage()
-		}
-		arg396 := flag.Arg(1)
-		mbTrans397 := thrift.NewTMemoryBufferLen(len(arg396))
-		defer mbTrans397.Close()
-		_, err398 := mbTrans397.WriteString(arg396)
-		if err398 != nil {
-			Usage()
-			return
-		}
-		factory399 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt400 := factory399.GetProtocol(mbTrans397)
-		argvalue0 := aurora.NewRewriteConfigsRequest()
-		err401 := argvalue0.Read(jsProt400)
-		if err401 != nil {
-			Usage()
-			return
-		}
-		value0 := argvalue0
-		fmt.Print(client.RewriteConfigs(value0))
-		fmt.Print("\n")
-		break
 	case "triggerExplicitTaskReconciliation":
 		if flag.NArg()-1 != 1 {
 			fmt.Fprintln(os.Stderr, "TriggerExplicitTaskReconciliation requires 1 args")
 			flag.Usage()
 		}
-		arg402 := flag.Arg(1)
-		mbTrans403 := thrift.NewTMemoryBufferLen(len(arg402))
-		defer mbTrans403.Close()
-		_, err404 := mbTrans403.WriteString(arg402)
-		if err404 != nil {
+		arg397 := flag.Arg(1)
+		mbTrans398 := thrift.NewTMemoryBufferLen(len(arg397))
+		defer mbTrans398.Close()
+		_, err399 := mbTrans398.WriteString(arg397)
+		if err399 != nil {
 			Usage()
 			return
 		}
-		factory405 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt406 := factory405.GetProtocol(mbTrans403)
+		factory400 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt401 := factory400.GetProtocol(mbTrans398)
 		argvalue0 := aurora.NewExplicitReconciliationSettings()
-		err407 := argvalue0.Read(jsProt406)
-		if err407 != nil {
+		err402 := argvalue0.Read(jsProt401)
+		if err402 != nil {
 			Usage()
 			return
 		}
@@ -460,24 +435,49 @@ func main() {
 		fmt.Print(client.TriggerImplicitTaskReconciliation())
 		fmt.Print("\n")
 		break
+	case "pruneTasks":
+		if flag.NArg()-1 != 1 {
+			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 {
+			Usage()
+			return
+		}
+		factory406 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt407 := factory406.GetProtocol(mbTrans404)
+		argvalue0 := aurora.NewTaskQuery()
+		err408 := argvalue0.Read(jsProt407)
+		if err408 != nil {
+			Usage()
+			return
+		}
+		value0 := argvalue0
+		fmt.Print(client.PruneTasks(value0))
+		fmt.Print("\n")
+		break
 	case "createJob":
 		if flag.NArg()-1 != 1 {
 			fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
 			flag.Usage()
 		}
-		arg408 := flag.Arg(1)
-		mbTrans409 := thrift.NewTMemoryBufferLen(len(arg408))
-		defer mbTrans409.Close()
-		_, err410 := mbTrans409.WriteString(arg408)
-		if err410 != nil {
+		arg409 := flag.Arg(1)
+		mbTrans410 := thrift.NewTMemoryBufferLen(len(arg409))
+		defer mbTrans410.Close()
+		_, err411 := mbTrans410.WriteString(arg409)
+		if err411 != nil {
 			Usage()
 			return
 		}
-		factory411 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt412 := factory411.GetProtocol(mbTrans409)
+		factory412 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt413 := factory412.GetProtocol(mbTrans410)
 		argvalue0 := aurora.NewJobConfiguration()
-		err413 := argvalue0.Read(jsProt412)
-		if err413 != nil {
+		err414 := argvalue0.Read(jsProt413)
+		if err414 != nil {
 			Usage()
 			return
 		}
@@ -490,19 +490,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg414 := flag.Arg(1)
-		mbTrans415 := thrift.NewTMemoryBufferLen(len(arg414))
-		defer mbTrans415.Close()
-		_, err416 := mbTrans415.WriteString(arg414)
-		if err416 != nil {
+		arg415 := flag.Arg(1)
+		mbTrans416 := thrift.NewTMemoryBufferLen(len(arg415))
+		defer mbTrans416.Close()
+		_, err417 := mbTrans416.WriteString(arg415)
+		if err417 != nil {
 			Usage()
 			return
 		}
-		factory417 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt418 := factory417.GetProtocol(mbTrans415)
+		factory418 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt419 := factory418.GetProtocol(mbTrans416)
 		argvalue0 := aurora.NewJobConfiguration()
-		err419 := argvalue0.Read(jsProt418)
-		if err419 != nil {
+		err420 := argvalue0.Read(jsProt419)
+		if err420 != nil {
 			Usage()
 			return
 		}
@@ -515,19 +515,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg420 := flag.Arg(1)
-		mbTrans421 := thrift.NewTMemoryBufferLen(len(arg420))
-		defer mbTrans421.Close()
-		_, err422 := mbTrans421.WriteString(arg420)
-		if err422 != nil {
+		arg421 := flag.Arg(1)
+		mbTrans422 := thrift.NewTMemoryBufferLen(len(arg421))
+		defer mbTrans422.Close()
+		_, err423 := mbTrans422.WriteString(arg421)
+		if err423 != nil {
 			Usage()
 			return
 		}
-		factory423 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt424 := factory423.GetProtocol(mbTrans421)
+		factory424 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt425 := factory424.GetProtocol(mbTrans422)
 		argvalue0 := aurora.NewJobKey()
-		err425 := argvalue0.Read(jsProt424)
-		if err425 != nil {
+		err426 := argvalue0.Read(jsProt425)
+		if err426 != nil {
 			Usage()
 			return
 		}
@@ -540,19 +540,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg426 := flag.Arg(1)
-		mbTrans427 := thrift.NewTMemoryBufferLen(len(arg426))
-		defer mbTrans427.Close()
-		_, err428 := mbTrans427.WriteString(arg426)
-		if err428 != nil {
+		arg427 := flag.Arg(1)
+		mbTrans428 := thrift.NewTMemoryBufferLen(len(arg427))
+		defer mbTrans428.Close()
+		_, err429 := mbTrans428.WriteString(arg427)
+		if err429 != nil {
 			Usage()
 			return
 		}
-		factory429 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt430 := factory429.GetProtocol(mbTrans427)
+		factory430 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt431 := factory430.GetProtocol(mbTrans428)
 		argvalue0 := aurora.NewJobKey()
-		err431 := argvalue0.Read(jsProt430)
-		if err431 != nil {
+		err432 := argvalue0.Read(jsProt431)
+		if err432 != nil {
 			Usage()
 			return
 		}
@@ -565,36 +565,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
 			flag.Usage()
 		}
-		arg432 := flag.Arg(1)
-		mbTrans433 := thrift.NewTMemoryBufferLen(len(arg432))
-		defer mbTrans433.Close()
-		_, err434 := mbTrans433.WriteString(arg432)
-		if err434 != nil {
+		arg433 := flag.Arg(1)
+		mbTrans434 := thrift.NewTMemoryBufferLen(len(arg433))
+		defer mbTrans434.Close()
+		_, err435 := mbTrans434.WriteString(arg433)
+		if err435 != nil {
 			Usage()
 			return
 		}
-		factory435 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt436 := factory435.GetProtocol(mbTrans433)
+		factory436 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt437 := factory436.GetProtocol(mbTrans434)
 		argvalue0 := aurora.NewJobKey()
-		err437 := argvalue0.Read(jsProt436)
-		if err437 != nil {
+		err438 := argvalue0.Read(jsProt437)
+		if err438 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg438 := flag.Arg(2)
-		mbTrans439 := thrift.NewTMemoryBufferLen(len(arg438))
-		defer mbTrans439.Close()
-		_, err440 := mbTrans439.WriteString(arg438)
-		if err440 != nil {
+		arg439 := flag.Arg(2)
+		mbTrans440 := thrift.NewTMemoryBufferLen(len(arg439))
+		defer mbTrans440.Close()
+		_, err441 := mbTrans440.WriteString(arg439)
+		if err441 != nil {
 			Usage()
 			return
 		}
-		factory441 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt442 := factory441.GetProtocol(mbTrans439)
+		factory442 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt443 := factory442.GetProtocol(mbTrans440)
 		containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
-		err443 := containerStruct1.ReadField2(jsProt442)
-		if err443 != nil {
+		err444 := containerStruct1.ReadField2(jsProt443)
+		if err444 != nil {
 			Usage()
 			return
 		}
@@ -604,46 +604,48 @@ func main() {
 		fmt.Print("\n")
 		break
 	case "killTasks":
-		if flag.NArg()-1 != 2 {
-			fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
+		if flag.NArg()-1 != 3 {
+			fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
 			flag.Usage()
 		}
-		arg444 := flag.Arg(1)
-		mbTrans445 := thrift.NewTMemoryBufferLen(len(arg444))
-		defer mbTrans445.Close()
-		_, err446 := mbTrans445.WriteString(arg444)
-		if err446 != nil {
+		arg445 := flag.Arg(1)
+		mbTrans446 := thrift.NewTMemoryBufferLen(len(arg445))
+		defer mbTrans446.Close()
+		_, err447 := mbTrans446.WriteString(arg445)
+		if err447 != nil {
 			Usage()
 			return
 		}
-		factory447 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt448 := factory447.GetProtocol(mbTrans445)
+		factory448 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt449 := factory448.GetProtocol(mbTrans446)
 		argvalue0 := aurora.NewJobKey()
-		err449 := argvalue0.Read(jsProt448)
-		if err449 != nil {
+		err450 := argvalue0.Read(jsProt449)
+		if err450 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg450 := flag.Arg(2)
-		mbTrans451 := thrift.NewTMemoryBufferLen(len(arg450))
-		defer mbTrans451.Close()
-		_, err452 := mbTrans451.WriteString(arg450)
-		if err452 != nil {
+		arg451 := flag.Arg(2)
+		mbTrans452 := thrift.NewTMemoryBufferLen(len(arg451))
+		defer mbTrans452.Close()
+		_, err453 := mbTrans452.WriteString(arg451)
+		if err453 != nil {
 			Usage()
 			return
 		}
-		factory453 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt454 := factory453.GetProtocol(mbTrans451)
+		factory454 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt455 := factory454.GetProtocol(mbTrans452)
 		containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
-		err455 := containerStruct1.ReadField2(jsProt454)
-		if err455 != nil {
+		err456 := containerStruct1.ReadField2(jsProt455)
+		if err456 != nil {
 			Usage()
 			return
 		}
 		argvalue1 := containerStruct1.Instances
 		value1 := argvalue1
-		fmt.Print(client.KillTasks(value0, value1))
+		argvalue2 := flag.Arg(3)
+		value2 := argvalue2
+		fmt.Print(client.KillTasks(value0, value1, value2))
 		fmt.Print("\n")
 		break
 	case "addInstances":
@@ -651,25 +653,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg456 := flag.Arg(1)
-		mbTrans457 := thrift.NewTMemoryBufferLen(len(arg456))
-		defer mbTrans457.Close()
-		_, err458 := mbTrans457.WriteString(arg456)
-		if err458 != nil {
+		arg458 := flag.Arg(1)
+		mbTrans459 := thrift.NewTMemoryBufferLen(len(arg458))
+		defer mbTrans459.Close()
+		_, err460 := mbTrans459.WriteString(arg458)
+		if err460 != nil {
 			Usage()
 			return
 		}
-		factory459 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt460 := factory459.GetProtocol(mbTrans457)
+		factory461 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt462 := factory461.GetProtocol(mbTrans459)
 		argvalue0 := aurora.NewInstanceKey()
-		err461 := argvalue0.Read(jsProt460)
-		if err461 != nil {
+		err463 := argvalue0.Read(jsProt462)
+		if err463 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err462 := (strconv.Atoi(flag.Arg(2)))
-		if err462 != nil {
+		tmp1, err464 := (strconv.Atoi(flag.Arg(2)))
+		if err464 != nil {
 			Usage()
 			return
 		}
@@ -683,19 +685,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg463 := flag.Arg(1)
-		mbTrans464 := thrift.NewTMemoryBufferLen(len(arg463))
-		defer mbTrans464.Close()
-		_, err465 := mbTrans464.WriteString(arg463)
-		if err465 != nil {
+		arg465 := flag.Arg(1)
+		mbTrans466 := thrift.NewTMemoryBufferLen(len(arg465))
+		defer mbTrans466.Close()
+		_, err467 := mbTrans466.WriteString(arg465)
+		if err467 != nil {
 			Usage()
 			return
 		}
-		factory466 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt467 := factory466.GetProtocol(mbTrans464)
+		factory468 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt469 := factory468.GetProtocol(mbTrans466)
 		argvalue0 := aurora.NewJobConfiguration()
-		err468 := argvalue0.Read(jsProt467)
-		if err468 != nil {
+		err470 := argvalue0.Read(jsProt469)
+		if err470 != nil {
 			Usage()
 			return
 		}
@@ -708,19 +710,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg469 := flag.Arg(1)
-		mbTrans470 := thrift.NewTMemoryBufferLen(len(arg469))
-		defer mbTrans470.Close()
-		_, err471 := mbTrans470.WriteString(arg469)
-		if err471 != nil {
+		arg471 := flag.Arg(1)
+		mbTrans472 := thrift.NewTMemoryBufferLen(len(arg471))
+		defer mbTrans472.Close()
+		_, err473 := mbTrans472.WriteString(arg471)
+		if err473 != nil {
 			Usage()
 			return
 		}
-		factory472 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt473 := factory472.GetProtocol(mbTrans470)
+		factory474 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt475 := factory474.GetProtocol(mbTrans472)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err474 := argvalue0.Read(jsProt473)
-		if err474 != nil {
+		err476 := argvalue0.Read(jsProt475)
+		if err476 != nil {
 			Usage()
 			return
 		}
@@ -735,19 +737,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg476 := flag.Arg(1)
-		mbTrans477 := thrift.NewTMemoryBufferLen(len(arg476))
-		defer mbTrans477.Close()
-		_, err478 := mbTrans477.WriteString(arg476)
-		if err478 != nil {
+		arg478 := flag.Arg(1)
+		mbTrans479 := thrift.NewTMemoryBufferLen(len(arg478))
+		defer mbTrans479.Close()
+		_, err480 := mbTrans479.WriteString(arg478)
+		if err480 != nil {
 			Usage()
 			return
 		}
-		factory479 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt480 := factory479.GetProtocol(mbTrans477)
+		factory481 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt482 := factory481.GetProtocol(mbTrans479)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err481 := argvalue0.Read(jsProt480)
-		if err481 != nil {
+		err483 := argvalue0.Read(jsProt482)
+		if err483 != nil {
 			Usage()
 			return
 		}
@@ -762,19 +764,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg483 := flag.Arg(1)
-		mbTrans484 := thrift.NewTMemoryBufferLen(len(arg483))
-		defer mbTrans484.Close()
-		_, err485 := mbTrans484.WriteString(arg483)
-		if err485 != nil {
+		arg485 := flag.Arg(1)
+		mbTrans486 := thrift.NewTMemoryBufferLen(len(arg485))
+		defer mbTrans486.Close()
+		_, err487 := mbTrans486.WriteString(arg485)
+		if err487 != nil {
 			Usage()
 			return
 		}
-		factory486 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt487 := factory486.GetProtocol(mbTrans484)
+		factory488 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt489 := factory488.GetProtocol(mbTrans486)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err488 := argvalue0.Read(jsProt487)
-		if err488 != nil {
+		err490 := argvalue0.Read(jsProt489)
+		if err490 != nil {
 			Usage()
 			return
 		}
@@ -789,19 +791,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg490 := flag.Arg(1)
-		mbTrans491 := thrift.NewTMemoryBufferLen(len(arg490))
-		defer mbTrans491.Close()
-		_, err492 := mbTrans491.WriteString(arg490)
-		if err492 != nil {
+		arg492 := flag.Arg(1)
+		mbTrans493 := thrift.NewTMemoryBufferLen(len(arg492))
+		defer mbTrans493.Close()
+		_, err494 := mbTrans493.WriteString(arg492)
+		if err494 != nil {
 			Usage()
 			return
 		}
-		factory493 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt494 := factory493.GetProtocol(mbTrans491)
+		factory495 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt496 := factory495.GetProtocol(mbTrans493)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err495 := argvalue0.Read(jsProt494)
-		if err495 != nil {
+		err497 := argvalue0.Read(jsProt496)
+		if err497 != nil {
 			Usage()
 			return
 		}
@@ -816,19 +818,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg497 := flag.Arg(1)
-		mbTrans498 := thrift.NewTMemoryBufferLen(len(arg497))
-		defer mbTrans498.Close()
-		_, err499 := mbTrans498.WriteString(arg497)
-		if err499 != nil {
+		arg499 := flag.Arg(1)
+		mbTrans500 := thrift.NewTMemoryBufferLen(len(arg499))
+		defer mbTrans500.Close()
+		_, err501 := mbTrans500.WriteString(arg499)
+		if err501 != nil {
 			Usage()
 			return
 		}
-		factory500 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt501 := factory500.GetProtocol(mbTrans498)
+		factory502 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt503 := factory502.GetProtocol(mbTrans500)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err502 := argvalue0.Read(jsProt501)
-		if err502 != nil {
+		err504 := argvalue0.Read(jsProt503)
+		if err504 != nil {
 			Usage()
 			return
 		}
@@ -843,19 +845,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
 			flag.Usage()
 		}
-		arg504 := flag.Arg(1)
-		mbTrans505 := thrift.NewTMemoryBufferLen(len(arg504))
-		defer mbTrans505.Close()
-		_, err506 := mbTrans505.WriteString(arg504)
-		if err506 != nil {
+		arg506 := flag.Arg(1)
+		mbTrans507 := thrift.NewTMemoryBufferLen(len(arg506))
+		defer mbTrans507.Close()
+		_, err508 := mbTrans507.WriteString(arg506)
+		if err508 != nil {
 			Usage()
 			return
 		}
-		factory507 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt508 := factory507.GetProtocol(mbTrans505)
+		factory509 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt510 := factory509.GetProtocol(mbTrans507)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err509 := argvalue0.Read(jsProt508)
-		if err509 != nil {
+		err511 := argvalue0.Read(jsProt510)
+		if err511 != nil {
 			Usage()
 			return
 		}
@@ -886,19 +888,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg511 := flag.Arg(1)
-		mbTrans512 := thrift.NewTMemoryBufferLen(len(arg511))
-		defer mbTrans512.Close()
-		_, err513 := mbTrans512.WriteString(arg511)
-		if err513 != nil {
+		arg513 := flag.Arg(1)
+		mbTrans514 := thrift.NewTMemoryBufferLen(len(arg513))
+		defer mbTrans514.Close()
+		_, err515 := mbTrans514.WriteString(arg513)
+		if err515 != nil {
 			Usage()
 			return
 		}
-		factory514 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt515 := factory514.GetProtocol(mbTrans512)
+		factory516 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt517 := factory516.GetProtocol(mbTrans514)
 		argvalue0 := aurora.NewTaskQuery()
-		err516 := argvalue0.Read(jsProt515)
-		if err516 != nil {
+		err518 := argvalue0.Read(jsProt517)
+		if err518 != nil {
 			Usage()
 			return
 		}
@@ -911,19 +913,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg517 := flag.Arg(1)
-		mbTrans518 := thrift.NewTMemoryBufferLen(len(arg517))
-		defer mbTrans518.Close()
-		_, err519 := mbTrans518.WriteString(arg517)
-		if err519 != nil {
+		arg519 := flag.Arg(1)
+		mbTrans520 := thrift.NewTMemoryBufferLen(len(arg519))
+		defer mbTrans520.Close()
+		_, err521 := mbTrans520.WriteString(arg519)
+		if err521 != nil {
 			Usage()
 			return
 		}
-		factory520 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt521 := factory520.GetProtocol(mbTrans518)
+		factory522 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt523 := factory522.GetProtocol(mbTrans520)
 		argvalue0 := aurora.NewTaskQuery()
-		err522 := argvalue0.Read(jsProt521)
-		if err522 != nil {
+		err524 := argvalue0.Read(jsProt523)
+		if err524 != nil {
 			Usage()
 			return
 		}
@@ -936,19 +938,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg523 := flag.Arg(1)
-		mbTrans524 := thrift.NewTMemoryBufferLen(len(arg523))
-		defer mbTrans524.Close()
-		_, err525 := mbTrans524.WriteString(arg523)
-		if err525 != nil {
+		arg525 := flag.Arg(1)
+		mbTrans526 := thrift.NewTMemoryBufferLen(len(arg525))
+		defer mbTrans526.Close()
+		_, err527 := mbTrans526.WriteString(arg525)
+		if err527 != nil {
 			Usage()
 			return
 		}
-		factory526 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt527 := factory526.GetProtocol(mbTrans524)
+		factory528 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt529 := factory528.GetProtocol(mbTrans526)
 		argvalue0 := aurora.NewTaskQuery()
-		err528 := argvalue0.Read(jsProt527)
-		if err528 != nil {
+		err530 := argvalue0.Read(jsProt529)
+		if err530 != nil {
 			Usage()
 			return
 		}
@@ -961,19 +963,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg529 := flag.Arg(1)
-		mbTrans530 := thrift.NewTMemoryBufferLen(len(arg529))
-		defer mbTrans530.Close()
-		_, err531 := mbTrans530.WriteString(arg529)
-		if err531 != nil {
+		arg531 := flag.Arg(1)
+		mbTrans532 := thrift.NewTMemoryBufferLen(len(arg531))
+		defer mbTrans532.Close()
+		_, err533 := mbTrans532.WriteString(arg531)
+		if err533 != nil {
 			Usage()
 			return
 		}
-		factory532 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt533 := factory532.GetProtocol(mbTrans530)
+		factory534 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt535 := factory534.GetProtocol(mbTrans532)
 		argvalue0 := aurora.NewJobKey()
-		err534 := argvalue0.Read(jsProt533)
-		if err534 != nil {
+		err536 := argvalue0.Read(jsProt535)
+		if err536 != nil {
 			Usage()
 			return
 		}
@@ -1006,19 +1008,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg537 := flag.Arg(1)
-		mbTrans538 := thrift.NewTMemoryBufferLen(len(arg537))
-		defer mbTrans538.Close()
-		_, err539 := mbTrans538.WriteString(arg537)
-		if err539 != nil {
+		arg539 := flag.Arg(1)
+		mbTrans540 := thrift.NewTMemoryBufferLen(len(arg539))
+		defer mbTrans540.Close()
+		_, err541 := mbTrans540.WriteString(arg539)
+		if err541 != nil {
 			Usage()
 			return
 		}
-		factory540 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt541 := factory540.GetProtocol(mbTrans538)
+		factory542 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt543 := factory542.GetProtocol(mbTrans540)
 		argvalue0 := aurora.NewJobConfiguration()
-		err542 := argvalue0.Read(jsProt541)
-		if err542 != nil {
+		err544 := argvalue0.Read(jsProt543)
+		if err544 != nil {
 			Usage()
 			return
 		}
@@ -1031,19 +1033,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg543 := flag.Arg(1)
-		mbTrans544 := thrift.NewTMemoryBufferLen(len(arg543))
-		defer mbTrans544.Close()
-		_, err545 := mbTrans544.WriteString(arg543)
-		if err545 != nil {
+		arg545 := flag.Arg(1)
+		mbTrans546 := thrift.NewTMemoryBufferLen(len(arg545))
+		defer mbTrans546.Close()
+		_, err547 := mbTrans546.WriteString(arg545)
+		if err547 != nil {
 			Usage()
 			return
 		}
-		factory546 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt547 := factory546.GetProtocol(mbTrans544)
+		factory548 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt549 := factory548.GetProtocol(mbTrans546)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err548 := argvalue0.Read(jsProt547)
-		if err548 != nil {
+		err550 := argvalue0.Read(jsProt549)
+		if err550 != nil {
 			Usage()
 			return
 		}
@@ -1056,19 +1058,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg549 := flag.Arg(1)
-		mbTrans550 := thrift.NewTMemoryBufferLen(len(arg549))
-		defer mbTrans550.Close()
-		_, err551 := mbTrans550.WriteString(arg549)
-		if err551 != nil {
+		arg551 := flag.Arg(1)
+		mbTrans552 := thrift.NewTMemoryBufferLen(len(arg551))
+		defer mbTrans552.Close()
+		_, err553 := mbTrans552.WriteString(arg551)
+		if err553 != nil {
 			Usage()
 			return
 		}
-		factory552 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt553 := factory552.GetProtocol(mbTrans550)
+		factory554 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt555 := factory554.GetProtocol(mbTrans552)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err554 := argvalue0.Read(jsProt553)
-		if err554 != nil {
+		err556 := argvalue0.Read(jsProt555)
+		if err556 != nil {
 			Usage()
 			return
 		}
@@ -1081,19 +1083,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg555 := flag.Arg(1)
-		mbTrans556 := thrift.NewTMemoryBufferLen(len(arg555))
-		defer mbTrans556.Close()
-		_, err557 := mbTrans556.WriteString(arg555)
-		if err557 != nil {
+		arg557 := flag.Arg(1)
+		mbTrans558 := thrift.NewTMemoryBufferLen(len(arg557))
+		defer mbTrans558.Close()
+		_, err559 := mbTrans558.WriteString(arg557)
+		if err559 != nil {
 			Usage()
 			return
 		}
-		factory558 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt559 := factory558.GetProtocol(mbTrans556)
+		factory560 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt561 := factory560.GetProtocol(mbTrans558)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err560 := argvalue0.Read(jsProt559)
-		if err560 != nil {
+		err562 := argvalue0.Read(jsProt561)
+		if err562 != nil {
 			Usage()
 			return
 		}

gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go

@@ -25,7 +25,7 @@ func Usage() {
 	fmt.Fprintln(os.Stderr, "  Response descheduleCronJob(JobKey job)")
 	fmt.Fprintln(os.Stderr, "  Response startCronJob(JobKey job)")
 	fmt.Fprintln(os.Stderr, "  Response restartShards(JobKey job,  shardIds)")
-	fmt.Fprintln(os.Stderr, "  Response killTasks(JobKey job,  instances)")
+	fmt.Fprintln(os.Stderr, "  Response killTasks(JobKey job,  instances, string message)")
 	fmt.Fprintln(os.Stderr, "  Response addInstances(InstanceKey key, i32 count)")
 	fmt.Fprintln(os.Stderr, "  Response replaceCronTemplate(JobConfiguration config)")
 	fmt.Fprintln(os.Stderr, "  Response startJobUpdate(JobUpdateRequest request, string message)")
@@ -285,8 +285,8 @@ func main() {
 		fmt.Print("\n")
 		break
 	case "killTasks":
-		if flag.NArg()-1 != 2 {
-			fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
+		if flag.NArg()-1 != 3 {
+			fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
 			flag.Usage()
 		}
 		arg199 := flag.Arg(1)
@@ -324,7 +324,9 @@ func main() {
 		}
 		argvalue1 := containerStruct1.Instances
 		value1 := argvalue1
-		fmt.Print(client.KillTasks(value0, value1))
+		argvalue2 := flag.Arg(3)
+		value2 := argvalue2
+		fmt.Print(client.KillTasks(value0, value1, value2))
 		fmt.Print("\n")
 		break
 	case "addInstances":
@@ -332,25 +334,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg211 := flag.Arg(1)
-		mbTrans212 := thrift.NewTMemoryBufferLen(len(arg211))
-		defer mbTrans212.Close()
-		_, err213 := mbTrans212.WriteString(arg211)
-		if err213 != nil {
+		arg212 := flag.Arg(1)
+		mbTrans213 := thrift.NewTMemoryBufferLen(len(arg212))
+		defer mbTrans213.Close()
+		_, err214 := mbTrans213.WriteString(arg212)
+		if err214 != nil {
 			Usage()
 			return
 		}
-		factory214 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt215 := factory214.GetProtocol(mbTrans212)
+		factory215 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt216 := factory215.GetProtocol(mbTrans213)
 		argvalue0 := aurora.NewInstanceKey()
-		err216 := argvalue0.Read(jsProt215)
-		if err216 != nil {
+		err217 := argvalue0.Read(jsProt216)
+		if err217 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err217 := (strconv.Atoi(flag.Arg(2)))
-		if err217 != nil {
+		tmp1, err218 := (strconv.Atoi(flag.Arg(2)))
+		if err218 != nil {
 			Usage()
 			return
 		}
@@ -364,19 +366,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg218 := flag.Arg(1)
-		mbTrans219 := thrift.NewTMemoryBufferLen(len(arg218))
-		defer mbTrans219.Close()
-		_, err220 := mbTrans219.WriteString(arg218)
-		if err220 != nil {
+		arg219 := flag.Arg(1)
+		mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
+		defer mbTrans220.Close()
+		_, err221 := mbTrans220.WriteString(arg219)
+		if err221 != nil {
 			Usage()
 			return
 		}
-		factory221 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt222 := factory221.GetProtocol(mbTrans219)
+		factory222 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt223 := factory222.GetProtocol(mbTrans220)
 		argvalue0 := aurora.NewJobConfiguration()
-		err223 := argvalue0.Read(jsProt222)
-		if err223 != nil {
+		err224 := argvalue0.Read(jsProt223)
+		if err224 != nil {
 			Usage()
 			return
 		}
@@ -389,19 +391,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg224 := flag.Arg(1)
-		mbTrans225 := thrift.NewTMemoryBufferLen(len(arg224))
-		defer mbTrans225.Close()
-		_, err226 := mbTrans225.WriteString(arg224)
-		if err226 != nil {
+		arg225 := flag.Arg(1)
+		mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
+		defer mbTrans226.Close()
+		_, err227 := mbTrans226.WriteString(arg225)
+		if err227 != nil {
 			Usage()
 			return
 		}
-		factory227 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt228 := factory227.GetProtocol(mbTrans225)
+		factory228 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt229 := factory228.GetProtocol(mbTrans226)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err229 := argvalue0.Read(jsProt228)
-		if err229 != nil {
+		err230 := argvalue0.Read(jsProt229)
+		if err230 != nil {
 			Usage()
 			return
 		}
@@ -416,19 +418,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg231 := flag.Arg(1)
-		mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
-		defer mbTrans232.Close()
-		_, err233 := mbTrans232.WriteString(arg231)
-		if err233 != nil {
+		arg232 := flag.Arg(1)
+		mbTrans233 := thrift.NewTMemoryBufferLen(len(arg232))
+		defer mbTrans233.Close()
+		_, err234 := mbTrans233.WriteString(arg232)
+		if err234 != nil {
 			Usage()
 			return
 		}
-		factory234 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt235 := factory234.GetProtocol(mbTrans232)
+		factory235 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt236 := factory235.GetProtocol(mbTrans233)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err236 := argvalue0.Read(jsProt235)
-		if err236 != nil {
+		err237 := argvalue0.Read(jsProt236)
+		if err237 != nil {
 			Usage()
 			return
 		}
@@ -443,19 +445,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg238 := flag.Arg(1)
-		mbTrans239 := thrift.NewTMemoryBufferLen(len(arg238))
-		defer mbTrans239.Close()
-		_, err240 := mbTrans239.WriteString(arg238)
-		if err240 != nil {
+		arg239 := flag.Arg(1)
+		mbTrans240 := thrift.NewTMemoryBufferLen(len(arg239))
+		defer mbTrans240.Close()
+		_, err241 := mbTrans240.WriteString(arg239)
+		if err241 != nil {
 			Usage()
 			return
 		}
-		factory241 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt242 := factory241.GetProtocol(mbTrans239)
+		factory242 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt243 := factory242.GetProtocol(mbTrans240)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err243 := argvalue0.Read(jsProt242)
-		if err243 != nil {
+		err244 := argvalue0.Read(jsProt243)
+		if err244 != nil {
 			Usage()
 			return
 		}
@@ -470,19 +472,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg245 := flag.Arg(1)
-		mbTrans246 := thrift.NewTMemoryBufferLen(len(arg245))
-		defer mbTrans246.Close()
-		_, err247 := mbTrans246.WriteString(arg245)
-		if err247 != nil {
+		arg246 := flag.Arg(1)
+		mbTrans247 := thrift.NewTMemoryBufferLen(len(arg246))
+		defer mbTrans247.Close()
+		_, err248 := mbTrans247.WriteString(arg246)
+		if err248 != nil {
 			Usage()
 			return
 		}
-		factory248 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt249 := factory248.GetProtocol(mbTrans246)
+		factory249 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt250 := factory249.GetProtocol(mbTrans247)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err250 := argvalue0.Read(jsProt249)
-		if err250 != nil {
+		err251 := argvalue0.Read(jsProt250)
+		if err251 != nil {
 			Usage()
 			return
 		}
@@ -497,19 +499,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg252 := flag.Arg(1)
-		mbTrans253 := thrift.NewTMemoryBufferLen(len(arg252))
-		defer mbTrans253.Close()
-		_, err254 := mbTrans253.WriteString(arg252)
-		if err254 != nil {
+		arg253 := flag.Arg(1)
+		mbTrans254 := thrift.NewTMemoryBufferLen(len(arg253))
+		defer mbTrans254.Close()
+		_, err255 := mbTrans254.WriteString(arg253)
+		if err255 != nil {
 			Usage()
 			return
 		}
-		factory255 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt256 := factory255.GetProtocol(mbTrans253)
+		factory256 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt257 := factory256.GetProtocol(mbTrans254)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err257 := argvalue0.Read(jsProt256)
-		if err257 != nil {
+		err258 := argvalue0.Read(jsProt257)
+		if err258 != nil {
 			Usage()
 			return
 		}
@@ -524,19 +526,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
 			flag.Usage()
 		}
-		arg259 := flag.Arg(1)
-		mbTrans260 := thrift.NewTMemoryBufferLen(len(arg259))
-		defer mbTrans260.Close()
-		_, err261 := mbTrans260.WriteString(arg259)
-		if err261 != nil {
+		arg260 := flag.Arg(1)
+		mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
+		defer mbTrans261.Close()
+		_, err262 := mbTrans261.WriteString(arg260)
+		if err262 != nil {
 			Usage()
 			return
 		}
-		factory262 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt263 := factory262.GetProtocol(mbTrans260)
+		factory263 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt264 := factory263.GetProtocol(mbTrans261)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err264 := argvalue0.Read(jsProt263)
-		if err264 != nil {
+		err265 := argvalue0.Read(jsProt264)
+		if err265 != nil {
 			Usage()
 			return
 		}
@@ -567,19 +569,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg266 := flag.Arg(1)
-		mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
-		defer mbTrans267.Close()
-		_, err268 := mbTrans267.WriteString(arg266)
-		if err268 != nil {
+		arg267 := flag.Arg(1)
+		mbTrans268 := thrift.NewTMemoryBufferLen(len(arg267))
+		defer mbTrans268.Close()
+		_, err269 := mbTrans268.WriteString(arg267)
+		if err269 != nil {
 			Usage()
 			return
 		}
-		factory269 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt270 := factory269.GetProtocol(mbTrans267)
+		factory270 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt271 := factory270.GetProtocol(mbTrans268)
 		argvalue0 := aurora.NewTaskQuery()
-		err271 := argvalue0.Read(jsProt270)
-		if err271 != nil {
+		err272 := argvalue0.Read(jsProt271)
+		if err272 != nil {
 			Usage()
 			return
 		}
@@ -592,19 +594,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg272 := flag.Arg(1)
-		mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
-		defer mbTrans273.Close()
-		_, err274 := mbTrans273.WriteString(arg272)
-		if err274 != nil {
+		arg273 := flag.Arg(1)
+		mbTrans274 := thrift.NewTMemoryBufferLen(len(arg273))
+		defer mbTrans274.Close()
+		_, err275 := mbTrans274.WriteString(arg273)
+		if err275 != nil {
 			Usage()
 			return
 		}
-		factory275 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt276 := factory275.GetProtocol(mbTrans273)
+		factory276 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt277 := factory276.GetProtocol(mbTrans274)
 		argvalue0 := aurora.NewTaskQuery()
-		err277 := argvalue0.Read(jsProt276)
-		if err277 != nil {
+		err278 := argvalue0.Read(jsProt277)
+		if err278 != nil {
 			Usage()
 			return
 		}
@@ -617,19 +619,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg278 := flag.Arg(1)
-		mbTrans279 := thrift.NewTMemoryBufferLen(len(arg278))
-		defer mbTrans279.Close()
-		_, err280 := mbTrans279.WriteString(arg278)
-		if err280 != nil {
+		arg279 := flag.Arg(1)
+		mbTrans280 := thrift.NewTMemoryBufferLen(len(arg279))
+		defer mbTrans280.Close()
+		_, err281 := mbTrans280.WriteString(arg279)
+		if err281 != nil {
 			Usage()
 			return
 		}
-		factory281 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt282 := factory281.GetProtocol(mbTrans279)
+		factory282 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt283 := factory282.GetProtocol(mbTrans280)
 		argvalue0 := aurora.NewTaskQuery()
-		err283 := argvalue0.Read(jsProt282)
-		if err283 != nil {
+		err284 := argvalue0.Read(jsProt283)
+		if err284 != nil {
 			Usage()
 			return
 		}
@@ -642,19 +644,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg284 := flag.Arg(1)
-		mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
-		defer mbTrans285.Close()
-		_, err286 := mbTrans285.WriteString(arg284)
-		if err286 != nil {
+		arg285 := flag.Arg(1)
+		mbTrans286 := thrift.NewTMemoryBufferLen(len(arg285))
+		defer mbTrans286.Close()
+		_, err287 := mbTrans286.WriteString(arg285)
+		if err287 != nil {
 			Usage()
 			return
 		}
-		factory287 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt288 := factory287.GetProtocol(mbTrans285)
+		factory288 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt289 := factory288.GetProtocol(mbTrans286)
 		argvalue0 := aurora.NewJobKey()
-		err289 := argvalue0.Read(jsProt288)
-		if err289 != nil {
+		err290 := argvalue0.Read(jsProt289)
+		if err290 != nil {
 			Usage()
 			return
 		}
@@ -687,19 +689,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg292 := flag.Arg(1)
-		mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
-		defer mbTrans293.Close()
-		_, err294 := mbTrans293.WriteString(arg292)
-		if err294 != nil {
+		arg293 := flag.Arg(1)
+		mbTrans294 := thrift.NewTMemoryBufferLen(len(arg293))
+		defer mbTrans294.Close()
+		_, err295 := mbTrans294.WriteString(arg293)
+		if err295 != nil {
 			Usage()
 			return
 		}
-		factory295 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt296 := factory295.GetProtocol(mbTrans293)
+		factory296 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt297 := factory296.GetProtocol(mbTrans294)
 		argvalue0 := aurora.NewJobConfiguration()
-		err297 := argvalue0.Read(jsProt296)
-		if err297 != nil {
+		err298 := argvalue0.Read(jsProt297)
+		if err298 != nil {
 			Usage()
 			return
 		}
@@ -712,19 +714,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg298 := flag.Arg(1)
-		mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
-		defer mbTrans299.Close()
-		_, err300 := mbTrans299.WriteString(arg298)
-		if err300 != nil {
+		arg299 := flag.Arg(1)
+		mbTrans300 := thrift.NewTMemoryBufferLen(len(arg299))
+		defer mbTrans300.Close()
+		_, err301 := mbTrans300.WriteString(arg299)
+		if err301 != nil {
 			Usage()
 			return
 		}
-		factory301 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt302 := factory301.GetProtocol(mbTrans299)
+		factory302 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt303 := factory302.GetProtocol(mbTrans300)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err303 := argvalue0.Read(jsProt302)
-		if err303 != nil {
+		err304 := argvalue0.Read(jsProt303)
+		if err304 != nil {
 			Usage()
 			return
 		}
@@ -737,19 +739,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg304 := flag.Arg(1)
-		mbTrans305 := thrift.NewTMemoryBufferLen(len(arg304))
-		defer mbTrans305.Close()
-		_, err306 := mbTrans305.WriteString(arg304)
-		if err306 != nil {
+		arg305 := flag.Arg(1)
+		mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
+		defer mbTrans306.Close()
+		_, err307 := mbTrans306.WriteString(arg305)
+		if err307 != nil {
 			Usage()
 			return
 		}
-		factory307 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt308 := factory307.GetProtocol(mbTrans305)
+		factory308 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt309 := factory308.GetProtocol(mbTrans306)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err309 := argvalue0.Read(jsProt308)
-		if err309 != nil {
+		err310 := argvalue0.Read(jsProt309)
+		if err310 != nil {
 			Usage()
 			return
 		}
@@ -762,19 +764,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg310 := flag.Arg(1)
-		mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
-		defer mbTrans311.Close()
-		_, err312 := mbTrans311.WriteString(arg310)
-		if err312 != nil {
+		arg311 := flag.Arg(1)
+		mbTrans312 := thrift.NewTMemoryBufferLen(len(arg311))
+		defer mbTrans312.Close()
+		_, err313 := mbTrans312.WriteString(arg311)
+		if err313 != nil {
 			Usage()
 			return
 		}
-		factory313 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt314 := factory313.GetProtocol(mbTrans311)
+		factory314 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt315 := factory314.GetProtocol(mbTrans312)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err315 := argvalue0.Read(jsProt314)
-		if err315 != nil {
+		err316 := argvalue0.Read(jsProt315)
+		if err316 != nil {
 			Usage()
 			return
 		}

gen-go/apache/aurora/auroraschedulermanager.go

@@ -53,7 +53,8 @@ type AuroraSchedulerManager interface {
 	// Parameters:
 	//  - Job
 	//  - Instances
-	KillTasks(job *JobKey, instances map[int32]bool) (r *Response, err error)
+	//  - Message
+	KillTasks(job *JobKey, instances map[int32]bool, message string) (r *Response, err error)
 	// Adds new instances with the TaskConfig of the existing instance pointed by the key.
 	//
 	// Parameters:
@@ -524,14 +525,15 @@ func (p *AuroraSchedulerManagerClient) recvRestartShards() (value *Response, err
 // Parameters:
 //  - Job
 //  - Instances
-func (p *AuroraSchedulerManagerClient) KillTasks(job *JobKey, instances map[int32]bool) (r *Response, err error) {
-	if err = p.sendKillTasks(job, instances); err != nil {
+//  - Message
+func (p *AuroraSchedulerManagerClient) KillTasks(job *JobKey, instances map[int32]bool, message string) (r *Response, err error) {
+	if err = p.sendKillTasks(job, instances, message); err != nil {
 		return
 	}
 	return p.recvKillTasks()
 }
 
-func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[int32]bool) (err error) {
+func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[int32]bool, message string) (err error) {
 	oprot := p.OutputProtocol
 	if oprot == nil {
 		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
@@ -544,6 +546,7 @@ func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[
 	args := AuroraSchedulerManagerKillTasksArgs{
 		Job:       job,
 		Instances: instances,
+		Message:   message,
 	}
 	if err = args.Write(oprot); err != nil {
 		return
@@ -1530,7 +1533,7 @@ func (p *auroraSchedulerManagerProcessorKillTasks) Process(seqId int32, iprot, o
 	result := AuroraSchedulerManagerKillTasksResult{}
 	var retval *Response
 	var err2 error
-	if retval, err2 = p.handler.KillTasks(args.Job, args.Instances); err2 != nil {
+	if retval, err2 = p.handler.KillTasks(args.Job, args.Instances, args.Message); err2 != nil {
 		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing killTasks: "+err2.Error())
 		oprot.WriteMessageBegin("killTasks", thrift.EXCEPTION, seqId)
 		x.Write(oprot)
@@ -3007,10 +3010,12 @@ func (p *AuroraSchedulerManagerRestartShardsResult) String() string {
 // Attributes:
 //  - Job
 //  - Instances
+//  - Message
 type AuroraSchedulerManagerKillTasksArgs struct {
 	// unused fields # 1 to 3
 	Job       *JobKey        `thrift:"job,4" json:"job"`
 	Instances map[int32]bool `thrift:"instances,5" json:"instances"`
+	Message   string         `thrift:"message,6" json:"message"`
 }
 
 func NewAuroraSchedulerManagerKillTasksArgs() *AuroraSchedulerManagerKillTasksArgs {
@@ -3029,6 +3034,10 @@ func (p *AuroraSchedulerManagerKillTasksArgs) GetJob() *JobKey {
 func (p *AuroraSchedulerManagerKillTasksArgs) GetInstances() map[int32]bool {
 	return p.Instances
 }
+
+func (p *AuroraSchedulerManagerKillTasksArgs) GetMessage() string {
+	return p.Message
+}
 func (p *AuroraSchedulerManagerKillTasksArgs) IsSetJob() bool {
 	return p.Job != nil
 }
@@ -3055,6 +3064,10 @@ func (p *AuroraSchedulerManagerKillTasksArgs) Read(iprot thrift.TProtocol) error
 			if err := p.readField5(iprot); err != nil {
 				return err
 			}
+		case 6:
+			if err := p.readField6(iprot); err != nil {
+				return err
+			}
 		default:
 			if err := iprot.Skip(fieldTypeId); err != nil {
 				return err
@@ -3100,6 +3113,15 @@ func (p *AuroraSchedulerManagerKillTasksArgs) readField5(iprot thrift.TProtocol)
 	return nil
 }
 
+func (p *AuroraSchedulerManagerKillTasksArgs) readField6(iprot thrift.TProtocol) error {
+	if v, err := iprot.ReadString(); err != nil {
+		return thrift.PrependError("error reading field 6: ", err)
+	} else {
+		p.Message = v
+	}
+	return nil
+}
+
 func (p *AuroraSchedulerManagerKillTasksArgs) Write(oprot thrift.TProtocol) error {
 	if err := oprot.WriteStructBegin("killTasks_args"); err != nil {
 		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
@@ -3110,6 +3132,9 @@ func (p *AuroraSchedulerManagerKillTasksArgs) Write(oprot thrift.TProtocol) erro
 	if err := p.writeField5(oprot); err != nil {
 		return err
 	}
+	if err := p.writeField6(oprot); err != nil {
+		return err
+	}
 	if err := oprot.WriteFieldStop(); err != nil {
 		return thrift.PrependError("write field stop error: ", err)
 	}
@@ -3153,6 +3178,19 @@ func (p *AuroraSchedulerManagerKillTasksArgs) writeField5(oprot thrift.TProtocol
 	return err
 }
 
+func (p *AuroraSchedulerManagerKillTasksArgs) writeField6(oprot thrift.TProtocol) (err error) {
+	if err := oprot.WriteFieldBegin("message", thrift.STRING, 6); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:message: ", p), err)
+	}
+	if err := oprot.WriteString(string(p.Message)); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T.message (6) field write error: ", p), err)
+	}
+	if err := oprot.WriteFieldEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field end error 6:message: ", p), err)
+	}
+	return err
+}
+
 func (p *AuroraSchedulerManagerKillTasksArgs) String() string {
 	if p == nil {
 		return "<nil>"

gen-go/apache/aurora/constants.go

@@ -26,6 +26,7 @@ const GOOD_IDENTIFIER_PATTERN_JVM = "^[\\w\\-\\.]+$"
 const GOOD_IDENTIFIER_PATTERN_PYTHON = "^[\\w\\-\\.]+$"
 
 var ACTIVE_JOB_UPDATE_STATES map[JobUpdateStatus]bool
+var AWAITNG_PULSE_JOB_UPDATE_STATES map[JobUpdateStatus]bool
 
 const BYPASS_LEADER_REDIRECT_HEADER_NAME = "Bypass-Leader-Redirect"
 const TASK_FILESYSTEM_MOUNT_POINT = "taskfs"
@@ -77,4 +78,9 @@ func init() {
 		10: true,
 	}
 
+	AWAITNG_PULSE_JOB_UPDATE_STATES = map[JobUpdateStatus]bool{
+		9:  true,
+		10: true,
+	}
+
 }

realis.go

@@ -267,7 +267,7 @@ func NewRealisClient(options ...ClientOption) (Realis, error) {
 		config.protoFactory = thrift.NewTBinaryProtocolFactoryDefault()
 	}
 
-	config.logger.Printf("gorealis config url: %+v\n", config.url)
+	config.logger.Printf("gorealis config url: %+v\n", url)
 
 	//Basic Authentication.
 	if config.username != "" && config.password != "" {
@@ -579,7 +579,7 @@ func (r *realisClient) KillInstances(key *aurora.JobKey, instances ...int32) (*a
 
 	retryErr := ExponentialBackoff(*r.config.backoff, func() (bool, error) {
 		resp, clientErr = CheckAndRetryConn(r, func() (*aurora.Response, error) {
-			return r.client.KillTasks(key, instanceIds)
+			return r.client.KillTasks(key, instanceIds, "")
 		})
 		if clientErr != nil && clientErr.Error() == RetryConnErr.Error() {
 			return false, nil
@@ -614,7 +614,7 @@ func (r *realisClient) KillJob(key *aurora.JobKey) (*aurora.Response, error) {
 	if len(instanceIds) > 0 {
 		retryErr := ExponentialBackoff(*r.config.backoff, func() (bool, error) {
 			resp, clientErr = CheckAndRetryConn(r, func() (*aurora.Response, error) {
-				return r.client.KillTasks(key, instanceIds)
+				return r.client.KillTasks(key, instanceIds, "")
 			})
 			if clientErr != nil && clientErr.Error() == RetryConnErr.Error() {
 				return false, nil