Thrift API update and Pull Request template. (#43)
* Adding a Pull request template to serve as a reminder of what to do before creating the pull request. * Updating our thrift API to match changes made by Aurora. * Update go bindings to match update thrift API.
This commit is contained in:
Renan DelValle
GitHub
parent
d4027bc95c
commit
c338c03355
10 changed files with 1227 additions and 1729 deletions
|
|
@ -34,15 +34,15 @@ func Usage() {
|
|||
fmt.Fprintln(os.Stderr, " Response maintenanceStatus(Hosts hosts)")
|
||||
fmt.Fprintln(os.Stderr, " Response endMaintenance(Hosts hosts)")
|
||||
fmt.Fprintln(os.Stderr, " Response snapshot()")
|
||||
fmt.Fprintln(os.Stderr, " Response rewriteConfigs(RewriteConfigsRequest request)")
|
||||
fmt.Fprintln(os.Stderr, " Response triggerExplicitTaskReconciliation(ExplicitReconciliationSettings settings)")
|
||||
fmt.Fprintln(os.Stderr, " Response triggerImplicitTaskReconciliation()")
|
||||
fmt.Fprintln(os.Stderr, " Response pruneTasks(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response createJob(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response scheduleCronJob(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response descheduleCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response startCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response restartShards(JobKey job, shardIds)")
|
||||
fmt.Fprintln(os.Stderr, " Response killTasks(JobKey job, instances)")
|
||||
fmt.Fprintln(os.Stderr, " Response killTasks(JobKey job, instances, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response addInstances(InstanceKey key, i32 count)")
|
||||
fmt.Fprintln(os.Stderr, " Response replaceCronTemplate(JobConfiguration config)")
|
||||
fmt.Fprintln(os.Stderr, " Response startJobUpdate(JobUpdateRequest request, string message)")
|
||||
|
|
@ -165,19 +165,19 @@ func main() {
|
|||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
arg352 := flag.Arg(2)
|
||||
mbTrans353 := thrift.NewTMemoryBufferLen(len(arg352))
|
||||
defer mbTrans353.Close()
|
||||
_, err354 := mbTrans353.WriteString(arg352)
|
||||
if err354 != nil {
|
||||
arg353 := flag.Arg(2)
|
||||
mbTrans354 := thrift.NewTMemoryBufferLen(len(arg353))
|
||||
defer mbTrans354.Close()
|
||||
_, err355 := mbTrans354.WriteString(arg353)
|
||||
if err355 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory355 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt356 := factory355.GetProtocol(mbTrans353)
|
||||
factory356 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt357 := factory356.GetProtocol(mbTrans354)
|
||||
argvalue1 := aurora.NewResourceAggregate()
|
||||
err357 := argvalue1.Read(jsProt356)
|
||||
if err357 != nil {
|
||||
err358 := argvalue1.Read(jsProt357)
|
||||
if err358 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -233,19 +233,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "QueryRecovery requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg360 := flag.Arg(1)
|
||||
mbTrans361 := thrift.NewTMemoryBufferLen(len(arg360))
|
||||
defer mbTrans361.Close()
|
||||
_, err362 := mbTrans361.WriteString(arg360)
|
||||
if err362 != nil {
|
||||
arg361 := flag.Arg(1)
|
||||
mbTrans362 := thrift.NewTMemoryBufferLen(len(arg361))
|
||||
defer mbTrans362.Close()
|
||||
_, err363 := mbTrans362.WriteString(arg361)
|
||||
if err363 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory363 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt364 := factory363.GetProtocol(mbTrans361)
|
||||
factory364 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt365 := factory364.GetProtocol(mbTrans362)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err365 := argvalue0.Read(jsProt364)
|
||||
if err365 != nil {
|
||||
err366 := argvalue0.Read(jsProt365)
|
||||
if err366 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -258,19 +258,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "DeleteRecoveryTasks requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg366 := flag.Arg(1)
|
||||
mbTrans367 := thrift.NewTMemoryBufferLen(len(arg366))
|
||||
defer mbTrans367.Close()
|
||||
_, err368 := mbTrans367.WriteString(arg366)
|
||||
if err368 != nil {
|
||||
arg367 := flag.Arg(1)
|
||||
mbTrans368 := thrift.NewTMemoryBufferLen(len(arg367))
|
||||
defer mbTrans368.Close()
|
||||
_, err369 := mbTrans368.WriteString(arg367)
|
||||
if err369 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory369 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt370 := factory369.GetProtocol(mbTrans367)
|
||||
factory370 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt371 := factory370.GetProtocol(mbTrans368)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err371 := argvalue0.Read(jsProt370)
|
||||
if err371 != nil {
|
||||
err372 := argvalue0.Read(jsProt371)
|
||||
if err372 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -299,19 +299,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "StartMaintenance requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg372 := flag.Arg(1)
|
||||
mbTrans373 := thrift.NewTMemoryBufferLen(len(arg372))
|
||||
defer mbTrans373.Close()
|
||||
_, err374 := mbTrans373.WriteString(arg372)
|
||||
if err374 != nil {
|
||||
arg373 := flag.Arg(1)
|
||||
mbTrans374 := thrift.NewTMemoryBufferLen(len(arg373))
|
||||
defer mbTrans374.Close()
|
||||
_, err375 := mbTrans374.WriteString(arg373)
|
||||
if err375 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory375 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt376 := factory375.GetProtocol(mbTrans373)
|
||||
factory376 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt377 := factory376.GetProtocol(mbTrans374)
|
||||
argvalue0 := aurora.NewHosts()
|
||||
err377 := argvalue0.Read(jsProt376)
|
||||
if err377 != nil {
|
||||
err378 := argvalue0.Read(jsProt377)
|
||||
if err378 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -324,19 +324,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "DrainHosts requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg378 := flag.Arg(1)
|
||||
mbTrans379 := thrift.NewTMemoryBufferLen(len(arg378))
|
||||
defer mbTrans379.Close()
|
||||
_, err380 := mbTrans379.WriteString(arg378)
|
||||
if err380 != nil {
|
||||
arg379 := flag.Arg(1)
|
||||
mbTrans380 := thrift.NewTMemoryBufferLen(len(arg379))
|
||||
defer mbTrans380.Close()
|
||||
_, err381 := mbTrans380.WriteString(arg379)
|
||||
if err381 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory381 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt382 := factory381.GetProtocol(mbTrans379)
|
||||
factory382 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt383 := factory382.GetProtocol(mbTrans380)
|
||||
argvalue0 := aurora.NewHosts()
|
||||
err383 := argvalue0.Read(jsProt382)
|
||||
if err383 != nil {
|
||||
err384 := argvalue0.Read(jsProt383)
|
||||
if err384 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -349,19 +349,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "MaintenanceStatus requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg384 := flag.Arg(1)
|
||||
mbTrans385 := thrift.NewTMemoryBufferLen(len(arg384))
|
||||
defer mbTrans385.Close()
|
||||
_, err386 := mbTrans385.WriteString(arg384)
|
||||
if err386 != nil {
|
||||
arg385 := flag.Arg(1)
|
||||
mbTrans386 := thrift.NewTMemoryBufferLen(len(arg385))
|
||||
defer mbTrans386.Close()
|
||||
_, err387 := mbTrans386.WriteString(arg385)
|
||||
if err387 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory387 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt388 := factory387.GetProtocol(mbTrans385)
|
||||
factory388 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt389 := factory388.GetProtocol(mbTrans386)
|
||||
argvalue0 := aurora.NewHosts()
|
||||
err389 := argvalue0.Read(jsProt388)
|
||||
if err389 != nil {
|
||||
err390 := argvalue0.Read(jsProt389)
|
||||
if err390 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -374,19 +374,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "EndMaintenance requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg390 := flag.Arg(1)
|
||||
mbTrans391 := thrift.NewTMemoryBufferLen(len(arg390))
|
||||
defer mbTrans391.Close()
|
||||
_, err392 := mbTrans391.WriteString(arg390)
|
||||
if err392 != nil {
|
||||
arg391 := flag.Arg(1)
|
||||
mbTrans392 := thrift.NewTMemoryBufferLen(len(arg391))
|
||||
defer mbTrans392.Close()
|
||||
_, err393 := mbTrans392.WriteString(arg391)
|
||||
if err393 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory393 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt394 := factory393.GetProtocol(mbTrans391)
|
||||
factory394 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt395 := factory394.GetProtocol(mbTrans392)
|
||||
argvalue0 := aurora.NewHosts()
|
||||
err395 := argvalue0.Read(jsProt394)
|
||||
if err395 != nil {
|
||||
err396 := argvalue0.Read(jsProt395)
|
||||
if err396 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -402,49 +402,24 @@ func main() {
|
|||
fmt.Print(client.Snapshot())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "rewriteConfigs":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "RewriteConfigs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg396 := flag.Arg(1)
|
||||
mbTrans397 := thrift.NewTMemoryBufferLen(len(arg396))
|
||||
defer mbTrans397.Close()
|
||||
_, err398 := mbTrans397.WriteString(arg396)
|
||||
if err398 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory399 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt400 := factory399.GetProtocol(mbTrans397)
|
||||
argvalue0 := aurora.NewRewriteConfigsRequest()
|
||||
err401 := argvalue0.Read(jsProt400)
|
||||
if err401 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.RewriteConfigs(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "triggerExplicitTaskReconciliation":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "TriggerExplicitTaskReconciliation requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg402 := flag.Arg(1)
|
||||
mbTrans403 := thrift.NewTMemoryBufferLen(len(arg402))
|
||||
defer mbTrans403.Close()
|
||||
_, err404 := mbTrans403.WriteString(arg402)
|
||||
if err404 != nil {
|
||||
arg397 := flag.Arg(1)
|
||||
mbTrans398 := thrift.NewTMemoryBufferLen(len(arg397))
|
||||
defer mbTrans398.Close()
|
||||
_, err399 := mbTrans398.WriteString(arg397)
|
||||
if err399 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory405 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt406 := factory405.GetProtocol(mbTrans403)
|
||||
factory400 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt401 := factory400.GetProtocol(mbTrans398)
|
||||
argvalue0 := aurora.NewExplicitReconciliationSettings()
|
||||
err407 := argvalue0.Read(jsProt406)
|
||||
if err407 != nil {
|
||||
err402 := argvalue0.Read(jsProt401)
|
||||
if err402 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -460,24 +435,49 @@ func main() {
|
|||
fmt.Print(client.TriggerImplicitTaskReconciliation())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "pruneTasks":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "PruneTasks requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg403 := flag.Arg(1)
|
||||
mbTrans404 := thrift.NewTMemoryBufferLen(len(arg403))
|
||||
defer mbTrans404.Close()
|
||||
_, err405 := mbTrans404.WriteString(arg403)
|
||||
if err405 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory406 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt407 := factory406.GetProtocol(mbTrans404)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err408 := argvalue0.Read(jsProt407)
|
||||
if err408 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.PruneTasks(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "createJob":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg408 := flag.Arg(1)
|
||||
mbTrans409 := thrift.NewTMemoryBufferLen(len(arg408))
|
||||
defer mbTrans409.Close()
|
||||
_, err410 := mbTrans409.WriteString(arg408)
|
||||
if err410 != nil {
|
||||
arg409 := flag.Arg(1)
|
||||
mbTrans410 := thrift.NewTMemoryBufferLen(len(arg409))
|
||||
defer mbTrans410.Close()
|
||||
_, err411 := mbTrans410.WriteString(arg409)
|
||||
if err411 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory411 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt412 := factory411.GetProtocol(mbTrans409)
|
||||
factory412 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt413 := factory412.GetProtocol(mbTrans410)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err413 := argvalue0.Read(jsProt412)
|
||||
if err413 != nil {
|
||||
err414 := argvalue0.Read(jsProt413)
|
||||
if err414 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -490,19 +490,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg414 := flag.Arg(1)
|
||||
mbTrans415 := thrift.NewTMemoryBufferLen(len(arg414))
|
||||
defer mbTrans415.Close()
|
||||
_, err416 := mbTrans415.WriteString(arg414)
|
||||
if err416 != nil {
|
||||
arg415 := flag.Arg(1)
|
||||
mbTrans416 := thrift.NewTMemoryBufferLen(len(arg415))
|
||||
defer mbTrans416.Close()
|
||||
_, err417 := mbTrans416.WriteString(arg415)
|
||||
if err417 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory417 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt418 := factory417.GetProtocol(mbTrans415)
|
||||
factory418 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt419 := factory418.GetProtocol(mbTrans416)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err419 := argvalue0.Read(jsProt418)
|
||||
if err419 != nil {
|
||||
err420 := argvalue0.Read(jsProt419)
|
||||
if err420 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -515,19 +515,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg420 := flag.Arg(1)
|
||||
mbTrans421 := thrift.NewTMemoryBufferLen(len(arg420))
|
||||
defer mbTrans421.Close()
|
||||
_, err422 := mbTrans421.WriteString(arg420)
|
||||
if err422 != nil {
|
||||
arg421 := flag.Arg(1)
|
||||
mbTrans422 := thrift.NewTMemoryBufferLen(len(arg421))
|
||||
defer mbTrans422.Close()
|
||||
_, err423 := mbTrans422.WriteString(arg421)
|
||||
if err423 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory423 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt424 := factory423.GetProtocol(mbTrans421)
|
||||
factory424 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt425 := factory424.GetProtocol(mbTrans422)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err425 := argvalue0.Read(jsProt424)
|
||||
if err425 != nil {
|
||||
err426 := argvalue0.Read(jsProt425)
|
||||
if err426 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -540,19 +540,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg426 := flag.Arg(1)
|
||||
mbTrans427 := thrift.NewTMemoryBufferLen(len(arg426))
|
||||
defer mbTrans427.Close()
|
||||
_, err428 := mbTrans427.WriteString(arg426)
|
||||
if err428 != nil {
|
||||
arg427 := flag.Arg(1)
|
||||
mbTrans428 := thrift.NewTMemoryBufferLen(len(arg427))
|
||||
defer mbTrans428.Close()
|
||||
_, err429 := mbTrans428.WriteString(arg427)
|
||||
if err429 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory429 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt430 := factory429.GetProtocol(mbTrans427)
|
||||
factory430 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt431 := factory430.GetProtocol(mbTrans428)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err431 := argvalue0.Read(jsProt430)
|
||||
if err431 != nil {
|
||||
err432 := argvalue0.Read(jsProt431)
|
||||
if err432 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -565,36 +565,36 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg432 := flag.Arg(1)
|
||||
mbTrans433 := thrift.NewTMemoryBufferLen(len(arg432))
|
||||
defer mbTrans433.Close()
|
||||
_, err434 := mbTrans433.WriteString(arg432)
|
||||
if err434 != nil {
|
||||
arg433 := flag.Arg(1)
|
||||
mbTrans434 := thrift.NewTMemoryBufferLen(len(arg433))
|
||||
defer mbTrans434.Close()
|
||||
_, err435 := mbTrans434.WriteString(arg433)
|
||||
if err435 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory435 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt436 := factory435.GetProtocol(mbTrans433)
|
||||
factory436 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt437 := factory436.GetProtocol(mbTrans434)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err437 := argvalue0.Read(jsProt436)
|
||||
if err437 != nil {
|
||||
err438 := argvalue0.Read(jsProt437)
|
||||
if err438 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
arg438 := flag.Arg(2)
|
||||
mbTrans439 := thrift.NewTMemoryBufferLen(len(arg438))
|
||||
defer mbTrans439.Close()
|
||||
_, err440 := mbTrans439.WriteString(arg438)
|
||||
if err440 != nil {
|
||||
arg439 := flag.Arg(2)
|
||||
mbTrans440 := thrift.NewTMemoryBufferLen(len(arg439))
|
||||
defer mbTrans440.Close()
|
||||
_, err441 := mbTrans440.WriteString(arg439)
|
||||
if err441 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory441 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt442 := factory441.GetProtocol(mbTrans439)
|
||||
factory442 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt443 := factory442.GetProtocol(mbTrans440)
|
||||
containerStruct1 := aurora.NewAuroraAdminRestartShardsArgs()
|
||||
err443 := containerStruct1.ReadField2(jsProt442)
|
||||
if err443 != nil {
|
||||
err444 := containerStruct1.ReadField2(jsProt443)
|
||||
if err444 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -604,46 +604,48 @@ func main() {
|
|||
fmt.Print("\n")
|
||||
break
|
||||
case "killTasks":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
|
||||
if flag.NArg()-1 != 3 {
|
||||
fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg444 := flag.Arg(1)
|
||||
mbTrans445 := thrift.NewTMemoryBufferLen(len(arg444))
|
||||
defer mbTrans445.Close()
|
||||
_, err446 := mbTrans445.WriteString(arg444)
|
||||
if err446 != nil {
|
||||
arg445 := flag.Arg(1)
|
||||
mbTrans446 := thrift.NewTMemoryBufferLen(len(arg445))
|
||||
defer mbTrans446.Close()
|
||||
_, err447 := mbTrans446.WriteString(arg445)
|
||||
if err447 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory447 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt448 := factory447.GetProtocol(mbTrans445)
|
||||
factory448 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt449 := factory448.GetProtocol(mbTrans446)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err449 := argvalue0.Read(jsProt448)
|
||||
if err449 != nil {
|
||||
err450 := argvalue0.Read(jsProt449)
|
||||
if err450 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
arg450 := flag.Arg(2)
|
||||
mbTrans451 := thrift.NewTMemoryBufferLen(len(arg450))
|
||||
defer mbTrans451.Close()
|
||||
_, err452 := mbTrans451.WriteString(arg450)
|
||||
if err452 != nil {
|
||||
arg451 := flag.Arg(2)
|
||||
mbTrans452 := thrift.NewTMemoryBufferLen(len(arg451))
|
||||
defer mbTrans452.Close()
|
||||
_, err453 := mbTrans452.WriteString(arg451)
|
||||
if err453 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory453 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt454 := factory453.GetProtocol(mbTrans451)
|
||||
factory454 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt455 := factory454.GetProtocol(mbTrans452)
|
||||
containerStruct1 := aurora.NewAuroraAdminKillTasksArgs()
|
||||
err455 := containerStruct1.ReadField2(jsProt454)
|
||||
if err455 != nil {
|
||||
err456 := containerStruct1.ReadField2(jsProt455)
|
||||
if err456 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
argvalue1 := containerStruct1.Instances
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.KillTasks(value0, value1))
|
||||
argvalue2 := flag.Arg(3)
|
||||
value2 := argvalue2
|
||||
fmt.Print(client.KillTasks(value0, value1, value2))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "addInstances":
|
||||
|
|
@ -651,25 +653,25 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg456 := flag.Arg(1)
|
||||
mbTrans457 := thrift.NewTMemoryBufferLen(len(arg456))
|
||||
defer mbTrans457.Close()
|
||||
_, err458 := mbTrans457.WriteString(arg456)
|
||||
if err458 != nil {
|
||||
arg458 := flag.Arg(1)
|
||||
mbTrans459 := thrift.NewTMemoryBufferLen(len(arg458))
|
||||
defer mbTrans459.Close()
|
||||
_, err460 := mbTrans459.WriteString(arg458)
|
||||
if err460 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory459 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt460 := factory459.GetProtocol(mbTrans457)
|
||||
factory461 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt462 := factory461.GetProtocol(mbTrans459)
|
||||
argvalue0 := aurora.NewInstanceKey()
|
||||
err461 := argvalue0.Read(jsProt460)
|
||||
if err461 != nil {
|
||||
err463 := argvalue0.Read(jsProt462)
|
||||
if err463 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
tmp1, err462 := (strconv.Atoi(flag.Arg(2)))
|
||||
if err462 != nil {
|
||||
tmp1, err464 := (strconv.Atoi(flag.Arg(2)))
|
||||
if err464 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -683,19 +685,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg463 := flag.Arg(1)
|
||||
mbTrans464 := thrift.NewTMemoryBufferLen(len(arg463))
|
||||
defer mbTrans464.Close()
|
||||
_, err465 := mbTrans464.WriteString(arg463)
|
||||
if err465 != nil {
|
||||
arg465 := flag.Arg(1)
|
||||
mbTrans466 := thrift.NewTMemoryBufferLen(len(arg465))
|
||||
defer mbTrans466.Close()
|
||||
_, err467 := mbTrans466.WriteString(arg465)
|
||||
if err467 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory466 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt467 := factory466.GetProtocol(mbTrans464)
|
||||
factory468 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt469 := factory468.GetProtocol(mbTrans466)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err468 := argvalue0.Read(jsProt467)
|
||||
if err468 != nil {
|
||||
err470 := argvalue0.Read(jsProt469)
|
||||
if err470 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -708,19 +710,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg469 := flag.Arg(1)
|
||||
mbTrans470 := thrift.NewTMemoryBufferLen(len(arg469))
|
||||
defer mbTrans470.Close()
|
||||
_, err471 := mbTrans470.WriteString(arg469)
|
||||
if err471 != nil {
|
||||
arg471 := flag.Arg(1)
|
||||
mbTrans472 := thrift.NewTMemoryBufferLen(len(arg471))
|
||||
defer mbTrans472.Close()
|
||||
_, err473 := mbTrans472.WriteString(arg471)
|
||||
if err473 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory472 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt473 := factory472.GetProtocol(mbTrans470)
|
||||
factory474 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt475 := factory474.GetProtocol(mbTrans472)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err474 := argvalue0.Read(jsProt473)
|
||||
if err474 != nil {
|
||||
err476 := argvalue0.Read(jsProt475)
|
||||
if err476 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -735,19 +737,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg476 := flag.Arg(1)
|
||||
mbTrans477 := thrift.NewTMemoryBufferLen(len(arg476))
|
||||
defer mbTrans477.Close()
|
||||
_, err478 := mbTrans477.WriteString(arg476)
|
||||
if err478 != nil {
|
||||
arg478 := flag.Arg(1)
|
||||
mbTrans479 := thrift.NewTMemoryBufferLen(len(arg478))
|
||||
defer mbTrans479.Close()
|
||||
_, err480 := mbTrans479.WriteString(arg478)
|
||||
if err480 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory479 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt480 := factory479.GetProtocol(mbTrans477)
|
||||
factory481 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt482 := factory481.GetProtocol(mbTrans479)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err481 := argvalue0.Read(jsProt480)
|
||||
if err481 != nil {
|
||||
err483 := argvalue0.Read(jsProt482)
|
||||
if err483 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -762,19 +764,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg483 := flag.Arg(1)
|
||||
mbTrans484 := thrift.NewTMemoryBufferLen(len(arg483))
|
||||
defer mbTrans484.Close()
|
||||
_, err485 := mbTrans484.WriteString(arg483)
|
||||
if err485 != nil {
|
||||
arg485 := flag.Arg(1)
|
||||
mbTrans486 := thrift.NewTMemoryBufferLen(len(arg485))
|
||||
defer mbTrans486.Close()
|
||||
_, err487 := mbTrans486.WriteString(arg485)
|
||||
if err487 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory486 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt487 := factory486.GetProtocol(mbTrans484)
|
||||
factory488 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt489 := factory488.GetProtocol(mbTrans486)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err488 := argvalue0.Read(jsProt487)
|
||||
if err488 != nil {
|
||||
err490 := argvalue0.Read(jsProt489)
|
||||
if err490 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -789,19 +791,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg490 := flag.Arg(1)
|
||||
mbTrans491 := thrift.NewTMemoryBufferLen(len(arg490))
|
||||
defer mbTrans491.Close()
|
||||
_, err492 := mbTrans491.WriteString(arg490)
|
||||
if err492 != nil {
|
||||
arg492 := flag.Arg(1)
|
||||
mbTrans493 := thrift.NewTMemoryBufferLen(len(arg492))
|
||||
defer mbTrans493.Close()
|
||||
_, err494 := mbTrans493.WriteString(arg492)
|
||||
if err494 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory493 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt494 := factory493.GetProtocol(mbTrans491)
|
||||
factory495 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt496 := factory495.GetProtocol(mbTrans493)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err495 := argvalue0.Read(jsProt494)
|
||||
if err495 != nil {
|
||||
err497 := argvalue0.Read(jsProt496)
|
||||
if err497 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -816,19 +818,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg497 := flag.Arg(1)
|
||||
mbTrans498 := thrift.NewTMemoryBufferLen(len(arg497))
|
||||
defer mbTrans498.Close()
|
||||
_, err499 := mbTrans498.WriteString(arg497)
|
||||
if err499 != nil {
|
||||
arg499 := flag.Arg(1)
|
||||
mbTrans500 := thrift.NewTMemoryBufferLen(len(arg499))
|
||||
defer mbTrans500.Close()
|
||||
_, err501 := mbTrans500.WriteString(arg499)
|
||||
if err501 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory500 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt501 := factory500.GetProtocol(mbTrans498)
|
||||
factory502 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt503 := factory502.GetProtocol(mbTrans500)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err502 := argvalue0.Read(jsProt501)
|
||||
if err502 != nil {
|
||||
err504 := argvalue0.Read(jsProt503)
|
||||
if err504 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -843,19 +845,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg504 := flag.Arg(1)
|
||||
mbTrans505 := thrift.NewTMemoryBufferLen(len(arg504))
|
||||
defer mbTrans505.Close()
|
||||
_, err506 := mbTrans505.WriteString(arg504)
|
||||
if err506 != nil {
|
||||
arg506 := flag.Arg(1)
|
||||
mbTrans507 := thrift.NewTMemoryBufferLen(len(arg506))
|
||||
defer mbTrans507.Close()
|
||||
_, err508 := mbTrans507.WriteString(arg506)
|
||||
if err508 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory507 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt508 := factory507.GetProtocol(mbTrans505)
|
||||
factory509 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt510 := factory509.GetProtocol(mbTrans507)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err509 := argvalue0.Read(jsProt508)
|
||||
if err509 != nil {
|
||||
err511 := argvalue0.Read(jsProt510)
|
||||
if err511 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -886,19 +888,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg511 := flag.Arg(1)
|
||||
mbTrans512 := thrift.NewTMemoryBufferLen(len(arg511))
|
||||
defer mbTrans512.Close()
|
||||
_, err513 := mbTrans512.WriteString(arg511)
|
||||
if err513 != nil {
|
||||
arg513 := flag.Arg(1)
|
||||
mbTrans514 := thrift.NewTMemoryBufferLen(len(arg513))
|
||||
defer mbTrans514.Close()
|
||||
_, err515 := mbTrans514.WriteString(arg513)
|
||||
if err515 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory514 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt515 := factory514.GetProtocol(mbTrans512)
|
||||
factory516 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt517 := factory516.GetProtocol(mbTrans514)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err516 := argvalue0.Read(jsProt515)
|
||||
if err516 != nil {
|
||||
err518 := argvalue0.Read(jsProt517)
|
||||
if err518 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -911,19 +913,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg517 := flag.Arg(1)
|
||||
mbTrans518 := thrift.NewTMemoryBufferLen(len(arg517))
|
||||
defer mbTrans518.Close()
|
||||
_, err519 := mbTrans518.WriteString(arg517)
|
||||
if err519 != nil {
|
||||
arg519 := flag.Arg(1)
|
||||
mbTrans520 := thrift.NewTMemoryBufferLen(len(arg519))
|
||||
defer mbTrans520.Close()
|
||||
_, err521 := mbTrans520.WriteString(arg519)
|
||||
if err521 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory520 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt521 := factory520.GetProtocol(mbTrans518)
|
||||
factory522 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt523 := factory522.GetProtocol(mbTrans520)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err522 := argvalue0.Read(jsProt521)
|
||||
if err522 != nil {
|
||||
err524 := argvalue0.Read(jsProt523)
|
||||
if err524 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -936,19 +938,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg523 := flag.Arg(1)
|
||||
mbTrans524 := thrift.NewTMemoryBufferLen(len(arg523))
|
||||
defer mbTrans524.Close()
|
||||
_, err525 := mbTrans524.WriteString(arg523)
|
||||
if err525 != nil {
|
||||
arg525 := flag.Arg(1)
|
||||
mbTrans526 := thrift.NewTMemoryBufferLen(len(arg525))
|
||||
defer mbTrans526.Close()
|
||||
_, err527 := mbTrans526.WriteString(arg525)
|
||||
if err527 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory526 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt527 := factory526.GetProtocol(mbTrans524)
|
||||
factory528 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt529 := factory528.GetProtocol(mbTrans526)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err528 := argvalue0.Read(jsProt527)
|
||||
if err528 != nil {
|
||||
err530 := argvalue0.Read(jsProt529)
|
||||
if err530 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -961,19 +963,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg529 := flag.Arg(1)
|
||||
mbTrans530 := thrift.NewTMemoryBufferLen(len(arg529))
|
||||
defer mbTrans530.Close()
|
||||
_, err531 := mbTrans530.WriteString(arg529)
|
||||
if err531 != nil {
|
||||
arg531 := flag.Arg(1)
|
||||
mbTrans532 := thrift.NewTMemoryBufferLen(len(arg531))
|
||||
defer mbTrans532.Close()
|
||||
_, err533 := mbTrans532.WriteString(arg531)
|
||||
if err533 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory532 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt533 := factory532.GetProtocol(mbTrans530)
|
||||
factory534 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt535 := factory534.GetProtocol(mbTrans532)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err534 := argvalue0.Read(jsProt533)
|
||||
if err534 != nil {
|
||||
err536 := argvalue0.Read(jsProt535)
|
||||
if err536 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -1006,19 +1008,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg537 := flag.Arg(1)
|
||||
mbTrans538 := thrift.NewTMemoryBufferLen(len(arg537))
|
||||
defer mbTrans538.Close()
|
||||
_, err539 := mbTrans538.WriteString(arg537)
|
||||
if err539 != nil {
|
||||
arg539 := flag.Arg(1)
|
||||
mbTrans540 := thrift.NewTMemoryBufferLen(len(arg539))
|
||||
defer mbTrans540.Close()
|
||||
_, err541 := mbTrans540.WriteString(arg539)
|
||||
if err541 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory540 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt541 := factory540.GetProtocol(mbTrans538)
|
||||
factory542 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt543 := factory542.GetProtocol(mbTrans540)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err542 := argvalue0.Read(jsProt541)
|
||||
if err542 != nil {
|
||||
err544 := argvalue0.Read(jsProt543)
|
||||
if err544 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -1031,19 +1033,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg543 := flag.Arg(1)
|
||||
mbTrans544 := thrift.NewTMemoryBufferLen(len(arg543))
|
||||
defer mbTrans544.Close()
|
||||
_, err545 := mbTrans544.WriteString(arg543)
|
||||
if err545 != nil {
|
||||
arg545 := flag.Arg(1)
|
||||
mbTrans546 := thrift.NewTMemoryBufferLen(len(arg545))
|
||||
defer mbTrans546.Close()
|
||||
_, err547 := mbTrans546.WriteString(arg545)
|
||||
if err547 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory546 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt547 := factory546.GetProtocol(mbTrans544)
|
||||
factory548 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt549 := factory548.GetProtocol(mbTrans546)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err548 := argvalue0.Read(jsProt547)
|
||||
if err548 != nil {
|
||||
err550 := argvalue0.Read(jsProt549)
|
||||
if err550 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -1056,19 +1058,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg549 := flag.Arg(1)
|
||||
mbTrans550 := thrift.NewTMemoryBufferLen(len(arg549))
|
||||
defer mbTrans550.Close()
|
||||
_, err551 := mbTrans550.WriteString(arg549)
|
||||
if err551 != nil {
|
||||
arg551 := flag.Arg(1)
|
||||
mbTrans552 := thrift.NewTMemoryBufferLen(len(arg551))
|
||||
defer mbTrans552.Close()
|
||||
_, err553 := mbTrans552.WriteString(arg551)
|
||||
if err553 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory552 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt553 := factory552.GetProtocol(mbTrans550)
|
||||
factory554 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt555 := factory554.GetProtocol(mbTrans552)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err554 := argvalue0.Read(jsProt553)
|
||||
if err554 != nil {
|
||||
err556 := argvalue0.Read(jsProt555)
|
||||
if err556 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -1081,19 +1083,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg555 := flag.Arg(1)
|
||||
mbTrans556 := thrift.NewTMemoryBufferLen(len(arg555))
|
||||
defer mbTrans556.Close()
|
||||
_, err557 := mbTrans556.WriteString(arg555)
|
||||
if err557 != nil {
|
||||
arg557 := flag.Arg(1)
|
||||
mbTrans558 := thrift.NewTMemoryBufferLen(len(arg557))
|
||||
defer mbTrans558.Close()
|
||||
_, err559 := mbTrans558.WriteString(arg557)
|
||||
if err559 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory558 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt559 := factory558.GetProtocol(mbTrans556)
|
||||
factory560 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt561 := factory560.GetProtocol(mbTrans558)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err560 := argvalue0.Read(jsProt559)
|
||||
if err560 != nil {
|
||||
err562 := argvalue0.Read(jsProt561)
|
||||
if err562 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ func Usage() {
|
|||
fmt.Fprintln(os.Stderr, " Response descheduleCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response startCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response restartShards(JobKey job, shardIds)")
|
||||
fmt.Fprintln(os.Stderr, " Response killTasks(JobKey job, instances)")
|
||||
fmt.Fprintln(os.Stderr, " Response killTasks(JobKey job, instances, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response addInstances(InstanceKey key, i32 count)")
|
||||
fmt.Fprintln(os.Stderr, " Response replaceCronTemplate(JobConfiguration config)")
|
||||
fmt.Fprintln(os.Stderr, " Response startJobUpdate(JobUpdateRequest request, string message)")
|
||||
|
|
@ -285,8 +285,8 @@ func main() {
|
|||
fmt.Print("\n")
|
||||
break
|
||||
case "killTasks":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
|
||||
if flag.NArg()-1 != 3 {
|
||||
fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg199 := flag.Arg(1)
|
||||
|
|
@ -324,7 +324,9 @@ func main() {
|
|||
}
|
||||
argvalue1 := containerStruct1.Instances
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.KillTasks(value0, value1))
|
||||
argvalue2 := flag.Arg(3)
|
||||
value2 := argvalue2
|
||||
fmt.Print(client.KillTasks(value0, value1, value2))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "addInstances":
|
||||
|
|
@ -332,25 +334,25 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg211 := flag.Arg(1)
|
||||
mbTrans212 := thrift.NewTMemoryBufferLen(len(arg211))
|
||||
defer mbTrans212.Close()
|
||||
_, err213 := mbTrans212.WriteString(arg211)
|
||||
if err213 != nil {
|
||||
arg212 := flag.Arg(1)
|
||||
mbTrans213 := thrift.NewTMemoryBufferLen(len(arg212))
|
||||
defer mbTrans213.Close()
|
||||
_, err214 := mbTrans213.WriteString(arg212)
|
||||
if err214 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory214 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt215 := factory214.GetProtocol(mbTrans212)
|
||||
factory215 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt216 := factory215.GetProtocol(mbTrans213)
|
||||
argvalue0 := aurora.NewInstanceKey()
|
||||
err216 := argvalue0.Read(jsProt215)
|
||||
if err216 != nil {
|
||||
err217 := argvalue0.Read(jsProt216)
|
||||
if err217 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
tmp1, err217 := (strconv.Atoi(flag.Arg(2)))
|
||||
if err217 != nil {
|
||||
tmp1, err218 := (strconv.Atoi(flag.Arg(2)))
|
||||
if err218 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -364,19 +366,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg218 := flag.Arg(1)
|
||||
mbTrans219 := thrift.NewTMemoryBufferLen(len(arg218))
|
||||
defer mbTrans219.Close()
|
||||
_, err220 := mbTrans219.WriteString(arg218)
|
||||
if err220 != nil {
|
||||
arg219 := flag.Arg(1)
|
||||
mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
|
||||
defer mbTrans220.Close()
|
||||
_, err221 := mbTrans220.WriteString(arg219)
|
||||
if err221 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory221 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt222 := factory221.GetProtocol(mbTrans219)
|
||||
factory222 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt223 := factory222.GetProtocol(mbTrans220)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err223 := argvalue0.Read(jsProt222)
|
||||
if err223 != nil {
|
||||
err224 := argvalue0.Read(jsProt223)
|
||||
if err224 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -389,19 +391,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg224 := flag.Arg(1)
|
||||
mbTrans225 := thrift.NewTMemoryBufferLen(len(arg224))
|
||||
defer mbTrans225.Close()
|
||||
_, err226 := mbTrans225.WriteString(arg224)
|
||||
if err226 != nil {
|
||||
arg225 := flag.Arg(1)
|
||||
mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
|
||||
defer mbTrans226.Close()
|
||||
_, err227 := mbTrans226.WriteString(arg225)
|
||||
if err227 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory227 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt228 := factory227.GetProtocol(mbTrans225)
|
||||
factory228 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt229 := factory228.GetProtocol(mbTrans226)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err229 := argvalue0.Read(jsProt228)
|
||||
if err229 != nil {
|
||||
err230 := argvalue0.Read(jsProt229)
|
||||
if err230 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -416,19 +418,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg231 := flag.Arg(1)
|
||||
mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
|
||||
defer mbTrans232.Close()
|
||||
_, err233 := mbTrans232.WriteString(arg231)
|
||||
if err233 != nil {
|
||||
arg232 := flag.Arg(1)
|
||||
mbTrans233 := thrift.NewTMemoryBufferLen(len(arg232))
|
||||
defer mbTrans233.Close()
|
||||
_, err234 := mbTrans233.WriteString(arg232)
|
||||
if err234 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory234 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt235 := factory234.GetProtocol(mbTrans232)
|
||||
factory235 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt236 := factory235.GetProtocol(mbTrans233)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err236 := argvalue0.Read(jsProt235)
|
||||
if err236 != nil {
|
||||
err237 := argvalue0.Read(jsProt236)
|
||||
if err237 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -443,19 +445,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg238 := flag.Arg(1)
|
||||
mbTrans239 := thrift.NewTMemoryBufferLen(len(arg238))
|
||||
defer mbTrans239.Close()
|
||||
_, err240 := mbTrans239.WriteString(arg238)
|
||||
if err240 != nil {
|
||||
arg239 := flag.Arg(1)
|
||||
mbTrans240 := thrift.NewTMemoryBufferLen(len(arg239))
|
||||
defer mbTrans240.Close()
|
||||
_, err241 := mbTrans240.WriteString(arg239)
|
||||
if err241 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory241 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt242 := factory241.GetProtocol(mbTrans239)
|
||||
factory242 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt243 := factory242.GetProtocol(mbTrans240)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err243 := argvalue0.Read(jsProt242)
|
||||
if err243 != nil {
|
||||
err244 := argvalue0.Read(jsProt243)
|
||||
if err244 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -470,19 +472,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg245 := flag.Arg(1)
|
||||
mbTrans246 := thrift.NewTMemoryBufferLen(len(arg245))
|
||||
defer mbTrans246.Close()
|
||||
_, err247 := mbTrans246.WriteString(arg245)
|
||||
if err247 != nil {
|
||||
arg246 := flag.Arg(1)
|
||||
mbTrans247 := thrift.NewTMemoryBufferLen(len(arg246))
|
||||
defer mbTrans247.Close()
|
||||
_, err248 := mbTrans247.WriteString(arg246)
|
||||
if err248 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory248 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt249 := factory248.GetProtocol(mbTrans246)
|
||||
factory249 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt250 := factory249.GetProtocol(mbTrans247)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err250 := argvalue0.Read(jsProt249)
|
||||
if err250 != nil {
|
||||
err251 := argvalue0.Read(jsProt250)
|
||||
if err251 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -497,19 +499,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg252 := flag.Arg(1)
|
||||
mbTrans253 := thrift.NewTMemoryBufferLen(len(arg252))
|
||||
defer mbTrans253.Close()
|
||||
_, err254 := mbTrans253.WriteString(arg252)
|
||||
if err254 != nil {
|
||||
arg253 := flag.Arg(1)
|
||||
mbTrans254 := thrift.NewTMemoryBufferLen(len(arg253))
|
||||
defer mbTrans254.Close()
|
||||
_, err255 := mbTrans254.WriteString(arg253)
|
||||
if err255 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory255 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt256 := factory255.GetProtocol(mbTrans253)
|
||||
factory256 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt257 := factory256.GetProtocol(mbTrans254)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err257 := argvalue0.Read(jsProt256)
|
||||
if err257 != nil {
|
||||
err258 := argvalue0.Read(jsProt257)
|
||||
if err258 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -524,19 +526,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg259 := flag.Arg(1)
|
||||
mbTrans260 := thrift.NewTMemoryBufferLen(len(arg259))
|
||||
defer mbTrans260.Close()
|
||||
_, err261 := mbTrans260.WriteString(arg259)
|
||||
if err261 != nil {
|
||||
arg260 := flag.Arg(1)
|
||||
mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
|
||||
defer mbTrans261.Close()
|
||||
_, err262 := mbTrans261.WriteString(arg260)
|
||||
if err262 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory262 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt263 := factory262.GetProtocol(mbTrans260)
|
||||
factory263 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt264 := factory263.GetProtocol(mbTrans261)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err264 := argvalue0.Read(jsProt263)
|
||||
if err264 != nil {
|
||||
err265 := argvalue0.Read(jsProt264)
|
||||
if err265 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -567,19 +569,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg266 := flag.Arg(1)
|
||||
mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
|
||||
defer mbTrans267.Close()
|
||||
_, err268 := mbTrans267.WriteString(arg266)
|
||||
if err268 != nil {
|
||||
arg267 := flag.Arg(1)
|
||||
mbTrans268 := thrift.NewTMemoryBufferLen(len(arg267))
|
||||
defer mbTrans268.Close()
|
||||
_, err269 := mbTrans268.WriteString(arg267)
|
||||
if err269 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory269 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt270 := factory269.GetProtocol(mbTrans267)
|
||||
factory270 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt271 := factory270.GetProtocol(mbTrans268)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err271 := argvalue0.Read(jsProt270)
|
||||
if err271 != nil {
|
||||
err272 := argvalue0.Read(jsProt271)
|
||||
if err272 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -592,19 +594,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg272 := flag.Arg(1)
|
||||
mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
|
||||
defer mbTrans273.Close()
|
||||
_, err274 := mbTrans273.WriteString(arg272)
|
||||
if err274 != nil {
|
||||
arg273 := flag.Arg(1)
|
||||
mbTrans274 := thrift.NewTMemoryBufferLen(len(arg273))
|
||||
defer mbTrans274.Close()
|
||||
_, err275 := mbTrans274.WriteString(arg273)
|
||||
if err275 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory275 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt276 := factory275.GetProtocol(mbTrans273)
|
||||
factory276 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt277 := factory276.GetProtocol(mbTrans274)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err277 := argvalue0.Read(jsProt276)
|
||||
if err277 != nil {
|
||||
err278 := argvalue0.Read(jsProt277)
|
||||
if err278 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -617,19 +619,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg278 := flag.Arg(1)
|
||||
mbTrans279 := thrift.NewTMemoryBufferLen(len(arg278))
|
||||
defer mbTrans279.Close()
|
||||
_, err280 := mbTrans279.WriteString(arg278)
|
||||
if err280 != nil {
|
||||
arg279 := flag.Arg(1)
|
||||
mbTrans280 := thrift.NewTMemoryBufferLen(len(arg279))
|
||||
defer mbTrans280.Close()
|
||||
_, err281 := mbTrans280.WriteString(arg279)
|
||||
if err281 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory281 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt282 := factory281.GetProtocol(mbTrans279)
|
||||
factory282 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt283 := factory282.GetProtocol(mbTrans280)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err283 := argvalue0.Read(jsProt282)
|
||||
if err283 != nil {
|
||||
err284 := argvalue0.Read(jsProt283)
|
||||
if err284 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -642,19 +644,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg284 := flag.Arg(1)
|
||||
mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
|
||||
defer mbTrans285.Close()
|
||||
_, err286 := mbTrans285.WriteString(arg284)
|
||||
if err286 != nil {
|
||||
arg285 := flag.Arg(1)
|
||||
mbTrans286 := thrift.NewTMemoryBufferLen(len(arg285))
|
||||
defer mbTrans286.Close()
|
||||
_, err287 := mbTrans286.WriteString(arg285)
|
||||
if err287 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory287 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt288 := factory287.GetProtocol(mbTrans285)
|
||||
factory288 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt289 := factory288.GetProtocol(mbTrans286)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err289 := argvalue0.Read(jsProt288)
|
||||
if err289 != nil {
|
||||
err290 := argvalue0.Read(jsProt289)
|
||||
if err290 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -687,19 +689,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg292 := flag.Arg(1)
|
||||
mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
|
||||
defer mbTrans293.Close()
|
||||
_, err294 := mbTrans293.WriteString(arg292)
|
||||
if err294 != nil {
|
||||
arg293 := flag.Arg(1)
|
||||
mbTrans294 := thrift.NewTMemoryBufferLen(len(arg293))
|
||||
defer mbTrans294.Close()
|
||||
_, err295 := mbTrans294.WriteString(arg293)
|
||||
if err295 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory295 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt296 := factory295.GetProtocol(mbTrans293)
|
||||
factory296 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt297 := factory296.GetProtocol(mbTrans294)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err297 := argvalue0.Read(jsProt296)
|
||||
if err297 != nil {
|
||||
err298 := argvalue0.Read(jsProt297)
|
||||
if err298 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -712,19 +714,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg298 := flag.Arg(1)
|
||||
mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
|
||||
defer mbTrans299.Close()
|
||||
_, err300 := mbTrans299.WriteString(arg298)
|
||||
if err300 != nil {
|
||||
arg299 := flag.Arg(1)
|
||||
mbTrans300 := thrift.NewTMemoryBufferLen(len(arg299))
|
||||
defer mbTrans300.Close()
|
||||
_, err301 := mbTrans300.WriteString(arg299)
|
||||
if err301 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory301 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt302 := factory301.GetProtocol(mbTrans299)
|
||||
factory302 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt303 := factory302.GetProtocol(mbTrans300)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err303 := argvalue0.Read(jsProt302)
|
||||
if err303 != nil {
|
||||
err304 := argvalue0.Read(jsProt303)
|
||||
if err304 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -737,19 +739,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg304 := flag.Arg(1)
|
||||
mbTrans305 := thrift.NewTMemoryBufferLen(len(arg304))
|
||||
defer mbTrans305.Close()
|
||||
_, err306 := mbTrans305.WriteString(arg304)
|
||||
if err306 != nil {
|
||||
arg305 := flag.Arg(1)
|
||||
mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
|
||||
defer mbTrans306.Close()
|
||||
_, err307 := mbTrans306.WriteString(arg305)
|
||||
if err307 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory307 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt308 := factory307.GetProtocol(mbTrans305)
|
||||
factory308 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt309 := factory308.GetProtocol(mbTrans306)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err309 := argvalue0.Read(jsProt308)
|
||||
if err309 != nil {
|
||||
err310 := argvalue0.Read(jsProt309)
|
||||
if err310 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
@ -762,19 +764,19 @@ func main() {
|
|||
fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg310 := flag.Arg(1)
|
||||
mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
|
||||
defer mbTrans311.Close()
|
||||
_, err312 := mbTrans311.WriteString(arg310)
|
||||
if err312 != nil {
|
||||
arg311 := flag.Arg(1)
|
||||
mbTrans312 := thrift.NewTMemoryBufferLen(len(arg311))
|
||||
defer mbTrans312.Close()
|
||||
_, err313 := mbTrans312.WriteString(arg311)
|
||||
if err313 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory313 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt314 := factory313.GetProtocol(mbTrans311)
|
||||
factory314 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt315 := factory314.GetProtocol(mbTrans312)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err315 := argvalue0.Read(jsProt314)
|
||||
if err315 != nil {
|
||||
err316 := argvalue0.Read(jsProt315)
|
||||
if err316 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -53,7 +53,8 @@ type AuroraSchedulerManager interface {
|
|||
// Parameters:
|
||||
// - Job
|
||||
// - Instances
|
||||
KillTasks(job *JobKey, instances map[int32]bool) (r *Response, err error)
|
||||
// - Message
|
||||
KillTasks(job *JobKey, instances map[int32]bool, message string) (r *Response, err error)
|
||||
// Adds new instances with the TaskConfig of the existing instance pointed by the key.
|
||||
//
|
||||
// Parameters:
|
||||
|
|
@ -524,14 +525,15 @@ func (p *AuroraSchedulerManagerClient) recvRestartShards() (value *Response, err
|
|||
// Parameters:
|
||||
// - Job
|
||||
// - Instances
|
||||
func (p *AuroraSchedulerManagerClient) KillTasks(job *JobKey, instances map[int32]bool) (r *Response, err error) {
|
||||
if err = p.sendKillTasks(job, instances); err != nil {
|
||||
// - Message
|
||||
func (p *AuroraSchedulerManagerClient) KillTasks(job *JobKey, instances map[int32]bool, message string) (r *Response, err error) {
|
||||
if err = p.sendKillTasks(job, instances, message); err != nil {
|
||||
return
|
||||
}
|
||||
return p.recvKillTasks()
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[int32]bool) (err error) {
|
||||
func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[int32]bool, message string) (err error) {
|
||||
oprot := p.OutputProtocol
|
||||
if oprot == nil {
|
||||
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
|
||||
|
|
@ -544,6 +546,7 @@ func (p *AuroraSchedulerManagerClient) sendKillTasks(job *JobKey, instances map[
|
|||
args := AuroraSchedulerManagerKillTasksArgs{
|
||||
Job: job,
|
||||
Instances: instances,
|
||||
Message: message,
|
||||
}
|
||||
if err = args.Write(oprot); err != nil {
|
||||
return
|
||||
|
|
@ -1530,7 +1533,7 @@ func (p *auroraSchedulerManagerProcessorKillTasks) Process(seqId int32, iprot, o
|
|||
result := AuroraSchedulerManagerKillTasksResult{}
|
||||
var retval *Response
|
||||
var err2 error
|
||||
if retval, err2 = p.handler.KillTasks(args.Job, args.Instances); err2 != nil {
|
||||
if retval, err2 = p.handler.KillTasks(args.Job, args.Instances, args.Message); err2 != nil {
|
||||
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing killTasks: "+err2.Error())
|
||||
oprot.WriteMessageBegin("killTasks", thrift.EXCEPTION, seqId)
|
||||
x.Write(oprot)
|
||||
|
|
@ -3007,10 +3010,12 @@ func (p *AuroraSchedulerManagerRestartShardsResult) String() string {
|
|||
// Attributes:
|
||||
// - Job
|
||||
// - Instances
|
||||
// - Message
|
||||
type AuroraSchedulerManagerKillTasksArgs struct {
|
||||
// unused fields # 1 to 3
|
||||
Job *JobKey `thrift:"job,4" json:"job"`
|
||||
Instances map[int32]bool `thrift:"instances,5" json:"instances"`
|
||||
Message string `thrift:"message,6" json:"message"`
|
||||
}
|
||||
|
||||
func NewAuroraSchedulerManagerKillTasksArgs() *AuroraSchedulerManagerKillTasksArgs {
|
||||
|
|
@ -3029,6 +3034,10 @@ func (p *AuroraSchedulerManagerKillTasksArgs) GetJob() *JobKey {
|
|||
func (p *AuroraSchedulerManagerKillTasksArgs) GetInstances() map[int32]bool {
|
||||
return p.Instances
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) GetMessage() string {
|
||||
return p.Message
|
||||
}
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) IsSetJob() bool {
|
||||
return p.Job != nil
|
||||
}
|
||||
|
|
@ -3055,6 +3064,10 @@ func (p *AuroraSchedulerManagerKillTasksArgs) Read(iprot thrift.TProtocol) error
|
|||
if err := p.readField5(iprot); err != nil {
|
||||
return err
|
||||
}
|
||||
case 6:
|
||||
if err := p.readField6(iprot); err != nil {
|
||||
return err
|
||||
}
|
||||
default:
|
||||
if err := iprot.Skip(fieldTypeId); err != nil {
|
||||
return err
|
||||
|
|
@ -3100,6 +3113,15 @@ func (p *AuroraSchedulerManagerKillTasksArgs) readField5(iprot thrift.TProtocol)
|
|||
return nil
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) readField6(iprot thrift.TProtocol) error {
|
||||
if v, err := iprot.ReadString(); err != nil {
|
||||
return thrift.PrependError("error reading field 6: ", err)
|
||||
} else {
|
||||
p.Message = v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) Write(oprot thrift.TProtocol) error {
|
||||
if err := oprot.WriteStructBegin("killTasks_args"); err != nil {
|
||||
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
|
||||
|
|
@ -3110,6 +3132,9 @@ func (p *AuroraSchedulerManagerKillTasksArgs) Write(oprot thrift.TProtocol) erro
|
|||
if err := p.writeField5(oprot); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := p.writeField6(oprot); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := oprot.WriteFieldStop(); err != nil {
|
||||
return thrift.PrependError("write field stop error: ", err)
|
||||
}
|
||||
|
|
@ -3153,6 +3178,19 @@ func (p *AuroraSchedulerManagerKillTasksArgs) writeField5(oprot thrift.TProtocol
|
|||
return err
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) writeField6(oprot thrift.TProtocol) (err error) {
|
||||
if err := oprot.WriteFieldBegin("message", thrift.STRING, 6); err != nil {
|
||||
return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:message: ", p), err)
|
||||
}
|
||||
if err := oprot.WriteString(string(p.Message)); err != nil {
|
||||
return thrift.PrependError(fmt.Sprintf("%T.message (6) field write error: ", p), err)
|
||||
}
|
||||
if err := oprot.WriteFieldEnd(); err != nil {
|
||||
return thrift.PrependError(fmt.Sprintf("%T write field end error 6:message: ", p), err)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (p *AuroraSchedulerManagerKillTasksArgs) String() string {
|
||||
if p == nil {
|
||||
return "<nil>"
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ const GOOD_IDENTIFIER_PATTERN_JVM = "^[\\w\\-\\.]+$"
|
|||
const GOOD_IDENTIFIER_PATTERN_PYTHON = "^[\\w\\-\\.]+$"
|
||||
|
||||
var ACTIVE_JOB_UPDATE_STATES map[JobUpdateStatus]bool
|
||||
var AWAITNG_PULSE_JOB_UPDATE_STATES map[JobUpdateStatus]bool
|
||||
|
||||
const BYPASS_LEADER_REDIRECT_HEADER_NAME = "Bypass-Leader-Redirect"
|
||||
const TASK_FILESYSTEM_MOUNT_POINT = "taskfs"
|
||||
|
|
@ -77,4 +78,9 @@ func init() {
|
|||
10: true,
|
||||
}
|
||||
|
||||
AWAITNG_PULSE_JOB_UPDATE_STATES = map[JobUpdateStatus]bool{
|
||||
9: true,
|
||||
10: true,
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue