Updated thrift API to the latest in the Aurora respository.

Added new monitors for watching number of instances get to a certain count using polling. Added new commands to sample client which give some statistics.
2016-08-26 16:35:31 -07:00 · 2016-08-26 16:35:31 -07:00 · 928fc42fc2
commit 928fc42fc2
parent 01b700554a
12 changed files with 1182 additions and 668 deletions
--- a/auroraAPI.thrift
+++ b/auroraAPI.thrift
@ -14,7 +14,6 @@

 namespace java org.apache.aurora.gen
 namespace py gen.apache.aurora.api
-namespace go gen.apache.aurora

 // Thrift interface definition for the aurora scheduler.

@ -260,12 +259,12 @@ struct TaskConfig {
 30: optional string tier
 /** All resources required to run a task. */
 32: set<Resource> resources
- /** Resources to retrieve with Mesos Fetcher */
- 33: optional set<MesosFetcherURI> mesosFetcherUris

 20: set<Constraint> constraints
 /** a list of named ports this task requests */
 21: set<string> requestedPorts
+ /** Resources to retrieve with Mesos Fetcher */
+ 33: optional set<MesosFetcherURI> mesosFetcherUris
 /**
  * Custom links to include when displaying this task on the scheduler dashboard. Keys are anchor
  * text, values are URLs. Wildcards are supported for dynamic link crafting based on host, ports,
@ -1107,6 +1106,15 @@ service AuroraSchedulerManager extends ReadOnlyScheduler {
      /** A user-specified message to include with the induced job update state change. */
      3: string message)

+  /**
+   * Rollbacks the specified active job update to the initial state.
+   */
+  Response rollbackJobUpdate(
+      /** The update to rollback. */
+      1: JobUpdateKey key,
+      /** A user-specified message to include with the induced job update state change. */
+      2: string message)
+
  /**
   * Allows progress of the job update in case blockIfNoPulsesAfterMs is specified in
   * JobUpdateSettings. Unblocks progress if the update was previously blocked.
@ -1203,3 +1211,7 @@ service AuroraAdmin extends AuroraSchedulerManager {

 // The name of the header that should be sent to bypass leader redirection in the Scheduler.
 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'
--- a/examples/client.go
+++ b/examples/client.go
@ -24,8 +24,8 @@ import (
 	"github.com/rdelval/gorealis/response"
 )

-func main() {

+func main() {
 	cmd := flag.String("cmd", "", "Job request type to send to Aurora Scheduler")
 	executor := flag.String("executor", "thermos", "Executor to use")
 	url := flag.String("url", "", "URL at which the Aurora Scheduler exists as [url]:[port]")
@ -69,6 +69,7 @@ func main() {
 	r := realis.NewClient(config)
 	defer r.Close()

+	monitor := &realis.Monitor{r}
 	var job realis.Job

 	switch *executor {
@ -121,8 +122,17 @@ func main() {
 			fmt.Println(err)
 			os.Exit(1)
 		}
-
 		fmt.Println(resp.String())
+
+		if(resp.ResponseCode == aurora.ResponseCode_OK) {
+			if(!monitor.Instances(job.JobKey(), job.GetInstanceCount(), 5, 10)) {
+				_, err := r.KillJob(job.JobKey())
+				if err != nil {
+					fmt.Println(err)
+					os.Exit(1)
+				}
+			}
+		}
 		break
 	case "kill":
 		fmt.Println("Killing job")
@ -133,6 +143,12 @@ func main() {
 			os.Exit(1)
 		}

+		if(resp.ResponseCode == aurora.ResponseCode_OK) {
+			if(!monitor.Instances(job.JobKey(), 0, 5, 10)) {
+				fmt.Println("Unable to kill all instances of job")
+				os.Exit(1)
+			}
+		}
 		fmt.Println(resp.String())
 		break
 	case "restart":
@ -145,13 +161,43 @@ func main() {

 		fmt.Println(resp.String())
 		break
-	case "flexUp":
-		fmt.Println("Flexing up job")
-		resp, err := r.AddInstances(aurora.InstanceKey{job.JobKey(), 0}, 5)
+	case "liveCount":
+		fmt.Println("Getting instance count")
+
+		live, err := r.GetInstanceIds(job.JobKey(), aurora.LIVE_STATES)
 		if err != nil {
 			fmt.Println(err)
 			os.Exit(1)
 		}
+
+		fmt.Println("Number of live instances: ", len(live))
+		break
+	case "activeCount":
+		fmt.Println("Getting instance count")
+
+		live, err := r.GetInstanceIds(job.JobKey(), aurora.ACTIVE_STATES)
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+
+		fmt.Println("Number of live instances: ", live)
+		break
+	case "flexUp":
+		fmt.Println("Flexing up job")
+
+		numOfInstances := int32(5)
+		resp, err := r.AddInstances(aurora.InstanceKey{job.JobKey(), 0}, numOfInstances)
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+
+		if(resp.ResponseCode == aurora.ResponseCode_OK) {
+			if(!monitor.Instances(job.JobKey(), job.GetInstanceCount()+numOfInstances, 5, 10)) {
+				fmt.Println("Flexing up failed")
+			}
+		}
 		fmt.Println(resp.String())
 		break
 	case "update":
@ -162,7 +208,7 @@ func main() {
 			os.Exit(1)
 		}
 		updateJob := realis.NewUpdateJob(taskConfig)
-		updateJob.InstanceCount(3).RAM(128)
+		updateJob.InstanceCount(5).RAM(128)

 		resp, err := r.StartJobUpdate(updateJob, "")
 		if err != nil {
@ -171,7 +217,7 @@ func main() {
 		}

 		jobUpdateKey := response.JobUpdateKey(resp)
-		r.MonitorJobUpdate(*jobUpdateKey, 5, 100)
+		monitor.JobUpdate(*jobUpdateKey, 5, 100)

 		break
 	case "updateDetails":
--- a/job.go
+++ b/job.go
@ -40,6 +40,7 @@ type Job interface {
 	TaskConfig() *aurora.TaskConfig
 	IsService(isService bool) Job
 	InstanceCount(instCount int32) Job
+	GetInstanceCount() int32
 	MaxFailure(maxFail int32) Job
 }

@ -155,6 +156,11 @@ func (j AuroraJob) InstanceCount(instCount int32) Job {
 	return j
 }

+// How many instances of the job to run
+func (j AuroraJob) GetInstanceCount() int32 {
+	return j.jobConfig.InstanceCount
+}
+
 // Restart the job's tasks if they fail
 func (j AuroraJob) IsService(isService bool) Job {
 	j.jobConfig.TaskConfig.IsService = isService
--- a/monitors.go
+++ b/monitors.go
@ -16,18 +16,22 @@
 package realis

 import (
-	"gen-go/apache/aurora"
 	"fmt"
-	"os"
+	"gen-go/apache/aurora"
 	"github.com/rdelval/gorealis/response"
+	"os"
 	"time"
 )

-// Polls the scheduler every certain amount of time to see if the update has succeeded
-func (r realisClient) MonitorJobUpdate(updateKey aurora.JobUpdateKey, interval int, timeout int) bool {
+type Monitor struct {
+	Client Realis
+}

-	for i:= 0; i*interval <= timeout; i++ {
-		respDetail, err := r.JobUpdateDetails(updateKey)
+// Polls the scheduler every certain amount of time to see if the update has succeeded
+func (m *Monitor) JobUpdate(updateKey aurora.JobUpdateKey, interval int, timeout int) bool {
+
+	for i := 0; i*interval <= timeout; i++ {
+		respDetail, err := m.Client.JobUpdateDetails(updateKey)
 		if err != nil {
 			fmt.Println(err)
 			os.Exit(1)
@ -35,19 +39,18 @@ func (r realisClient) MonitorJobUpdate(updateKey aurora.JobUpdateKey, interval i

 		updateDetail := response.JobUpdateDetails(respDetail)

-		// Iterate through the history of the events available
-		for _, detail := range updateDetail.UpdateEvents {
-			if _, ok := aurora.ACTIVE_JOB_UPDATE_STATES[detail.Status]; !ok {
+		status := updateDetail.Update.Summary.State.Status

-				// Rolled forward is the only state in which an update has been successfully updated
-				// if we encounter an inactive state and it is not at rolled forward, update failed
-				if detail.Status == aurora.JobUpdateStatus_ROLLED_FORWARD {
-					fmt.Println("Update succeded")
-					return true
-				} else {
-					fmt.Println("Update failed")
-					return false
-				}
+		if _, ok := aurora.ACTIVE_JOB_UPDATE_STATES[status]; !ok {
+
+			// Rolled forward is the only state in which an update has been successfully updated
+			// if we encounter an inactive state and it is not at rolled forward, update failed
+			if status == aurora.JobUpdateStatus_ROLLED_FORWARD {
+				fmt.Println("Update succeded")
+				return true
+			} else {
+				fmt.Println("Update failed")
+				return false
 			}
 		}

@ -55,6 +58,29 @@ func (r realisClient) MonitorJobUpdate(updateKey aurora.JobUpdateKey, interval i
 		time.Sleep(time.Duration(interval) * time.Second)
 	}

+	fmt.Println("Timed out")
+	return false
+}
+
+
+func (m *Monitor) Instances(key *aurora.JobKey, instances int32, interval int, timeout int) bool {
+
+	for i := 0; i*interval <= timeout; i++ {
+
+		live, err := m.Client.GetInstanceIds(key, aurora.LIVE_STATES)
+
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+
+		if(len(live) == int(instances)){
+			return true
+		}
+
+		fmt.Println("Polling, instances running: ", len(live))
+		time.Sleep(time.Duration(interval) * time.Second)
+	}

 	fmt.Println("Timed out")
 	return false
--- a/realis.go
+++ b/realis.go
@ -32,10 +32,10 @@ type Realis interface {
 	AddInstances(instKey aurora.InstanceKey, count int32) (*aurora.Response, error)
 	CreateJob(auroraJob Job) (*aurora.Response, error)
 	FetchTaskConfig(instKey aurora.InstanceKey) (*aurora.TaskConfig, error)
+    GetInstanceIds(key *aurora.JobKey, states map[aurora.ScheduleStatus]bool) (map[int32]bool, error)
 	JobUpdateDetails(updateKey aurora.JobUpdateKey) (*aurora.Response, error)
 	KillJob(key *aurora.JobKey) (*aurora.Response, error)
 	KillInstances(key *aurora.JobKey, instances ...int32) (*aurora.Response, error)
-	MonitorJobUpdate(updateKey aurora.JobUpdateKey, interval int, timeout int) bool
 	RestartInstances(key *aurora.JobKey, instances ...int32) (*aurora.Response, error)
 	RestartJob(key *aurora.JobKey) (*aurora.Response, error)
 	StartJobUpdate(updateJob *UpdateJob, message string) (*aurora.Response, error)
@ -105,11 +105,11 @@ func (r realisClient) Close() {
 }

 // Uses predefined set of states to retrieve a set of active jobs in Apache Aurora.
-func (r realisClient) getActiveInstanceIds(key *aurora.JobKey) (map[int32]bool, error) {
+func (r realisClient) GetInstanceIds(key *aurora.JobKey, states map[aurora.ScheduleStatus]bool) (map[int32]bool, error) {
 	taskQ := &aurora.TaskQuery{Role: key.Role,
 		Environment: key.Environment,
 		JobName:     key.Name,
-		Statuses:    aurora.ACTIVE_STATES}
+		Statuses:    states}

 	response, err := r.client.GetTasksWithoutConfigs(taskQ)
 	if err != nil {
@ -146,7 +146,7 @@ func (r realisClient) KillInstances(key *aurora.JobKey, instances ...int32) (*au
 // Sends a kill message to the scheduler for all active tasks under a job.
 func (r realisClient) KillJob(key *aurora.JobKey) (*aurora.Response, error) {

-	instanceIds, err := r.getActiveInstanceIds(key)
+	instanceIds, err := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
 	if err != nil {
 		return nil, errors.Wrap(err, "Could not retrieve relevant task instance IDs")
 	}
@ -194,7 +194,7 @@ func (r realisClient) RestartInstances(key *aurora.JobKey, instances ...int32) (
 // Restarts all active tasks under a job configuration.
 func (r realisClient) RestartJob(key *aurora.JobKey) (*aurora.Response, error) {

-	instanceIds, err := r.getActiveInstanceIds(key)
+	instanceIds, err := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
 	if err != nil {
 		return nil, errors.Wrap(err, "Could not retrieve relevant task instance IDs")
 	}
--- a/response/response.go
+++ b/response/response.go
@ -27,8 +27,3 @@ func JobUpdateKey(resp *aurora.Response) *aurora.JobUpdateKey {
 func JobUpdateDetails(resp *aurora.Response) *aurora.JobUpdateDetails {
 	return resp.Result_.GetJobUpdateDetailsResult_.Details
 }
-
-
-
-
-
--- a/vendor/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
+++ b/vendor/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
@ -47,6 +47,7 @@ func Usage() {
 	fmt.Fprintln(os.Stderr, "  Response pauseJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response resumeJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response abortJobUpdate(JobUpdateKey key, string message)")
+	fmt.Fprintln(os.Stderr, "  Response rollbackJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response pulseJobUpdate(JobUpdateKey key)")
 	fmt.Fprintln(os.Stderr, "  Response getRoleSummary()")
 	fmt.Fprintln(os.Stderr, "  Response getJobSummary(string role)")
@ -162,19 +163,19 @@ func main() {
 		}
 		argvalue0 := flag.Arg(1)
 		value0 := argvalue0
-		arg336 := flag.Arg(2)
-		mbTrans337 := thrift.NewTMemoryBufferLen(len(arg336))
-		defer mbTrans337.Close()
-		_, err338 := mbTrans337.WriteString(arg336)
-		if err338 != nil {
+		arg345 := flag.Arg(2)
+		mbTrans346 := thrift.NewTMemoryBufferLen(len(arg345))
+		defer mbTrans346.Close()
+		_, err347 := mbTrans346.WriteString(arg345)
+		if err347 != nil {
 			Usage()
 			return
 		}
-		factory339 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt340 := factory339.GetProtocol(mbTrans337)
+		factory348 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt349 := factory348.GetProtocol(mbTrans346)
 		argvalue1 := aurora.NewResourceAggregate()
-		err341 := argvalue1.Read(jsProt340)
-		if err341 != nil {
+		err350 := argvalue1.Read(jsProt349)
+		if err350 != nil {
 			Usage()
 			return
 		}
@ -230,19 +231,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "QueryRecovery requires 1 args")
 			flag.Usage()
 		}
-		arg344 := flag.Arg(1)
-		mbTrans345 := thrift.NewTMemoryBufferLen(len(arg344))
-		defer mbTrans345.Close()
-		_, err346 := mbTrans345.WriteString(arg344)
-		if err346 != nil {
+		arg353 := flag.Arg(1)
+		mbTrans354 := thrift.NewTMemoryBufferLen(len(arg353))
+		defer mbTrans354.Close()
+		_, err355 := mbTrans354.WriteString(arg353)
+		if err355 != nil {
 			Usage()
 			return
 		}
-		factory347 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt348 := factory347.GetProtocol(mbTrans345)
+		factory356 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt357 := factory356.GetProtocol(mbTrans354)
 		argvalue0 := aurora.NewTaskQuery()
-		err349 := argvalue0.Read(jsProt348)
-		if err349 != nil {
+		err358 := argvalue0.Read(jsProt357)
+		if err358 != nil {
 			Usage()
 			return
 		}
@ -255,19 +256,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DeleteRecoveryTasks requires 1 args")
 			flag.Usage()
 		}
-		arg350 := flag.Arg(1)
-		mbTrans351 := thrift.NewTMemoryBufferLen(len(arg350))
-		defer mbTrans351.Close()
-		_, err352 := mbTrans351.WriteString(arg350)
-		if err352 != nil {
+		arg359 := flag.Arg(1)
+		mbTrans360 := thrift.NewTMemoryBufferLen(len(arg359))
+		defer mbTrans360.Close()
+		_, err361 := mbTrans360.WriteString(arg359)
+		if err361 != nil {
 			Usage()
 			return
 		}
-		factory353 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt354 := factory353.GetProtocol(mbTrans351)
+		factory362 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt363 := factory362.GetProtocol(mbTrans360)
 		argvalue0 := aurora.NewTaskQuery()
-		err355 := argvalue0.Read(jsProt354)
-		if err355 != nil {
+		err364 := argvalue0.Read(jsProt363)
+		if err364 != nil {
 			Usage()
 			return
 		}
@ -296,19 +297,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg356 := flag.Arg(1)
-		mbTrans357 := thrift.NewTMemoryBufferLen(len(arg356))
-		defer mbTrans357.Close()
-		_, err358 := mbTrans357.WriteString(arg356)
-		if err358 != nil {
+		arg365 := flag.Arg(1)
+		mbTrans366 := thrift.NewTMemoryBufferLen(len(arg365))
+		defer mbTrans366.Close()
+		_, err367 := mbTrans366.WriteString(arg365)
+		if err367 != nil {
 			Usage()
 			return
 		}
-		factory359 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt360 := factory359.GetProtocol(mbTrans357)
+		factory368 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt369 := factory368.GetProtocol(mbTrans366)
 		argvalue0 := aurora.NewHosts()
-		err361 := argvalue0.Read(jsProt360)
-		if err361 != nil {
+		err370 := argvalue0.Read(jsProt369)
+		if err370 != nil {
 			Usage()
 			return
 		}
@ -321,19 +322,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DrainHosts requires 1 args")
 			flag.Usage()
 		}
-		arg362 := flag.Arg(1)
-		mbTrans363 := thrift.NewTMemoryBufferLen(len(arg362))
-		defer mbTrans363.Close()
-		_, err364 := mbTrans363.WriteString(arg362)
-		if err364 != nil {
+		arg371 := flag.Arg(1)
+		mbTrans372 := thrift.NewTMemoryBufferLen(len(arg371))
+		defer mbTrans372.Close()
+		_, err373 := mbTrans372.WriteString(arg371)
+		if err373 != nil {
 			Usage()
 			return
 		}
-		factory365 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt366 := factory365.GetProtocol(mbTrans363)
+		factory374 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt375 := factory374.GetProtocol(mbTrans372)
 		argvalue0 := aurora.NewHosts()
-		err367 := argvalue0.Read(jsProt366)
-		if err367 != nil {
+		err376 := argvalue0.Read(jsProt375)
+		if err376 != nil {
 			Usage()
 			return
 		}
@ -346,19 +347,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "MaintenanceStatus requires 1 args")
 			flag.Usage()
 		}
-		arg368 := flag.Arg(1)
-		mbTrans369 := thrift.NewTMemoryBufferLen(len(arg368))
-		defer mbTrans369.Close()
-		_, err370 := mbTrans369.WriteString(arg368)
-		if err370 != nil {
+		arg377 := flag.Arg(1)
+		mbTrans378 := thrift.NewTMemoryBufferLen(len(arg377))
+		defer mbTrans378.Close()
+		_, err379 := mbTrans378.WriteString(arg377)
+		if err379 != nil {
 			Usage()
 			return
 		}
-		factory371 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt372 := factory371.GetProtocol(mbTrans369)
+		factory380 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt381 := factory380.GetProtocol(mbTrans378)
 		argvalue0 := aurora.NewHosts()
-		err373 := argvalue0.Read(jsProt372)
-		if err373 != nil {
+		err382 := argvalue0.Read(jsProt381)
+		if err382 != nil {
 			Usage()
 			return
 		}
@ -371,19 +372,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "EndMaintenance requires 1 args")
 			flag.Usage()
 		}
-		arg374 := flag.Arg(1)
-		mbTrans375 := thrift.NewTMemoryBufferLen(len(arg374))
-		defer mbTrans375.Close()
-		_, err376 := mbTrans375.WriteString(arg374)
-		if err376 != nil {
+		arg383 := flag.Arg(1)
+		mbTrans384 := thrift.NewTMemoryBufferLen(len(arg383))
+		defer mbTrans384.Close()
+		_, err385 := mbTrans384.WriteString(arg383)
+		if err385 != nil {
 			Usage()
 			return
 		}
-		factory377 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt378 := factory377.GetProtocol(mbTrans375)
+		factory386 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt387 := factory386.GetProtocol(mbTrans384)
 		argvalue0 := aurora.NewHosts()
-		err379 := argvalue0.Read(jsProt378)
-		if err379 != nil {
+		err388 := argvalue0.Read(jsProt387)
+		if err388 != nil {
 			Usage()
 			return
 		}
@ -404,19 +405,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RewriteConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg380 := flag.Arg(1)
-		mbTrans381 := thrift.NewTMemoryBufferLen(len(arg380))
-		defer mbTrans381.Close()
-		_, err382 := mbTrans381.WriteString(arg380)
-		if err382 != nil {
+		arg389 := flag.Arg(1)
+		mbTrans390 := thrift.NewTMemoryBufferLen(len(arg389))
+		defer mbTrans390.Close()
+		_, err391 := mbTrans390.WriteString(arg389)
+		if err391 != nil {
 			Usage()
 			return
 		}
-		factory383 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt384 := factory383.GetProtocol(mbTrans381)
+		factory392 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt393 := factory392.GetProtocol(mbTrans390)
 		argvalue0 := aurora.NewRewriteConfigsRequest()
-		err385 := argvalue0.Read(jsProt384)
-		if err385 != nil {
+		err394 := argvalue0.Read(jsProt393)
+		if err394 != nil {
 			Usage()
 			return
 		}
@ -429,19 +430,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
 			flag.Usage()
 		}
-		arg386 := flag.Arg(1)
-		mbTrans387 := thrift.NewTMemoryBufferLen(len(arg386))
-		defer mbTrans387.Close()
-		_, err388 := mbTrans387.WriteString(arg386)
-		if err388 != nil {
+		arg395 := flag.Arg(1)
+		mbTrans396 := thrift.NewTMemoryBufferLen(len(arg395))
+		defer mbTrans396.Close()
+		_, err397 := mbTrans396.WriteString(arg395)
+		if err397 != nil {
 			Usage()
 			return
 		}
-		factory389 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt390 := factory389.GetProtocol(mbTrans387)
+		factory398 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt399 := factory398.GetProtocol(mbTrans396)
 		argvalue0 := aurora.NewJobConfiguration()
-		err391 := argvalue0.Read(jsProt390)
-		if err391 != nil {
+		err400 := argvalue0.Read(jsProt399)
+		if err400 != nil {
 			Usage()
 			return
 		}
@ -454,19 +455,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg392 := flag.Arg(1)
-		mbTrans393 := thrift.NewTMemoryBufferLen(len(arg392))
-		defer mbTrans393.Close()
-		_, err394 := mbTrans393.WriteString(arg392)
-		if err394 != nil {
+		arg401 := flag.Arg(1)
+		mbTrans402 := thrift.NewTMemoryBufferLen(len(arg401))
+		defer mbTrans402.Close()
+		_, err403 := mbTrans402.WriteString(arg401)
+		if err403 != nil {
 			Usage()
 			return
 		}
-		factory395 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt396 := factory395.GetProtocol(mbTrans393)
+		factory404 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt405 := factory404.GetProtocol(mbTrans402)
 		argvalue0 := aurora.NewJobConfiguration()
-		err397 := argvalue0.Read(jsProt396)
-		if err397 != nil {
+		err406 := argvalue0.Read(jsProt405)
+		if err406 != nil {
 			Usage()
 			return
 		}
@ -479,19 +480,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg398 := flag.Arg(1)
-		mbTrans399 := thrift.NewTMemoryBufferLen(len(arg398))
-		defer mbTrans399.Close()
-		_, err400 := mbTrans399.WriteString(arg398)
-		if err400 != nil {
+		arg407 := flag.Arg(1)
+		mbTrans408 := thrift.NewTMemoryBufferLen(len(arg407))
+		defer mbTrans408.Close()
+		_, err409 := mbTrans408.WriteString(arg407)
+		if err409 != nil {
 			Usage()
 			return
 		}
-		factory401 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt402 := factory401.GetProtocol(mbTrans399)
+		factory410 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt411 := factory410.GetProtocol(mbTrans408)
 		argvalue0 := aurora.NewJobKey()
-		err403 := argvalue0.Read(jsProt402)
-		if err403 != nil {
+		err412 := argvalue0.Read(jsProt411)
+		if err412 != nil {
 			Usage()
 			return
 		}
@ -504,19 +505,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg404 := flag.Arg(1)
-		mbTrans405 := thrift.NewTMemoryBufferLen(len(arg404))
-		defer mbTrans405.Close()
-		_, err406 := mbTrans405.WriteString(arg404)
-		if err406 != nil {
+		arg413 := flag.Arg(1)
+		mbTrans414 := thrift.NewTMemoryBufferLen(len(arg413))
+		defer mbTrans414.Close()
+		_, err415 := mbTrans414.WriteString(arg413)
+		if err415 != nil {
 			Usage()
 			return
 		}
-		factory407 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt408 := factory407.GetProtocol(mbTrans405)
+		factory416 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt417 := factory416.GetProtocol(mbTrans414)
 		argvalue0 := aurora.NewJobKey()
-		err409 := argvalue0.Read(jsProt408)
-		if err409 != nil {
+		err418 := argvalue0.Read(jsProt417)
+		if err418 != nil {
 			Usage()
 			return
 		}
@ -529,36 +530,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
 			flag.Usage()
 		}
-		arg410 := flag.Arg(1)
-		mbTrans411 := thrift.NewTMemoryBufferLen(len(arg410))
-		defer mbTrans411.Close()
-		_, err412 := mbTrans411.WriteString(arg410)
-		if err412 != nil {
+		arg419 := flag.Arg(1)
+		mbTrans420 := thrift.NewTMemoryBufferLen(len(arg419))
+		defer mbTrans420.Close()
+		_, err421 := mbTrans420.WriteString(arg419)
+		if err421 != nil {
 			Usage()
 			return
 		}
-		factory413 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt414 := factory413.GetProtocol(mbTrans411)
+		factory422 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt423 := factory422.GetProtocol(mbTrans420)
 		argvalue0 := aurora.NewJobKey()
-		err415 := argvalue0.Read(jsProt414)
-		if err415 != nil {
+		err424 := argvalue0.Read(jsProt423)
+		if err424 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg416 := flag.Arg(2)
-		mbTrans417 := thrift.NewTMemoryBufferLen(len(arg416))
-		defer mbTrans417.Close()
-		_, err418 := mbTrans417.WriteString(arg416)
-		if err418 != nil {
+		arg425 := flag.Arg(2)
+		mbTrans426 := thrift.NewTMemoryBufferLen(len(arg425))
+		defer mbTrans426.Close()
+		_, err427 := mbTrans426.WriteString(arg425)
+		if err427 != nil {
 			Usage()
 			return
 		}
-		factory419 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt420 := factory419.GetProtocol(mbTrans417)
+		factory428 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt429 := factory428.GetProtocol(mbTrans426)
 		containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
-		err421 := containerStruct1.ReadField2(jsProt420)
-		if err421 != nil {
+		err430 := containerStruct1.ReadField2(jsProt429)
+		if err430 != nil {
 			Usage()
 			return
 		}
@ -572,36 +573,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
 			flag.Usage()
 		}
-		arg422 := flag.Arg(1)
-		mbTrans423 := thrift.NewTMemoryBufferLen(len(arg422))
-		defer mbTrans423.Close()
-		_, err424 := mbTrans423.WriteString(arg422)
-		if err424 != nil {
+		arg431 := flag.Arg(1)
+		mbTrans432 := thrift.NewTMemoryBufferLen(len(arg431))
+		defer mbTrans432.Close()
+		_, err433 := mbTrans432.WriteString(arg431)
+		if err433 != nil {
 			Usage()
 			return
 		}
-		factory425 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt426 := factory425.GetProtocol(mbTrans423)
+		factory434 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt435 := factory434.GetProtocol(mbTrans432)
 		argvalue0 := aurora.NewJobKey()
-		err427 := argvalue0.Read(jsProt426)
-		if err427 != nil {
+		err436 := argvalue0.Read(jsProt435)
+		if err436 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg428 := flag.Arg(2)
-		mbTrans429 := thrift.NewTMemoryBufferLen(len(arg428))
-		defer mbTrans429.Close()
-		_, err430 := mbTrans429.WriteString(arg428)
-		if err430 != nil {
+		arg437 := flag.Arg(2)
+		mbTrans438 := thrift.NewTMemoryBufferLen(len(arg437))
+		defer mbTrans438.Close()
+		_, err439 := mbTrans438.WriteString(arg437)
+		if err439 != nil {
 			Usage()
 			return
 		}
-		factory431 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt432 := factory431.GetProtocol(mbTrans429)
+		factory440 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt441 := factory440.GetProtocol(mbTrans438)
 		containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
-		err433 := containerStruct1.ReadField2(jsProt432)
-		if err433 != nil {
+		err442 := containerStruct1.ReadField2(jsProt441)
+		if err442 != nil {
 			Usage()
 			return
 		}
@ -615,25 +616,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg434 := flag.Arg(1)
-		mbTrans435 := thrift.NewTMemoryBufferLen(len(arg434))
-		defer mbTrans435.Close()
-		_, err436 := mbTrans435.WriteString(arg434)
-		if err436 != nil {
+		arg443 := flag.Arg(1)
+		mbTrans444 := thrift.NewTMemoryBufferLen(len(arg443))
+		defer mbTrans444.Close()
+		_, err445 := mbTrans444.WriteString(arg443)
+		if err445 != nil {
 			Usage()
 			return
 		}
-		factory437 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt438 := factory437.GetProtocol(mbTrans435)
+		factory446 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt447 := factory446.GetProtocol(mbTrans444)
 		argvalue0 := aurora.NewInstanceKey()
-		err439 := argvalue0.Read(jsProt438)
-		if err439 != nil {
+		err448 := argvalue0.Read(jsProt447)
+		if err448 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err440 := (strconv.Atoi(flag.Arg(2)))
-		if err440 != nil {
+		tmp1, err449 := (strconv.Atoi(flag.Arg(2)))
+		if err449 != nil {
 			Usage()
 			return
 		}
@ -647,19 +648,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg441 := flag.Arg(1)
-		mbTrans442 := thrift.NewTMemoryBufferLen(len(arg441))
-		defer mbTrans442.Close()
-		_, err443 := mbTrans442.WriteString(arg441)
-		if err443 != nil {
+		arg450 := flag.Arg(1)
+		mbTrans451 := thrift.NewTMemoryBufferLen(len(arg450))
+		defer mbTrans451.Close()
+		_, err452 := mbTrans451.WriteString(arg450)
+		if err452 != nil {
 			Usage()
 			return
 		}
-		factory444 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt445 := factory444.GetProtocol(mbTrans442)
+		factory453 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt454 := factory453.GetProtocol(mbTrans451)
 		argvalue0 := aurora.NewJobConfiguration()
-		err446 := argvalue0.Read(jsProt445)
-		if err446 != nil {
+		err455 := argvalue0.Read(jsProt454)
+		if err455 != nil {
 			Usage()
 			return
 		}
@ -672,19 +673,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg447 := flag.Arg(1)
-		mbTrans448 := thrift.NewTMemoryBufferLen(len(arg447))
-		defer mbTrans448.Close()
-		_, err449 := mbTrans448.WriteString(arg447)
-		if err449 != nil {
+		arg456 := flag.Arg(1)
+		mbTrans457 := thrift.NewTMemoryBufferLen(len(arg456))
+		defer mbTrans457.Close()
+		_, err458 := mbTrans457.WriteString(arg456)
+		if err458 != nil {
 			Usage()
 			return
 		}
-		factory450 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt451 := factory450.GetProtocol(mbTrans448)
+		factory459 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt460 := factory459.GetProtocol(mbTrans457)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err452 := argvalue0.Read(jsProt451)
-		if err452 != nil {
+		err461 := argvalue0.Read(jsProt460)
+		if err461 != nil {
 			Usage()
 			return
 		}
@ -699,19 +700,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg454 := flag.Arg(1)
-		mbTrans455 := thrift.NewTMemoryBufferLen(len(arg454))
-		defer mbTrans455.Close()
-		_, err456 := mbTrans455.WriteString(arg454)
-		if err456 != nil {
+		arg463 := flag.Arg(1)
+		mbTrans464 := thrift.NewTMemoryBufferLen(len(arg463))
+		defer mbTrans464.Close()
+		_, err465 := mbTrans464.WriteString(arg463)
+		if err465 != nil {
 			Usage()
 			return
 		}
-		factory457 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt458 := factory457.GetProtocol(mbTrans455)
+		factory466 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt467 := factory466.GetProtocol(mbTrans464)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err459 := argvalue0.Read(jsProt458)
-		if err459 != nil {
+		err468 := argvalue0.Read(jsProt467)
+		if err468 != nil {
 			Usage()
 			return
 		}
@ -726,19 +727,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg461 := flag.Arg(1)
-		mbTrans462 := thrift.NewTMemoryBufferLen(len(arg461))
-		defer mbTrans462.Close()
-		_, err463 := mbTrans462.WriteString(arg461)
-		if err463 != nil {
+		arg470 := flag.Arg(1)
+		mbTrans471 := thrift.NewTMemoryBufferLen(len(arg470))
+		defer mbTrans471.Close()
+		_, err472 := mbTrans471.WriteString(arg470)
+		if err472 != nil {
 			Usage()
 			return
 		}
-		factory464 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt465 := factory464.GetProtocol(mbTrans462)
+		factory473 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt474 := factory473.GetProtocol(mbTrans471)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err466 := argvalue0.Read(jsProt465)
-		if err466 != nil {
+		err475 := argvalue0.Read(jsProt474)
+		if err475 != nil {
 			Usage()
 			return
 		}
@ -753,19 +754,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg468 := flag.Arg(1)
-		mbTrans469 := thrift.NewTMemoryBufferLen(len(arg468))
-		defer mbTrans469.Close()
-		_, err470 := mbTrans469.WriteString(arg468)
-		if err470 != nil {
+		arg477 := flag.Arg(1)
+		mbTrans478 := thrift.NewTMemoryBufferLen(len(arg477))
+		defer mbTrans478.Close()
+		_, err479 := mbTrans478.WriteString(arg477)
+		if err479 != nil {
 			Usage()
 			return
 		}
-		factory471 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt472 := factory471.GetProtocol(mbTrans469)
+		factory480 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt481 := factory480.GetProtocol(mbTrans478)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err473 := argvalue0.Read(jsProt472)
-		if err473 != nil {
+		err482 := argvalue0.Read(jsProt481)
+		if err482 != nil {
 			Usage()
 			return
 		}
@ -775,24 +776,51 @@ func main() {
 		fmt.Print(client.AbortJobUpdate(value0, value1))
 		fmt.Print("\n")
 		break
+	case "rollbackJobUpdate":
+		if flag.NArg()-1 != 2 {
+			fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
+			flag.Usage()
+		}
+		arg484 := flag.Arg(1)
+		mbTrans485 := thrift.NewTMemoryBufferLen(len(arg484))
+		defer mbTrans485.Close()
+		_, err486 := mbTrans485.WriteString(arg484)
+		if err486 != nil {
+			Usage()
+			return
+		}
+		factory487 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt488 := factory487.GetProtocol(mbTrans485)
+		argvalue0 := aurora.NewJobUpdateKey()
+		err489 := argvalue0.Read(jsProt488)
+		if err489 != nil {
+			Usage()
+			return
+		}
+		value0 := argvalue0
+		argvalue1 := flag.Arg(2)
+		value1 := argvalue1
+		fmt.Print(client.RollbackJobUpdate(value0, value1))
+		fmt.Print("\n")
+		break
 	case "pulseJobUpdate":
 		if flag.NArg()-1 != 1 {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
 			flag.Usage()
 		}
-		arg475 := flag.Arg(1)
-		mbTrans476 := thrift.NewTMemoryBufferLen(len(arg475))
-		defer mbTrans476.Close()
-		_, err477 := mbTrans476.WriteString(arg475)
-		if err477 != nil {
+		arg491 := flag.Arg(1)
+		mbTrans492 := thrift.NewTMemoryBufferLen(len(arg491))
+		defer mbTrans492.Close()
+		_, err493 := mbTrans492.WriteString(arg491)
+		if err493 != nil {
 			Usage()
 			return
 		}
-		factory478 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt479 := factory478.GetProtocol(mbTrans476)
+		factory494 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt495 := factory494.GetProtocol(mbTrans492)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err480 := argvalue0.Read(jsProt479)
-		if err480 != nil {
+		err496 := argvalue0.Read(jsProt495)
+		if err496 != nil {
 			Usage()
 			return
 		}
@ -823,19 +851,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg482 := flag.Arg(1)
-		mbTrans483 := thrift.NewTMemoryBufferLen(len(arg482))
-		defer mbTrans483.Close()
-		_, err484 := mbTrans483.WriteString(arg482)
-		if err484 != nil {
+		arg498 := flag.Arg(1)
+		mbTrans499 := thrift.NewTMemoryBufferLen(len(arg498))
+		defer mbTrans499.Close()
+		_, err500 := mbTrans499.WriteString(arg498)
+		if err500 != nil {
 			Usage()
 			return
 		}
-		factory485 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt486 := factory485.GetProtocol(mbTrans483)
+		factory501 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt502 := factory501.GetProtocol(mbTrans499)
 		argvalue0 := aurora.NewTaskQuery()
-		err487 := argvalue0.Read(jsProt486)
-		if err487 != nil {
+		err503 := argvalue0.Read(jsProt502)
+		if err503 != nil {
 			Usage()
 			return
 		}
@ -848,19 +876,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg488 := flag.Arg(1)
-		mbTrans489 := thrift.NewTMemoryBufferLen(len(arg488))
-		defer mbTrans489.Close()
-		_, err490 := mbTrans489.WriteString(arg488)
-		if err490 != nil {
+		arg504 := flag.Arg(1)
+		mbTrans505 := thrift.NewTMemoryBufferLen(len(arg504))
+		defer mbTrans505.Close()
+		_, err506 := mbTrans505.WriteString(arg504)
+		if err506 != nil {
 			Usage()
 			return
 		}
-		factory491 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt492 := factory491.GetProtocol(mbTrans489)
+		factory507 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt508 := factory507.GetProtocol(mbTrans505)
 		argvalue0 := aurora.NewTaskQuery()
-		err493 := argvalue0.Read(jsProt492)
-		if err493 != nil {
+		err509 := argvalue0.Read(jsProt508)
+		if err509 != nil {
 			Usage()
 			return
 		}
@ -873,19 +901,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg494 := flag.Arg(1)
-		mbTrans495 := thrift.NewTMemoryBufferLen(len(arg494))
-		defer mbTrans495.Close()
-		_, err496 := mbTrans495.WriteString(arg494)
-		if err496 != nil {
+		arg510 := flag.Arg(1)
+		mbTrans511 := thrift.NewTMemoryBufferLen(len(arg510))
+		defer mbTrans511.Close()
+		_, err512 := mbTrans511.WriteString(arg510)
+		if err512 != nil {
 			Usage()
 			return
 		}
-		factory497 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt498 := factory497.GetProtocol(mbTrans495)
+		factory513 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt514 := factory513.GetProtocol(mbTrans511)
 		argvalue0 := aurora.NewTaskQuery()
-		err499 := argvalue0.Read(jsProt498)
-		if err499 != nil {
+		err515 := argvalue0.Read(jsProt514)
+		if err515 != nil {
 			Usage()
 			return
 		}
@ -898,19 +926,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg500 := flag.Arg(1)
-		mbTrans501 := thrift.NewTMemoryBufferLen(len(arg500))
-		defer mbTrans501.Close()
-		_, err502 := mbTrans501.WriteString(arg500)
-		if err502 != nil {
+		arg516 := flag.Arg(1)
+		mbTrans517 := thrift.NewTMemoryBufferLen(len(arg516))
+		defer mbTrans517.Close()
+		_, err518 := mbTrans517.WriteString(arg516)
+		if err518 != nil {
 			Usage()
 			return
 		}
-		factory503 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt504 := factory503.GetProtocol(mbTrans501)
+		factory519 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt520 := factory519.GetProtocol(mbTrans517)
 		argvalue0 := aurora.NewJobKey()
-		err505 := argvalue0.Read(jsProt504)
-		if err505 != nil {
+		err521 := argvalue0.Read(jsProt520)
+		if err521 != nil {
 			Usage()
 			return
 		}
@ -943,19 +971,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg508 := flag.Arg(1)
-		mbTrans509 := thrift.NewTMemoryBufferLen(len(arg508))
-		defer mbTrans509.Close()
-		_, err510 := mbTrans509.WriteString(arg508)
-		if err510 != nil {
+		arg524 := flag.Arg(1)
+		mbTrans525 := thrift.NewTMemoryBufferLen(len(arg524))
+		defer mbTrans525.Close()
+		_, err526 := mbTrans525.WriteString(arg524)
+		if err526 != nil {
 			Usage()
 			return
 		}
-		factory511 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt512 := factory511.GetProtocol(mbTrans509)
+		factory527 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt528 := factory527.GetProtocol(mbTrans525)
 		argvalue0 := aurora.NewJobConfiguration()
-		err513 := argvalue0.Read(jsProt512)
-		if err513 != nil {
+		err529 := argvalue0.Read(jsProt528)
+		if err529 != nil {
 			Usage()
 			return
 		}
@ -968,19 +996,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg514 := flag.Arg(1)
-		mbTrans515 := thrift.NewTMemoryBufferLen(len(arg514))
-		defer mbTrans515.Close()
-		_, err516 := mbTrans515.WriteString(arg514)
-		if err516 != nil {
+		arg530 := flag.Arg(1)
+		mbTrans531 := thrift.NewTMemoryBufferLen(len(arg530))
+		defer mbTrans531.Close()
+		_, err532 := mbTrans531.WriteString(arg530)
+		if err532 != nil {
 			Usage()
 			return
 		}
-		factory517 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt518 := factory517.GetProtocol(mbTrans515)
+		factory533 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt534 := factory533.GetProtocol(mbTrans531)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err519 := argvalue0.Read(jsProt518)
-		if err519 != nil {
+		err535 := argvalue0.Read(jsProt534)
+		if err535 != nil {
 			Usage()
 			return
 		}
@ -993,19 +1021,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg520 := flag.Arg(1)
-		mbTrans521 := thrift.NewTMemoryBufferLen(len(arg520))
-		defer mbTrans521.Close()
-		_, err522 := mbTrans521.WriteString(arg520)
-		if err522 != nil {
+		arg536 := flag.Arg(1)
+		mbTrans537 := thrift.NewTMemoryBufferLen(len(arg536))
+		defer mbTrans537.Close()
+		_, err538 := mbTrans537.WriteString(arg536)
+		if err538 != nil {
 			Usage()
 			return
 		}
-		factory523 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt524 := factory523.GetProtocol(mbTrans521)
+		factory539 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt540 := factory539.GetProtocol(mbTrans537)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err525 := argvalue0.Read(jsProt524)
-		if err525 != nil {
+		err541 := argvalue0.Read(jsProt540)
+		if err541 != nil {
 			Usage()
 			return
 		}
@ -1018,19 +1046,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg526 := flag.Arg(1)
-		mbTrans527 := thrift.NewTMemoryBufferLen(len(arg526))
-		defer mbTrans527.Close()
-		_, err528 := mbTrans527.WriteString(arg526)
-		if err528 != nil {
+		arg542 := flag.Arg(1)
+		mbTrans543 := thrift.NewTMemoryBufferLen(len(arg542))
+		defer mbTrans543.Close()
+		_, err544 := mbTrans543.WriteString(arg542)
+		if err544 != nil {
 			Usage()
 			return
 		}
-		factory529 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt530 := factory529.GetProtocol(mbTrans527)
+		factory545 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt546 := factory545.GetProtocol(mbTrans543)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err531 := argvalue0.Read(jsProt530)
-		if err531 != nil {
+		err547 := argvalue0.Read(jsProt546)
+		if err547 != nil {
 			Usage()
 			return
 		}
--- a/vendor/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
+++ b/vendor/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
@ -32,6 +32,7 @@ func Usage() {
 	fmt.Fprintln(os.Stderr, "  Response pauseJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response resumeJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response abortJobUpdate(JobUpdateKey key, string message)")
+	fmt.Fprintln(os.Stderr, "  Response rollbackJobUpdate(JobUpdateKey key, string message)")
 	fmt.Fprintln(os.Stderr, "  Response pulseJobUpdate(JobUpdateKey key)")
 	fmt.Fprintln(os.Stderr, "  Response getRoleSummary()")
 	fmt.Fprintln(os.Stderr, "  Response getJobSummary(string role)")
@ -145,19 +146,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
 			flag.Usage()
 		}
-		arg158 := flag.Arg(1)
-		mbTrans159 := thrift.NewTMemoryBufferLen(len(arg158))
-		defer mbTrans159.Close()
-		_, err160 := mbTrans159.WriteString(arg158)
-		if err160 != nil {
+		arg160 := flag.Arg(1)
+		mbTrans161 := thrift.NewTMemoryBufferLen(len(arg160))
+		defer mbTrans161.Close()
+		_, err162 := mbTrans161.WriteString(arg160)
+		if err162 != nil {
 			Usage()
 			return
 		}
-		factory161 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt162 := factory161.GetProtocol(mbTrans159)
+		factory163 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt164 := factory163.GetProtocol(mbTrans161)
 		argvalue0 := aurora.NewJobConfiguration()
-		err163 := argvalue0.Read(jsProt162)
-		if err163 != nil {
+		err165 := argvalue0.Read(jsProt164)
+		if err165 != nil {
 			Usage()
 			return
 		}
@ -170,19 +171,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg164 := flag.Arg(1)
-		mbTrans165 := thrift.NewTMemoryBufferLen(len(arg164))
-		defer mbTrans165.Close()
-		_, err166 := mbTrans165.WriteString(arg164)
-		if err166 != nil {
+		arg166 := flag.Arg(1)
+		mbTrans167 := thrift.NewTMemoryBufferLen(len(arg166))
+		defer mbTrans167.Close()
+		_, err168 := mbTrans167.WriteString(arg166)
+		if err168 != nil {
 			Usage()
 			return
 		}
-		factory167 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt168 := factory167.GetProtocol(mbTrans165)
+		factory169 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt170 := factory169.GetProtocol(mbTrans167)
 		argvalue0 := aurora.NewJobConfiguration()
-		err169 := argvalue0.Read(jsProt168)
-		if err169 != nil {
+		err171 := argvalue0.Read(jsProt170)
+		if err171 != nil {
 			Usage()
 			return
 		}
@ -195,19 +196,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg170 := flag.Arg(1)
-		mbTrans171 := thrift.NewTMemoryBufferLen(len(arg170))
-		defer mbTrans171.Close()
-		_, err172 := mbTrans171.WriteString(arg170)
-		if err172 != nil {
+		arg172 := flag.Arg(1)
+		mbTrans173 := thrift.NewTMemoryBufferLen(len(arg172))
+		defer mbTrans173.Close()
+		_, err174 := mbTrans173.WriteString(arg172)
+		if err174 != nil {
 			Usage()
 			return
 		}
-		factory173 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt174 := factory173.GetProtocol(mbTrans171)
+		factory175 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt176 := factory175.GetProtocol(mbTrans173)
 		argvalue0 := aurora.NewJobKey()
-		err175 := argvalue0.Read(jsProt174)
-		if err175 != nil {
+		err177 := argvalue0.Read(jsProt176)
+		if err177 != nil {
 			Usage()
 			return
 		}
@ -220,19 +221,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
 			flag.Usage()
 		}
-		arg176 := flag.Arg(1)
-		mbTrans177 := thrift.NewTMemoryBufferLen(len(arg176))
-		defer mbTrans177.Close()
-		_, err178 := mbTrans177.WriteString(arg176)
-		if err178 != nil {
+		arg178 := flag.Arg(1)
+		mbTrans179 := thrift.NewTMemoryBufferLen(len(arg178))
+		defer mbTrans179.Close()
+		_, err180 := mbTrans179.WriteString(arg178)
+		if err180 != nil {
 			Usage()
 			return
 		}
-		factory179 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt180 := factory179.GetProtocol(mbTrans177)
+		factory181 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt182 := factory181.GetProtocol(mbTrans179)
 		argvalue0 := aurora.NewJobKey()
-		err181 := argvalue0.Read(jsProt180)
-		if err181 != nil {
+		err183 := argvalue0.Read(jsProt182)
+		if err183 != nil {
 			Usage()
 			return
 		}
@ -245,36 +246,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
 			flag.Usage()
 		}
-		arg182 := flag.Arg(1)
-		mbTrans183 := thrift.NewTMemoryBufferLen(len(arg182))
-		defer mbTrans183.Close()
-		_, err184 := mbTrans183.WriteString(arg182)
-		if err184 != nil {
+		arg184 := flag.Arg(1)
+		mbTrans185 := thrift.NewTMemoryBufferLen(len(arg184))
+		defer mbTrans185.Close()
+		_, err186 := mbTrans185.WriteString(arg184)
+		if err186 != nil {
 			Usage()
 			return
 		}
-		factory185 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt186 := factory185.GetProtocol(mbTrans183)
+		factory187 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt188 := factory187.GetProtocol(mbTrans185)
 		argvalue0 := aurora.NewJobKey()
-		err187 := argvalue0.Read(jsProt186)
-		if err187 != nil {
+		err189 := argvalue0.Read(jsProt188)
+		if err189 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg188 := flag.Arg(2)
-		mbTrans189 := thrift.NewTMemoryBufferLen(len(arg188))
-		defer mbTrans189.Close()
-		_, err190 := mbTrans189.WriteString(arg188)
-		if err190 != nil {
+		arg190 := flag.Arg(2)
+		mbTrans191 := thrift.NewTMemoryBufferLen(len(arg190))
+		defer mbTrans191.Close()
+		_, err192 := mbTrans191.WriteString(arg190)
+		if err192 != nil {
 			Usage()
 			return
 		}
-		factory191 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt192 := factory191.GetProtocol(mbTrans189)
+		factory193 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt194 := factory193.GetProtocol(mbTrans191)
 		containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
-		err193 := containerStruct1.ReadField2(jsProt192)
-		if err193 != nil {
+		err195 := containerStruct1.ReadField2(jsProt194)
+		if err195 != nil {
 			Usage()
 			return
 		}
@ -288,36 +289,36 @@ func main() {
 			fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
 			flag.Usage()
 		}
-		arg194 := flag.Arg(1)
-		mbTrans195 := thrift.NewTMemoryBufferLen(len(arg194))
-		defer mbTrans195.Close()
-		_, err196 := mbTrans195.WriteString(arg194)
-		if err196 != nil {
+		arg196 := flag.Arg(1)
+		mbTrans197 := thrift.NewTMemoryBufferLen(len(arg196))
+		defer mbTrans197.Close()
+		_, err198 := mbTrans197.WriteString(arg196)
+		if err198 != nil {
 			Usage()
 			return
 		}
-		factory197 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt198 := factory197.GetProtocol(mbTrans195)
+		factory199 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt200 := factory199.GetProtocol(mbTrans197)
 		argvalue0 := aurora.NewJobKey()
-		err199 := argvalue0.Read(jsProt198)
-		if err199 != nil {
+		err201 := argvalue0.Read(jsProt200)
+		if err201 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		arg200 := flag.Arg(2)
-		mbTrans201 := thrift.NewTMemoryBufferLen(len(arg200))
-		defer mbTrans201.Close()
-		_, err202 := mbTrans201.WriteString(arg200)
-		if err202 != nil {
+		arg202 := flag.Arg(2)
+		mbTrans203 := thrift.NewTMemoryBufferLen(len(arg202))
+		defer mbTrans203.Close()
+		_, err204 := mbTrans203.WriteString(arg202)
+		if err204 != nil {
 			Usage()
 			return
 		}
-		factory203 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt204 := factory203.GetProtocol(mbTrans201)
+		factory205 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt206 := factory205.GetProtocol(mbTrans203)
 		containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
-		err205 := containerStruct1.ReadField2(jsProt204)
-		if err205 != nil {
+		err207 := containerStruct1.ReadField2(jsProt206)
+		if err207 != nil {
 			Usage()
 			return
 		}
@ -331,25 +332,25 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
 			flag.Usage()
 		}
-		arg206 := flag.Arg(1)
-		mbTrans207 := thrift.NewTMemoryBufferLen(len(arg206))
-		defer mbTrans207.Close()
-		_, err208 := mbTrans207.WriteString(arg206)
-		if err208 != nil {
+		arg208 := flag.Arg(1)
+		mbTrans209 := thrift.NewTMemoryBufferLen(len(arg208))
+		defer mbTrans209.Close()
+		_, err210 := mbTrans209.WriteString(arg208)
+		if err210 != nil {
 			Usage()
 			return
 		}
-		factory209 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt210 := factory209.GetProtocol(mbTrans207)
+		factory211 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt212 := factory211.GetProtocol(mbTrans209)
 		argvalue0 := aurora.NewInstanceKey()
-		err211 := argvalue0.Read(jsProt210)
-		if err211 != nil {
+		err213 := argvalue0.Read(jsProt212)
+		if err213 != nil {
 			Usage()
 			return
 		}
 		value0 := argvalue0
-		tmp1, err212 := (strconv.Atoi(flag.Arg(2)))
-		if err212 != nil {
+		tmp1, err214 := (strconv.Atoi(flag.Arg(2)))
+		if err214 != nil {
 			Usage()
 			return
 		}
@ -363,19 +364,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
 			flag.Usage()
 		}
-		arg213 := flag.Arg(1)
-		mbTrans214 := thrift.NewTMemoryBufferLen(len(arg213))
-		defer mbTrans214.Close()
-		_, err215 := mbTrans214.WriteString(arg213)
-		if err215 != nil {
+		arg215 := flag.Arg(1)
+		mbTrans216 := thrift.NewTMemoryBufferLen(len(arg215))
+		defer mbTrans216.Close()
+		_, err217 := mbTrans216.WriteString(arg215)
+		if err217 != nil {
 			Usage()
 			return
 		}
-		factory216 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt217 := factory216.GetProtocol(mbTrans214)
+		factory218 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt219 := factory218.GetProtocol(mbTrans216)
 		argvalue0 := aurora.NewJobConfiguration()
-		err218 := argvalue0.Read(jsProt217)
-		if err218 != nil {
+		err220 := argvalue0.Read(jsProt219)
+		if err220 != nil {
 			Usage()
 			return
 		}
@ -388,19 +389,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg219 := flag.Arg(1)
-		mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
-		defer mbTrans220.Close()
-		_, err221 := mbTrans220.WriteString(arg219)
-		if err221 != nil {
+		arg221 := flag.Arg(1)
+		mbTrans222 := thrift.NewTMemoryBufferLen(len(arg221))
+		defer mbTrans222.Close()
+		_, err223 := mbTrans222.WriteString(arg221)
+		if err223 != nil {
 			Usage()
 			return
 		}
-		factory222 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt223 := factory222.GetProtocol(mbTrans220)
+		factory224 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt225 := factory224.GetProtocol(mbTrans222)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err224 := argvalue0.Read(jsProt223)
-		if err224 != nil {
+		err226 := argvalue0.Read(jsProt225)
+		if err226 != nil {
 			Usage()
 			return
 		}
@ -415,19 +416,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg226 := flag.Arg(1)
-		mbTrans227 := thrift.NewTMemoryBufferLen(len(arg226))
-		defer mbTrans227.Close()
-		_, err228 := mbTrans227.WriteString(arg226)
-		if err228 != nil {
+		arg228 := flag.Arg(1)
+		mbTrans229 := thrift.NewTMemoryBufferLen(len(arg228))
+		defer mbTrans229.Close()
+		_, err230 := mbTrans229.WriteString(arg228)
+		if err230 != nil {
 			Usage()
 			return
 		}
-		factory229 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt230 := factory229.GetProtocol(mbTrans227)
+		factory231 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt232 := factory231.GetProtocol(mbTrans229)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err231 := argvalue0.Read(jsProt230)
-		if err231 != nil {
+		err233 := argvalue0.Read(jsProt232)
+		if err233 != nil {
 			Usage()
 			return
 		}
@ -442,19 +443,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg233 := flag.Arg(1)
-		mbTrans234 := thrift.NewTMemoryBufferLen(len(arg233))
-		defer mbTrans234.Close()
-		_, err235 := mbTrans234.WriteString(arg233)
-		if err235 != nil {
+		arg235 := flag.Arg(1)
+		mbTrans236 := thrift.NewTMemoryBufferLen(len(arg235))
+		defer mbTrans236.Close()
+		_, err237 := mbTrans236.WriteString(arg235)
+		if err237 != nil {
 			Usage()
 			return
 		}
-		factory236 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt237 := factory236.GetProtocol(mbTrans234)
+		factory238 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt239 := factory238.GetProtocol(mbTrans236)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err238 := argvalue0.Read(jsProt237)
-		if err238 != nil {
+		err240 := argvalue0.Read(jsProt239)
+		if err240 != nil {
 			Usage()
 			return
 		}
@ -469,19 +470,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
 			flag.Usage()
 		}
-		arg240 := flag.Arg(1)
-		mbTrans241 := thrift.NewTMemoryBufferLen(len(arg240))
-		defer mbTrans241.Close()
-		_, err242 := mbTrans241.WriteString(arg240)
-		if err242 != nil {
+		arg242 := flag.Arg(1)
+		mbTrans243 := thrift.NewTMemoryBufferLen(len(arg242))
+		defer mbTrans243.Close()
+		_, err244 := mbTrans243.WriteString(arg242)
+		if err244 != nil {
 			Usage()
 			return
 		}
-		factory243 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt244 := factory243.GetProtocol(mbTrans241)
+		factory245 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt246 := factory245.GetProtocol(mbTrans243)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err245 := argvalue0.Read(jsProt244)
-		if err245 != nil {
+		err247 := argvalue0.Read(jsProt246)
+		if err247 != nil {
 			Usage()
 			return
 		}
@ -491,24 +492,51 @@ func main() {
 		fmt.Print(client.AbortJobUpdate(value0, value1))
 		fmt.Print("\n")
 		break
+	case "rollbackJobUpdate":
+		if flag.NArg()-1 != 2 {
+			fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
+			flag.Usage()
+		}
+		arg249 := flag.Arg(1)
+		mbTrans250 := thrift.NewTMemoryBufferLen(len(arg249))
+		defer mbTrans250.Close()
+		_, err251 := mbTrans250.WriteString(arg249)
+		if err251 != nil {
+			Usage()
+			return
+		}
+		factory252 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt253 := factory252.GetProtocol(mbTrans250)
+		argvalue0 := aurora.NewJobUpdateKey()
+		err254 := argvalue0.Read(jsProt253)
+		if err254 != nil {
+			Usage()
+			return
+		}
+		value0 := argvalue0
+		argvalue1 := flag.Arg(2)
+		value1 := argvalue1
+		fmt.Print(client.RollbackJobUpdate(value0, value1))
+		fmt.Print("\n")
+		break
 	case "pulseJobUpdate":
 		if flag.NArg()-1 != 1 {
 			fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
 			flag.Usage()
 		}
-		arg247 := flag.Arg(1)
-		mbTrans248 := thrift.NewTMemoryBufferLen(len(arg247))
-		defer mbTrans248.Close()
-		_, err249 := mbTrans248.WriteString(arg247)
-		if err249 != nil {
+		arg256 := flag.Arg(1)
+		mbTrans257 := thrift.NewTMemoryBufferLen(len(arg256))
+		defer mbTrans257.Close()
+		_, err258 := mbTrans257.WriteString(arg256)
+		if err258 != nil {
 			Usage()
 			return
 		}
-		factory250 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt251 := factory250.GetProtocol(mbTrans248)
+		factory259 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt260 := factory259.GetProtocol(mbTrans257)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err252 := argvalue0.Read(jsProt251)
-		if err252 != nil {
+		err261 := argvalue0.Read(jsProt260)
+		if err261 != nil {
 			Usage()
 			return
 		}
@ -539,19 +567,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
 			flag.Usage()
 		}
-		arg254 := flag.Arg(1)
-		mbTrans255 := thrift.NewTMemoryBufferLen(len(arg254))
-		defer mbTrans255.Close()
-		_, err256 := mbTrans255.WriteString(arg254)
-		if err256 != nil {
+		arg263 := flag.Arg(1)
+		mbTrans264 := thrift.NewTMemoryBufferLen(len(arg263))
+		defer mbTrans264.Close()
+		_, err265 := mbTrans264.WriteString(arg263)
+		if err265 != nil {
 			Usage()
 			return
 		}
-		factory257 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt258 := factory257.GetProtocol(mbTrans255)
+		factory266 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt267 := factory266.GetProtocol(mbTrans264)
 		argvalue0 := aurora.NewTaskQuery()
-		err259 := argvalue0.Read(jsProt258)
-		if err259 != nil {
+		err268 := argvalue0.Read(jsProt267)
+		if err268 != nil {
 			Usage()
 			return
 		}
@ -564,19 +592,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
 			flag.Usage()
 		}
-		arg260 := flag.Arg(1)
-		mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
-		defer mbTrans261.Close()
-		_, err262 := mbTrans261.WriteString(arg260)
-		if err262 != nil {
+		arg269 := flag.Arg(1)
+		mbTrans270 := thrift.NewTMemoryBufferLen(len(arg269))
+		defer mbTrans270.Close()
+		_, err271 := mbTrans270.WriteString(arg269)
+		if err271 != nil {
 			Usage()
 			return
 		}
-		factory263 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt264 := factory263.GetProtocol(mbTrans261)
+		factory272 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt273 := factory272.GetProtocol(mbTrans270)
 		argvalue0 := aurora.NewTaskQuery()
-		err265 := argvalue0.Read(jsProt264)
-		if err265 != nil {
+		err274 := argvalue0.Read(jsProt273)
+		if err274 != nil {
 			Usage()
 			return
 		}
@ -589,19 +617,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
 			flag.Usage()
 		}
-		arg266 := flag.Arg(1)
-		mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
-		defer mbTrans267.Close()
-		_, err268 := mbTrans267.WriteString(arg266)
-		if err268 != nil {
+		arg275 := flag.Arg(1)
+		mbTrans276 := thrift.NewTMemoryBufferLen(len(arg275))
+		defer mbTrans276.Close()
+		_, err277 := mbTrans276.WriteString(arg275)
+		if err277 != nil {
 			Usage()
 			return
 		}
-		factory269 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt270 := factory269.GetProtocol(mbTrans267)
+		factory278 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt279 := factory278.GetProtocol(mbTrans276)
 		argvalue0 := aurora.NewTaskQuery()
-		err271 := argvalue0.Read(jsProt270)
-		if err271 != nil {
+		err280 := argvalue0.Read(jsProt279)
+		if err280 != nil {
 			Usage()
 			return
 		}
@ -614,19 +642,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
 			flag.Usage()
 		}
-		arg272 := flag.Arg(1)
-		mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
-		defer mbTrans273.Close()
-		_, err274 := mbTrans273.WriteString(arg272)
-		if err274 != nil {
+		arg281 := flag.Arg(1)
+		mbTrans282 := thrift.NewTMemoryBufferLen(len(arg281))
+		defer mbTrans282.Close()
+		_, err283 := mbTrans282.WriteString(arg281)
+		if err283 != nil {
 			Usage()
 			return
 		}
-		factory275 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt276 := factory275.GetProtocol(mbTrans273)
+		factory284 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt285 := factory284.GetProtocol(mbTrans282)
 		argvalue0 := aurora.NewJobKey()
-		err277 := argvalue0.Read(jsProt276)
-		if err277 != nil {
+		err286 := argvalue0.Read(jsProt285)
+		if err286 != nil {
 			Usage()
 			return
 		}
@ -659,19 +687,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
 			flag.Usage()
 		}
-		arg280 := flag.Arg(1)
-		mbTrans281 := thrift.NewTMemoryBufferLen(len(arg280))
-		defer mbTrans281.Close()
-		_, err282 := mbTrans281.WriteString(arg280)
-		if err282 != nil {
+		arg289 := flag.Arg(1)
+		mbTrans290 := thrift.NewTMemoryBufferLen(len(arg289))
+		defer mbTrans290.Close()
+		_, err291 := mbTrans290.WriteString(arg289)
+		if err291 != nil {
 			Usage()
 			return
 		}
-		factory283 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt284 := factory283.GetProtocol(mbTrans281)
+		factory292 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt293 := factory292.GetProtocol(mbTrans290)
 		argvalue0 := aurora.NewJobConfiguration()
-		err285 := argvalue0.Read(jsProt284)
-		if err285 != nil {
+		err294 := argvalue0.Read(jsProt293)
+		if err294 != nil {
 			Usage()
 			return
 		}
@ -684,19 +712,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
 			flag.Usage()
 		}
-		arg286 := flag.Arg(1)
-		mbTrans287 := thrift.NewTMemoryBufferLen(len(arg286))
-		defer mbTrans287.Close()
-		_, err288 := mbTrans287.WriteString(arg286)
-		if err288 != nil {
+		arg295 := flag.Arg(1)
+		mbTrans296 := thrift.NewTMemoryBufferLen(len(arg295))
+		defer mbTrans296.Close()
+		_, err297 := mbTrans296.WriteString(arg295)
+		if err297 != nil {
 			Usage()
 			return
 		}
-		factory289 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt290 := factory289.GetProtocol(mbTrans287)
+		factory298 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt299 := factory298.GetProtocol(mbTrans296)
 		argvalue0 := aurora.NewJobUpdateQuery()
-		err291 := argvalue0.Read(jsProt290)
-		if err291 != nil {
+		err300 := argvalue0.Read(jsProt299)
+		if err300 != nil {
 			Usage()
 			return
 		}
@ -709,19 +737,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
 			flag.Usage()
 		}
-		arg292 := flag.Arg(1)
-		mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
-		defer mbTrans293.Close()
-		_, err294 := mbTrans293.WriteString(arg292)
-		if err294 != nil {
+		arg301 := flag.Arg(1)
+		mbTrans302 := thrift.NewTMemoryBufferLen(len(arg301))
+		defer mbTrans302.Close()
+		_, err303 := mbTrans302.WriteString(arg301)
+		if err303 != nil {
 			Usage()
 			return
 		}
-		factory295 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt296 := factory295.GetProtocol(mbTrans293)
+		factory304 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt305 := factory304.GetProtocol(mbTrans302)
 		argvalue0 := aurora.NewJobUpdateKey()
-		err297 := argvalue0.Read(jsProt296)
-		if err297 != nil {
+		err306 := argvalue0.Read(jsProt305)
+		if err306 != nil {
 			Usage()
 			return
 		}
@ -734,19 +762,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
 			flag.Usage()
 		}
-		arg298 := flag.Arg(1)
-		mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
-		defer mbTrans299.Close()
-		_, err300 := mbTrans299.WriteString(arg298)
-		if err300 != nil {
+		arg307 := flag.Arg(1)
+		mbTrans308 := thrift.NewTMemoryBufferLen(len(arg307))
+		defer mbTrans308.Close()
+		_, err309 := mbTrans308.WriteString(arg307)
+		if err309 != nil {
 			Usage()
 			return
 		}
-		factory301 := thrift.NewTSimpleJSONProtocolFactory()
-		jsProt302 := factory301.GetProtocol(mbTrans299)
+		factory310 := thrift.NewTSimpleJSONProtocolFactory()
+		jsProt311 := factory310.GetProtocol(mbTrans308)
 		argvalue0 := aurora.NewJobUpdateRequest()
-		err303 := argvalue0.Read(jsProt302)
-		if err303 != nil {
+		err312 := argvalue0.Read(jsProt311)
+		if err312 != nil {
 			Usage()
 			return
 		}
--- a/vendor/gen-go/apache/aurora/auroraadmin.go
+++ b/vendor/gen-go/apache/aurora/auroraadmin.go
@ -153,16 +153,16 @@ func (p *AuroraAdminClient) recvSetQuota() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error304 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error305 error
-		error305, err = error304.Read(iprot)
+		error313 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error314 error
+		error314, err = error313.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error305
+		err = error314
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -236,16 +236,16 @@ func (p *AuroraAdminClient) recvForceTaskState() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error306 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error307 error
-		error307, err = error306.Read(iprot)
+		error315 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error316 error
+		error316, err = error315.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error307
+		err = error316
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -310,16 +310,16 @@ func (p *AuroraAdminClient) recvPerformBackup() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error308 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error309 error
-		error309, err = error308.Read(iprot)
+		error317 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error318 error
+		error318, err = error317.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error309
+		err = error318
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -384,16 +384,16 @@ func (p *AuroraAdminClient) recvListBackups() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error310 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error311 error
-		error311, err = error310.Read(iprot)
+		error319 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error320 error
+		error320, err = error319.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error311
+		err = error320
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -463,16 +463,16 @@ func (p *AuroraAdminClient) recvStageRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error312 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error313 error
-		error313, err = error312.Read(iprot)
+		error321 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error322 error
+		error322, err = error321.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error313
+		err = error322
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -542,16 +542,16 @@ func (p *AuroraAdminClient) recvQueryRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error314 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error315 error
-		error315, err = error314.Read(iprot)
+		error323 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error324 error
+		error324, err = error323.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error315
+		err = error324
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -621,16 +621,16 @@ func (p *AuroraAdminClient) recvDeleteRecoveryTasks() (value *Response, err erro
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error316 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error317 error
-		error317, err = error316.Read(iprot)
+		error325 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error326 error
+		error326, err = error325.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error317
+		err = error326
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -695,16 +695,16 @@ func (p *AuroraAdminClient) recvCommitRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error318 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error319 error
-		error319, err = error318.Read(iprot)
+		error327 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error328 error
+		error328, err = error327.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error319
+		err = error328
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -769,16 +769,16 @@ func (p *AuroraAdminClient) recvUnloadRecovery() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error320 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error321 error
-		error321, err = error320.Read(iprot)
+		error329 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error330 error
+		error330, err = error329.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error321
+		err = error330
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -848,16 +848,16 @@ func (p *AuroraAdminClient) recvStartMaintenance() (value *Response, err error)
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error322 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error323 error
-		error323, err = error322.Read(iprot)
+		error331 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error332 error
+		error332, err = error331.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error323
+		err = error332
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -927,16 +927,16 @@ func (p *AuroraAdminClient) recvDrainHosts() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error324 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error325 error
-		error325, err = error324.Read(iprot)
+		error333 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error334 error
+		error334, err = error333.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error325
+		err = error334
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1006,16 +1006,16 @@ func (p *AuroraAdminClient) recvMaintenanceStatus() (value *Response, err error)
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error326 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error327 error
-		error327, err = error326.Read(iprot)
+		error335 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error336 error
+		error336, err = error335.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error327
+		err = error336
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1085,16 +1085,16 @@ func (p *AuroraAdminClient) recvEndMaintenance() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error328 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error329 error
-		error329, err = error328.Read(iprot)
+		error337 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error338 error
+		error338, err = error337.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error329
+		err = error338
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1159,16 +1159,16 @@ func (p *AuroraAdminClient) recvSnapshot() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error330 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error331 error
-		error331, err = error330.Read(iprot)
+		error339 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error340 error
+		error340, err = error339.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error331
+		err = error340
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1242,16 +1242,16 @@ func (p *AuroraAdminClient) recvRewriteConfigs() (value *Response, err error) {
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error332 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error333 error
-		error333, err = error332.Read(iprot)
+		error341 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
+		var error342 error
+		error342, err = error341.Read(iprot)
 		if err != nil {
 			return
 		}
 		if err = iprot.ReadMessageEnd(); err != nil {
 			return
 		}
-		err = error333
+		err = error342
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1274,23 +1274,23 @@ type AuroraAdminProcessor struct {
 }

 func NewAuroraAdminProcessor(handler AuroraAdmin) *AuroraAdminProcessor {
-	self334 := &AuroraAdminProcessor{NewAuroraSchedulerManagerProcessor(handler)}
-	self334.AddToProcessorMap("setQuota", &auroraAdminProcessorSetQuota{handler: handler})
-	self334.AddToProcessorMap("forceTaskState", &auroraAdminProcessorForceTaskState{handler: handler})
-	self334.AddToProcessorMap("performBackup", &auroraAdminProcessorPerformBackup{handler: handler})
-	self334.AddToProcessorMap("listBackups", &auroraAdminProcessorListBackups{handler: handler})
-	self334.AddToProcessorMap("stageRecovery", &auroraAdminProcessorStageRecovery{handler: handler})
-	self334.AddToProcessorMap("queryRecovery", &auroraAdminProcessorQueryRecovery{handler: handler})
-	self334.AddToProcessorMap("deleteRecoveryTasks", &auroraAdminProcessorDeleteRecoveryTasks{handler: handler})
-	self334.AddToProcessorMap("commitRecovery", &auroraAdminProcessorCommitRecovery{handler: handler})
-	self334.AddToProcessorMap("unloadRecovery", &auroraAdminProcessorUnloadRecovery{handler: handler})
-	self334.AddToProcessorMap("startMaintenance", &auroraAdminProcessorStartMaintenance{handler: handler})
-	self334.AddToProcessorMap("drainHosts", &auroraAdminProcessorDrainHosts{handler: handler})
-	self334.AddToProcessorMap("maintenanceStatus", &auroraAdminProcessorMaintenanceStatus{handler: handler})
-	self334.AddToProcessorMap("endMaintenance", &auroraAdminProcessorEndMaintenance{handler: handler})
-	self334.AddToProcessorMap("snapshot", &auroraAdminProcessorSnapshot{handler: handler})
-	self334.AddToProcessorMap("rewriteConfigs", &auroraAdminProcessorRewriteConfigs{handler: handler})
-	return self334
+	self343 := &AuroraAdminProcessor{NewAuroraSchedulerManagerProcessor(handler)}
+	self343.AddToProcessorMap("setQuota", &auroraAdminProcessorSetQuota{handler: handler})
+	self343.AddToProcessorMap("forceTaskState", &auroraAdminProcessorForceTaskState{handler: handler})
+	self343.AddToProcessorMap("performBackup", &auroraAdminProcessorPerformBackup{handler: handler})
+	self343.AddToProcessorMap("listBackups", &auroraAdminProcessorListBackups{handler: handler})
+	self343.AddToProcessorMap("stageRecovery", &auroraAdminProcessorStageRecovery{handler: handler})
+	self343.AddToProcessorMap("queryRecovery", &auroraAdminProcessorQueryRecovery{handler: handler})
+	self343.AddToProcessorMap("deleteRecoveryTasks", &auroraAdminProcessorDeleteRecoveryTasks{handler: handler})
+	self343.AddToProcessorMap("commitRecovery", &auroraAdminProcessorCommitRecovery{handler: handler})
+	self343.AddToProcessorMap("unloadRecovery", &auroraAdminProcessorUnloadRecovery{handler: handler})
+	self343.AddToProcessorMap("startMaintenance", &auroraAdminProcessorStartMaintenance{handler: handler})
+	self343.AddToProcessorMap("drainHosts", &auroraAdminProcessorDrainHosts{handler: handler})
+	self343.AddToProcessorMap("maintenanceStatus", &auroraAdminProcessorMaintenanceStatus{handler: handler})
+	self343.AddToProcessorMap("endMaintenance", &auroraAdminProcessorEndMaintenance{handler: handler})
+	self343.AddToProcessorMap("snapshot", &auroraAdminProcessorSnapshot{handler: handler})
+	self343.AddToProcessorMap("rewriteConfigs", &auroraAdminProcessorRewriteConfigs{handler: handler})
+	return self343
 }

 type auroraAdminProcessorSetQuota struct {
--- a/vendor/gen-go/apache/aurora/auroraschedulermanager.go
+++ b/vendor/gen-go/apache/aurora/auroraschedulermanager.go
@ -90,6 +90,12 @@ type AuroraSchedulerManager interface {
 	//  - Key: The update to abort.
 	//  - Message: A user-specified message to include with the induced job update state change.
 	AbortJobUpdate(key *JobUpdateKey, message string) (r *Response, err error)
+	// Rollbacks the specified active job update to the initial state.
+	//
+	// Parameters:
+	//  - Key: The update to rollback.
+	//  - Message: A user-specified message to include with the induced job update state change.
+	RollbackJobUpdate(key *JobUpdateKey, message string) (r *Response, err error)
 	// Allows progress of the job update in case blockIfNoPulsesAfterMs is specified in
 	// JobUpdateSettings. Unblocks progress if the update was previously blocked.
 	// Responds with ResponseCode.INVALID_REQUEST in case an unknown update key is specified.
@ -1079,6 +1085,87 @@ func (p *AuroraSchedulerManagerClient) recvAbortJobUpdate() (value *Response, er
 	return
 }

+// Rollbacks the specified active job update to the initial state.
+//
+// Parameters:
+//  - Key: The update to rollback.
+//  - Message: A user-specified message to include with the induced job update state change.
+func (p *AuroraSchedulerManagerClient) RollbackJobUpdate(key *JobUpdateKey, message string) (r *Response, err error) {
+	if err = p.sendRollbackJobUpdate(key, message); err != nil {
+		return
+	}
+	return p.recvRollbackJobUpdate()
+}
+
+func (p *AuroraSchedulerManagerClient) sendRollbackJobUpdate(key *JobUpdateKey, message string) (err error) {
+	oprot := p.OutputProtocol
+	if oprot == nil {
+		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
+		p.OutputProtocol = oprot
+	}
+	p.SeqId++
+	if err = oprot.WriteMessageBegin("rollbackJobUpdate", thrift.CALL, p.SeqId); err != nil {
+		return
+	}
+	args := AuroraSchedulerManagerRollbackJobUpdateArgs{
+		Key:     key,
+		Message: message,
+	}
+	if err = args.Write(oprot); err != nil {
+		return
+	}
+	if err = oprot.WriteMessageEnd(); err != nil {
+		return
+	}
+	return oprot.Flush()
+}
+
+func (p *AuroraSchedulerManagerClient) recvRollbackJobUpdate() (value *Response, err error) {
+	iprot := p.InputProtocol
+	if iprot == nil {
+		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
+		p.InputProtocol = iprot
+	}
+	method, mTypeId, seqId, err := iprot.ReadMessageBegin()
+	if err != nil {
+		return
+	}
+	if method != "rollbackJobUpdate" {
+		err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "rollbackJobUpdate failed: wrong method name")
+		return
+	}
+	if p.SeqId != seqId {
+		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "rollbackJobUpdate failed: out of sequence response")
+		return
+	}
+	if mTypeId == thrift.EXCEPTION {
+		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 = error154
+		return
+	}
+	if mTypeId != thrift.REPLY {
+		err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "rollbackJobUpdate failed: invalid message type")
+		return
+	}
+	result := AuroraSchedulerManagerRollbackJobUpdateResult{}
+	if err = result.Read(iprot); err != nil {
+		return
+	}
+	if err = iprot.ReadMessageEnd(); err != nil {
+		return
+	}
+	value = result.GetSuccess()
+	return
+}
+
 // Allows progress of the job update in case blockIfNoPulsesAfterMs is specified in
 // JobUpdateSettings. Unblocks progress if the update was previously blocked.
 // Responds with ResponseCode.INVALID_REQUEST in case an unknown update key is specified.
@ -1133,16 +1220,16 @@ func (p *AuroraSchedulerManagerClient) recvPulseJobUpdate() (value *Response, er
 		return
 	}
 	if mTypeId == thrift.EXCEPTION {
-		error153 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
-		var error154 error
-		error154, err = error153.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 = error154
+		err = error156
 		return
 	}
 	if mTypeId != thrift.REPLY {
@ -1165,21 +1252,22 @@ type AuroraSchedulerManagerProcessor struct {
 }

 func NewAuroraSchedulerManagerProcessor(handler AuroraSchedulerManager) *AuroraSchedulerManagerProcessor {
-	self155 := &AuroraSchedulerManagerProcessor{NewReadOnlySchedulerProcessor(handler)}
-	self155.AddToProcessorMap("createJob", &auroraSchedulerManagerProcessorCreateJob{handler: handler})
-	self155.AddToProcessorMap("scheduleCronJob", &auroraSchedulerManagerProcessorScheduleCronJob{handler: handler})
-	self155.AddToProcessorMap("descheduleCronJob", &auroraSchedulerManagerProcessorDescheduleCronJob{handler: handler})
-	self155.AddToProcessorMap("startCronJob", &auroraSchedulerManagerProcessorStartCronJob{handler: handler})
-	self155.AddToProcessorMap("restartShards", &auroraSchedulerManagerProcessorRestartShards{handler: handler})
-	self155.AddToProcessorMap("killTasks", &auroraSchedulerManagerProcessorKillTasks{handler: handler})
-	self155.AddToProcessorMap("addInstances", &auroraSchedulerManagerProcessorAddInstances{handler: handler})
-	self155.AddToProcessorMap("replaceCronTemplate", &auroraSchedulerManagerProcessorReplaceCronTemplate{handler: handler})
-	self155.AddToProcessorMap("startJobUpdate", &auroraSchedulerManagerProcessorStartJobUpdate{handler: handler})
-	self155.AddToProcessorMap("pauseJobUpdate", &auroraSchedulerManagerProcessorPauseJobUpdate{handler: handler})
-	self155.AddToProcessorMap("resumeJobUpdate", &auroraSchedulerManagerProcessorResumeJobUpdate{handler: handler})
-	self155.AddToProcessorMap("abortJobUpdate", &auroraSchedulerManagerProcessorAbortJobUpdate{handler: handler})
-	self155.AddToProcessorMap("pulseJobUpdate", &auroraSchedulerManagerProcessorPulseJobUpdate{handler: handler})
-	return self155
+	self157 := &AuroraSchedulerManagerProcessor{NewReadOnlySchedulerProcessor(handler)}
+	self157.AddToProcessorMap("createJob", &auroraSchedulerManagerProcessorCreateJob{handler: handler})
+	self157.AddToProcessorMap("scheduleCronJob", &auroraSchedulerManagerProcessorScheduleCronJob{handler: handler})
+	self157.AddToProcessorMap("descheduleCronJob", &auroraSchedulerManagerProcessorDescheduleCronJob{handler: handler})
+	self157.AddToProcessorMap("startCronJob", &auroraSchedulerManagerProcessorStartCronJob{handler: handler})
+	self157.AddToProcessorMap("restartShards", &auroraSchedulerManagerProcessorRestartShards{handler: handler})
+	self157.AddToProcessorMap("killTasks", &auroraSchedulerManagerProcessorKillTasks{handler: handler})
+	self157.AddToProcessorMap("addInstances", &auroraSchedulerManagerProcessorAddInstances{handler: handler})
+	self157.AddToProcessorMap("replaceCronTemplate", &auroraSchedulerManagerProcessorReplaceCronTemplate{handler: handler})
+	self157.AddToProcessorMap("startJobUpdate", &auroraSchedulerManagerProcessorStartJobUpdate{handler: handler})
+	self157.AddToProcessorMap("pauseJobUpdate", &auroraSchedulerManagerProcessorPauseJobUpdate{handler: handler})
+	self157.AddToProcessorMap("resumeJobUpdate", &auroraSchedulerManagerProcessorResumeJobUpdate{handler: handler})
+	self157.AddToProcessorMap("abortJobUpdate", &auroraSchedulerManagerProcessorAbortJobUpdate{handler: handler})
+	self157.AddToProcessorMap("rollbackJobUpdate", &auroraSchedulerManagerProcessorRollbackJobUpdate{handler: handler})
+	self157.AddToProcessorMap("pulseJobUpdate", &auroraSchedulerManagerProcessorPulseJobUpdate{handler: handler})
+	return self157
 }

 type auroraSchedulerManagerProcessorCreateJob struct {
@ -1758,6 +1846,54 @@ func (p *auroraSchedulerManagerProcessorAbortJobUpdate) Process(seqId int32, ipr
 	return true, err
 }

+type auroraSchedulerManagerProcessorRollbackJobUpdate struct {
+	handler AuroraSchedulerManager
+}
+
+func (p *auroraSchedulerManagerProcessorRollbackJobUpdate) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
+	args := AuroraSchedulerManagerRollbackJobUpdateArgs{}
+	if err = args.Read(iprot); err != nil {
+		iprot.ReadMessageEnd()
+		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
+		oprot.WriteMessageBegin("rollbackJobUpdate", thrift.EXCEPTION, seqId)
+		x.Write(oprot)
+		oprot.WriteMessageEnd()
+		oprot.Flush()
+		return false, err
+	}
+
+	iprot.ReadMessageEnd()
+	result := AuroraSchedulerManagerRollbackJobUpdateResult{}
+	var retval *Response
+	var err2 error
+	if retval, err2 = p.handler.RollbackJobUpdate(args.Key, args.Message); err2 != nil {
+		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing rollbackJobUpdate: "+err2.Error())
+		oprot.WriteMessageBegin("rollbackJobUpdate", thrift.EXCEPTION, seqId)
+		x.Write(oprot)
+		oprot.WriteMessageEnd()
+		oprot.Flush()
+		return true, err2
+	} else {
+		result.Success = retval
+	}
+	if err2 = oprot.WriteMessageBegin("rollbackJobUpdate", thrift.REPLY, seqId); err2 != nil {
+		err = err2
+	}
+	if err2 = result.Write(oprot); err == nil && err2 != nil {
+		err = err2
+	}
+	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
+		err = err2
+	}
+	if err2 = oprot.Flush(); err == nil && err2 != nil {
+		err = err2
+	}
+	if err != nil {
+		return
+	}
+	return true, err
+}
+
 type auroraSchedulerManagerProcessorPulseJobUpdate struct {
 	handler AuroraSchedulerManager
 }
@ -2693,13 +2829,13 @@ func (p *AuroraSchedulerManagerRestartShardsArgs) readField3(iprot thrift.TProto
 	tSet := make(map[int32]bool, size)
 	p.ShardIds = tSet
 	for i := 0; i < size; i++ {
-		var _elem156 int32
+		var _elem158 int32
 		if v, err := iprot.ReadI32(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem156 = v
+			_elem158 = v
 		}
-		p.ShardIds[_elem156] = true
+		p.ShardIds[_elem158] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@ -2950,13 +3086,13 @@ func (p *AuroraSchedulerManagerKillTasksArgs) readField5(iprot thrift.TProtocol)
 	tSet := make(map[int32]bool, size)
 	p.Instances = tSet
 	for i := 0; i < size; i++ {
-		var _elem157 int32
+		var _elem159 int32
 		if v, err := iprot.ReadI32(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem157 = v
+			_elem159 = v
 		}
-		p.Instances[_elem157] = true
+		p.Instances[_elem159] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@ -4505,6 +4641,241 @@ func (p *AuroraSchedulerManagerAbortJobUpdateResult) String() string {
 	return fmt.Sprintf("AuroraSchedulerManagerAbortJobUpdateResult(%+v)", *p)
 }

+// Attributes:
+//  - Key: The update to rollback.
+//  - Message: A user-specified message to include with the induced job update state change.
+type AuroraSchedulerManagerRollbackJobUpdateArgs struct {
+	Key     *JobUpdateKey `thrift:"key,1" json:"key"`
+	Message string        `thrift:"message,2" json:"message"`
+}
+
+func NewAuroraSchedulerManagerRollbackJobUpdateArgs() *AuroraSchedulerManagerRollbackJobUpdateArgs {
+	return &AuroraSchedulerManagerRollbackJobUpdateArgs{}
+}
+
+var AuroraSchedulerManagerRollbackJobUpdateArgs_Key_DEFAULT *JobUpdateKey
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) GetKey() *JobUpdateKey {
+	if !p.IsSetKey() {
+		return AuroraSchedulerManagerRollbackJobUpdateArgs_Key_DEFAULT
+	}
+	return p.Key
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) GetMessage() string {
+	return p.Message
+}
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) IsSetKey() bool {
+	return p.Key != nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) Read(iprot thrift.TProtocol) error {
+	if _, err := iprot.ReadStructBegin(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+		if err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if err := p.readField1(iprot); err != nil {
+				return err
+			}
+		case 2:
+			if err := p.readField2(iprot); err != nil {
+				return err
+			}
+		default:
+			if err := iprot.Skip(fieldTypeId); err != nil {
+				return err
+			}
+		}
+		if err := iprot.ReadFieldEnd(); err != nil {
+			return err
+		}
+	}
+	if err := iprot.ReadStructEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) readField1(iprot thrift.TProtocol) error {
+	p.Key = &JobUpdateKey{}
+	if err := p.Key.Read(iprot); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Key), err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) readField2(iprot thrift.TProtocol) error {
+	if v, err := iprot.ReadString(); err != nil {
+		return thrift.PrependError("error reading field 2: ", err)
+	} else {
+		p.Message = v
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) Write(oprot thrift.TProtocol) error {
+	if err := oprot.WriteStructBegin("rollbackJobUpdate_args"); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+	}
+	if err := p.writeField1(oprot); err != nil {
+		return err
+	}
+	if err := p.writeField2(oprot); err != nil {
+		return err
+	}
+	if err := oprot.WriteFieldStop(); err != nil {
+		return thrift.PrependError("write field stop error: ", err)
+	}
+	if err := oprot.WriteStructEnd(); err != nil {
+		return thrift.PrependError("write struct stop error: ", err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) writeField1(oprot thrift.TProtocol) (err error) {
+	if err := oprot.WriteFieldBegin("key", thrift.STRUCT, 1); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err)
+	}
+	if err := p.Key.Write(oprot); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Key), err)
+	}
+	if err := oprot.WriteFieldEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err)
+	}
+	return err
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) writeField2(oprot thrift.TProtocol) (err error) {
+	if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:message: ", p), err)
+	}
+	if err := oprot.WriteString(string(p.Message)); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T.message (2) field write error: ", p), err)
+	}
+	if err := oprot.WriteFieldEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:message: ", p), err)
+	}
+	return err
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateArgs) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AuroraSchedulerManagerRollbackJobUpdateArgs(%+v)", *p)
+}
+
+// Attributes:
+//  - Success
+type AuroraSchedulerManagerRollbackJobUpdateResult struct {
+	Success *Response `thrift:"success,0" json:"success,omitempty"`
+}
+
+func NewAuroraSchedulerManagerRollbackJobUpdateResult() *AuroraSchedulerManagerRollbackJobUpdateResult {
+	return &AuroraSchedulerManagerRollbackJobUpdateResult{}
+}
+
+var AuroraSchedulerManagerRollbackJobUpdateResult_Success_DEFAULT *Response
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) GetSuccess() *Response {
+	if !p.IsSetSuccess() {
+		return AuroraSchedulerManagerRollbackJobUpdateResult_Success_DEFAULT
+	}
+	return p.Success
+}
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) IsSetSuccess() bool {
+	return p.Success != nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) Read(iprot thrift.TProtocol) error {
+	if _, err := iprot.ReadStructBegin(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+		if err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 0:
+			if err := p.readField0(iprot); err != nil {
+				return err
+			}
+		default:
+			if err := iprot.Skip(fieldTypeId); err != nil {
+				return err
+			}
+		}
+		if err := iprot.ReadFieldEnd(); err != nil {
+			return err
+		}
+	}
+	if err := iprot.ReadStructEnd(); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) readField0(iprot thrift.TProtocol) error {
+	p.Success = &Response{}
+	if err := p.Success.Read(iprot); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) Write(oprot thrift.TProtocol) error {
+	if err := oprot.WriteStructBegin("rollbackJobUpdate_result"); err != nil {
+		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+	}
+	if err := p.writeField0(oprot); err != nil {
+		return err
+	}
+	if err := oprot.WriteFieldStop(); err != nil {
+		return thrift.PrependError("write field stop error: ", err)
+	}
+	if err := oprot.WriteStructEnd(); err != nil {
+		return thrift.PrependError("write struct stop error: ", err)
+	}
+	return nil
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) writeField0(oprot thrift.TProtocol) (err error) {
+	if p.IsSetSuccess() {
+		if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
+		}
+		if err := p.Success.Write(oprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
+		}
+		if err := oprot.WriteFieldEnd(); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
+		}
+	}
+	return err
+}
+
+func (p *AuroraSchedulerManagerRollbackJobUpdateResult) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AuroraSchedulerManagerRollbackJobUpdateResult(%+v)", *p)
+}
+
 // Attributes:
 //  - Key
 type AuroraSchedulerManagerPulseJobUpdateArgs struct {
--- a/vendor/gen-go/apache/aurora/constants.go
+++ b/vendor/gen-go/apache/aurora/constants.go
@ -28,6 +28,7 @@ const GOOD_IDENTIFIER_PATTERN_PYTHON = "^[\\w\\-\\.]+$"
 var ACTIVE_JOB_UPDATE_STATES map[JobUpdateStatus]bool

 const BYPASS_LEADER_REDIRECT_HEADER_NAME = "Bypass-Leader-Redirect"
+const TASK_FILESYSTEM_MOUNT_POINT = "taskfs"

 func init() {
 	ACTIVE_STATES = map[ScheduleStatus]bool{
--- a/vendor/gen-go/apache/aurora/ttypes.go
+++ b/vendor/gen-go/apache/aurora/ttypes.go
@ -4271,9 +4271,9 @@ func (p *Resource) String() string {
 //  - Production: Whether this is a production task, which can preempt.
 //  - Tier: Task tier type.
 //  - Resources: All resources required to run a task.
-//  - MesosFetcherUris: Resources to retrieve with Mesos Fetcher
 //  - Constraints
 //  - RequestedPorts: a list of named ports this task requests
+//  - MesosFetcherUris: Resources to retrieve with Mesos Fetcher
 //  - TaskLinks: Custom links to include when displaying this task on the scheduler dashboard. Keys are anchor
 // text, values are URLs. Wildcards are supported for dynamic link crafting based on host, ports,
 // instance, etc.
@ -4378,12 +4378,6 @@ func (p *TaskConfig) GetResources() map[*Resource]bool {
 	return p.Resources
 }

-var TaskConfig_MesosFetcherUris_DEFAULT map[*MesosFetcherURI]bool
-
-func (p *TaskConfig) GetMesosFetcherUris() map[*MesosFetcherURI]bool {
-	return p.MesosFetcherUris
-}
-
 func (p *TaskConfig) GetConstraints() map[*Constraint]bool {
 	return p.Constraints
 }
@ -4392,6 +4386,12 @@ func (p *TaskConfig) GetRequestedPorts() map[string]bool {
 	return p.RequestedPorts
 }

+var TaskConfig_MesosFetcherUris_DEFAULT map[*MesosFetcherURI]bool
+
+func (p *TaskConfig) GetMesosFetcherUris() map[*MesosFetcherURI]bool {
+	return p.MesosFetcherUris
+}
+
 var TaskConfig_TaskLinks_DEFAULT map[string]string

 func (p *TaskConfig) GetTaskLinks() map[string]string {
@ -4530,10 +4530,6 @@ func (p *TaskConfig) Read(iprot thrift.TProtocol) error {
 			if err := p.readField32(iprot); err != nil {
 				return err
 			}
-		case 33:
-			if err := p.readField33(iprot); err != nil {
-				return err
-			}
 		case 20:
 			if err := p.readField20(iprot); err != nil {
 				return err
@ -4542,6 +4538,10 @@ func (p *TaskConfig) Read(iprot thrift.TProtocol) error {
 			if err := p.readField21(iprot); err != nil {
 				return err
 			}
+		case 33:
+			if err := p.readField33(iprot); err != nil {
+				return err
+			}
 		case 22:
 			if err := p.readField22(iprot); err != nil {
 				return err
@ -4685,26 +4685,6 @@ func (p *TaskConfig) readField32(iprot thrift.TProtocol) error {
 	return nil
 }

-func (p *TaskConfig) readField33(iprot thrift.TProtocol) error {
-	_, size, err := iprot.ReadSetBegin()
-	if err != nil {
-		return thrift.PrependError("error reading set begin: ", err)
-	}
-	tSet := make(map[*MesosFetcherURI]bool, size)
-	p.MesosFetcherUris = tSet
-	for i := 0; i < size; i++ {
-		_elem5 := &MesosFetcherURI{}
-		if err := _elem5.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem5), err)
-		}
-		p.MesosFetcherUris[_elem5] = true
-	}
-	if err := iprot.ReadSetEnd(); err != nil {
-		return thrift.PrependError("error reading set end: ", err)
-	}
-	return nil
-}
-
 func (p *TaskConfig) readField20(iprot thrift.TProtocol) error {
 	_, size, err := iprot.ReadSetBegin()
 	if err != nil {
@ -4713,11 +4693,11 @@ func (p *TaskConfig) readField20(iprot thrift.TProtocol) error {
 	tSet := make(map[*Constraint]bool, size)
 	p.Constraints = tSet
 	for i := 0; i < size; i++ {
-		_elem6 := &Constraint{}
-		if err := _elem6.Read(iprot); err != nil {
-			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem6), err)
+		_elem5 := &Constraint{}
+		if err := _elem5.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem5), err)
 		}
-		p.Constraints[_elem6] = true
+		p.Constraints[_elem5] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@ -4733,13 +4713,33 @@ func (p *TaskConfig) readField21(iprot thrift.TProtocol) error {
 	tSet := make(map[string]bool, size)
 	p.RequestedPorts = tSet
 	for i := 0; i < size; i++ {
-		var _elem7 string
+		var _elem6 string
 		if v, err := iprot.ReadString(); err != nil {
 			return thrift.PrependError("error reading field 0: ", err)
 		} else {
-			_elem7 = v
+			_elem6 = v
 		}
-		p.RequestedPorts[_elem7] = true
+		p.RequestedPorts[_elem6] = true
+	}
+	if err := iprot.ReadSetEnd(); err != nil {
+		return thrift.PrependError("error reading set end: ", err)
+	}
+	return nil
+}
+
+func (p *TaskConfig) readField33(iprot thrift.TProtocol) error {
+	_, size, err := iprot.ReadSetBegin()
+	if err != nil {
+		return thrift.PrependError("error reading set begin: ", err)
+	}
+	tSet := make(map[*MesosFetcherURI]bool, size)
+	p.MesosFetcherUris = tSet
+	for i := 0; i < size; i++ {
+		_elem7 := &MesosFetcherURI{}
+		if err := _elem7.Read(iprot); err != nil {
+			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem7), err)
+		}
+		p.MesosFetcherUris[_elem7] = true
 	}
 	if err := iprot.ReadSetEnd(); err != nil {
 		return thrift.PrependError("error reading set end: ", err)
@ -5431,6 +5431,7 @@ func (p *ResourceAggregate) String() string {
 // used to construct it server-side.
 //  - Owner: Owner of this job.
 //  - CronSchedule: If present, the job will be handled as a cron job with this crontab-syntax schedule.
+// This currently differs from the thrift API found in the main repo where it is not optional
 //  - CronCollisionPolicy: Collision policy to use when handling overlapping cron runs.  Default is KILL_EXISTING.
 //  - TaskConfig: Task configuration for this job.
 //  - InstanceCount: The number of instances in the job. Generated instance IDs for tasks will be in the range