scheduler/api/thrift/gen-go/scoot/cloudscoot.go (5,219 lines of code) (raw):
// Autogenerated by Thrift Compiler (0.9.3)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
package scoot
import (
"bytes"
"fmt"
"github.com/apache/thrift/lib/go/thrift"
)
// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal
type CloudScoot interface {
// Parameters:
// - Job
RunJob(job *JobDefinition) (r *JobId, err error)
// Parameters:
// - JobId
GetStatus(jobId string) (r *JobStatus, err error)
// Parameters:
// - JobId
KillJob(jobId string) (r *JobStatus, err error)
// Parameters:
// - Req
OfflineWorker(req *OfflineWorkerReq) (err error)
// Parameters:
// - Req
ReinstateWorker(req *ReinstateWorkerReq) (err error)
GetSchedulerStatus() (r *SchedulerStatus, err error)
// Parameters:
// - MaxTasks
SetSchedulerStatus(maxTasks int32) (err error)
GetClassLoadPercents() (r map[string]int32, err error)
// Parameters:
// - LoadPercents
SetClassLoadPercents(loadPercents map[string]int32) (err error)
GetRequestorToClassMap() (r map[string]string, err error)
// Parameters:
// - RequestorToClassMap
SetRequestorToClassMap(requestorToClassMap map[string]string) (err error)
GetRebalanceMinimumDuration() (r int32, err error)
// Parameters:
// - DurationMin
SetRebalanceMinimumDuration(durationMin int32) (err error)
GetRebalanceThreshold() (r int32, err error)
// Parameters:
// - Threshold
SetRebalanceThreshold(threshold int32) (err error)
}
type CloudScootClient struct {
Transport thrift.TTransport
ProtocolFactory thrift.TProtocolFactory
InputProtocol thrift.TProtocol
OutputProtocol thrift.TProtocol
SeqId int32
}
func NewCloudScootClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *CloudScootClient {
return &CloudScootClient{Transport: t,
ProtocolFactory: f,
InputProtocol: f.GetProtocol(t),
OutputProtocol: f.GetProtocol(t),
SeqId: 0,
}
}
func NewCloudScootClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *CloudScootClient {
return &CloudScootClient{Transport: t,
ProtocolFactory: nil,
InputProtocol: iprot,
OutputProtocol: oprot,
SeqId: 0,
}
}
// Parameters:
// - Job
func (p *CloudScootClient) RunJob(job *JobDefinition) (r *JobId, err error) {
if err = p.sendRunJob(job); err != nil {
return
}
return p.recvRunJob()
}
func (p *CloudScootClient) sendRunJob(job *JobDefinition) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("RunJob", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootRunJobArgs{
Job: job,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvRunJob() (value *JobId, 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 != "RunJob" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "RunJob failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "RunJob failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error8 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error9 error
error9, err = error8.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error9
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "RunJob failed: invalid message type")
return
}
result := CloudScootRunJobResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Cnsn != nil {
err = result.Cnsn
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - JobId
func (p *CloudScootClient) GetStatus(jobId string) (r *JobStatus, err error) {
if err = p.sendGetStatus(jobId); err != nil {
return
}
return p.recvGetStatus()
}
func (p *CloudScootClient) sendGetStatus(jobId string) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetStatus", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetStatusArgs{
JobId: jobId,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetStatus() (value *JobStatus, 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 != "GetStatus" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetStatus failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetStatus failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error10 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error11 error
error11, err = error10.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error11
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetStatus failed: invalid message type")
return
}
result := CloudScootGetStatusResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - JobId
func (p *CloudScootClient) KillJob(jobId string) (r *JobStatus, err error) {
if err = p.sendKillJob(jobId); err != nil {
return
}
return p.recvKillJob()
}
func (p *CloudScootClient) sendKillJob(jobId string) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("KillJob", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootKillJobArgs{
JobId: jobId,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvKillJob() (value *JobStatus, 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 != "KillJob" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "KillJob failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "KillJob failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error12 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error13 error
error13, err = error12.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error13
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "KillJob failed: invalid message type")
return
}
result := CloudScootKillJobResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - Req
func (p *CloudScootClient) OfflineWorker(req *OfflineWorkerReq) (err error) {
if err = p.sendOfflineWorker(req); err != nil {
return
}
return p.recvOfflineWorker()
}
func (p *CloudScootClient) sendOfflineWorker(req *OfflineWorkerReq) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("OfflineWorker", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootOfflineWorkerArgs{
Req: req,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvOfflineWorker() (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 != "OfflineWorker" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "OfflineWorker failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "OfflineWorker failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error14 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error15 error
error15, err = error14.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error15
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "OfflineWorker failed: invalid message type")
return
}
result := CloudScootOfflineWorkerResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
// Parameters:
// - Req
func (p *CloudScootClient) ReinstateWorker(req *ReinstateWorkerReq) (err error) {
if err = p.sendReinstateWorker(req); err != nil {
return
}
return p.recvReinstateWorker()
}
func (p *CloudScootClient) sendReinstateWorker(req *ReinstateWorkerReq) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("ReinstateWorker", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootReinstateWorkerArgs{
Req: req,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvReinstateWorker() (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 != "ReinstateWorker" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "ReinstateWorker failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "ReinstateWorker failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error16 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error17 error
error17, err = error16.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error17
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "ReinstateWorker failed: invalid message type")
return
}
result := CloudScootReinstateWorkerResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
func (p *CloudScootClient) GetSchedulerStatus() (r *SchedulerStatus, err error) {
if err = p.sendGetSchedulerStatus(); err != nil {
return
}
return p.recvGetSchedulerStatus()
}
func (p *CloudScootClient) sendGetSchedulerStatus() (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetSchedulerStatus", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetSchedulerStatusArgs{}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetSchedulerStatus() (value *SchedulerStatus, 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 != "GetSchedulerStatus" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetSchedulerStatus failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetSchedulerStatus failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error18 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error19 error
error19, err = error18.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error19
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetSchedulerStatus failed: invalid message type")
return
}
result := CloudScootGetSchedulerStatusResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Err != nil {
err = result.Err
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - MaxTasks
func (p *CloudScootClient) SetSchedulerStatus(maxTasks int32) (err error) {
if err = p.sendSetSchedulerStatus(maxTasks); err != nil {
return
}
return p.recvSetSchedulerStatus()
}
func (p *CloudScootClient) sendSetSchedulerStatus(maxTasks int32) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("SetSchedulerStatus", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootSetSchedulerStatusArgs{
MaxTasks: maxTasks,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvSetSchedulerStatus() (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 != "SetSchedulerStatus" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "SetSchedulerStatus failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "SetSchedulerStatus failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error20 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error21 error
error21, err = error20.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error21
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "SetSchedulerStatus failed: invalid message type")
return
}
result := CloudScootSetSchedulerStatusResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
func (p *CloudScootClient) GetClassLoadPercents() (r map[string]int32, err error) {
if err = p.sendGetClassLoadPercents(); err != nil {
return
}
return p.recvGetClassLoadPercents()
}
func (p *CloudScootClient) sendGetClassLoadPercents() (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetClassLoadPercents", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetClassLoadPercentsArgs{}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetClassLoadPercents() (value map[string]int32, 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 != "GetClassLoadPercents" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetClassLoadPercents failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetClassLoadPercents failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error22 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error23 error
error23, err = error22.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error23
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetClassLoadPercents failed: invalid message type")
return
}
result := CloudScootGetClassLoadPercentsResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - LoadPercents
func (p *CloudScootClient) SetClassLoadPercents(loadPercents map[string]int32) (err error) {
if err = p.sendSetClassLoadPercents(loadPercents); err != nil {
return
}
return p.recvSetClassLoadPercents()
}
func (p *CloudScootClient) sendSetClassLoadPercents(loadPercents map[string]int32) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("SetClassLoadPercents", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootSetClassLoadPercentsArgs{
LoadPercents: loadPercents,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvSetClassLoadPercents() (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 != "SetClassLoadPercents" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "SetClassLoadPercents failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "SetClassLoadPercents failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error24 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error25 error
error25, err = error24.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error25
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "SetClassLoadPercents failed: invalid message type")
return
}
result := CloudScootSetClassLoadPercentsResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
func (p *CloudScootClient) GetRequestorToClassMap() (r map[string]string, err error) {
if err = p.sendGetRequestorToClassMap(); err != nil {
return
}
return p.recvGetRequestorToClassMap()
}
func (p *CloudScootClient) sendGetRequestorToClassMap() (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetRequestorToClassMap", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetRequestorToClassMapArgs{}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetRequestorToClassMap() (value map[string]string, 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 != "GetRequestorToClassMap" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetRequestorToClassMap failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetRequestorToClassMap failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error26 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error27 error
error27, err = error26.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error27
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetRequestorToClassMap failed: invalid message type")
return
}
result := CloudScootGetRequestorToClassMapResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - RequestorToClassMap
func (p *CloudScootClient) SetRequestorToClassMap(requestorToClassMap map[string]string) (err error) {
if err = p.sendSetRequestorToClassMap(requestorToClassMap); err != nil {
return
}
return p.recvSetRequestorToClassMap()
}
func (p *CloudScootClient) sendSetRequestorToClassMap(requestorToClassMap map[string]string) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("SetRequestorToClassMap", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootSetRequestorToClassMapArgs{
RequestorToClassMap: requestorToClassMap,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvSetRequestorToClassMap() (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 != "SetRequestorToClassMap" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "SetRequestorToClassMap failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "SetRequestorToClassMap failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error28 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error29 error
error29, err = error28.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error29
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "SetRequestorToClassMap failed: invalid message type")
return
}
result := CloudScootSetRequestorToClassMapResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
func (p *CloudScootClient) GetRebalanceMinimumDuration() (r int32, err error) {
if err = p.sendGetRebalanceMinimumDuration(); err != nil {
return
}
return p.recvGetRebalanceMinimumDuration()
}
func (p *CloudScootClient) sendGetRebalanceMinimumDuration() (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetRebalanceMinimumDuration", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetRebalanceMinimumDurationArgs{}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetRebalanceMinimumDuration() (value int32, 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 != "GetRebalanceMinimumDuration" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetRebalanceMinimumDuration failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetRebalanceMinimumDuration failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error30 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error31 error
error31, err = error30.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error31
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetRebalanceMinimumDuration failed: invalid message type")
return
}
result := CloudScootGetRebalanceMinimumDurationResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - DurationMin
func (p *CloudScootClient) SetRebalanceMinimumDuration(durationMin int32) (err error) {
if err = p.sendSetRebalanceMinimumDuration(durationMin); err != nil {
return
}
return p.recvSetRebalanceMinimumDuration()
}
func (p *CloudScootClient) sendSetRebalanceMinimumDuration(durationMin int32) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("SetRebalanceMinimumDuration", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootSetRebalanceMinimumDurationArgs{
DurationMin: durationMin,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvSetRebalanceMinimumDuration() (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 != "SetRebalanceMinimumDuration" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "SetRebalanceMinimumDuration failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "SetRebalanceMinimumDuration failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error32 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error33 error
error33, err = error32.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error33
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "SetRebalanceMinimumDuration failed: invalid message type")
return
}
result := CloudScootSetRebalanceMinimumDurationResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
func (p *CloudScootClient) GetRebalanceThreshold() (r int32, err error) {
if err = p.sendGetRebalanceThreshold(); err != nil {
return
}
return p.recvGetRebalanceThreshold()
}
func (p *CloudScootClient) sendGetRebalanceThreshold() (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("GetRebalanceThreshold", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootGetRebalanceThresholdArgs{}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvGetRebalanceThreshold() (value int32, 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 != "GetRebalanceThreshold" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "GetRebalanceThreshold failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "GetRebalanceThreshold failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error34 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error35 error
error35, err = error34.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error35
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "GetRebalanceThreshold failed: invalid message type")
return
}
result := CloudScootGetRebalanceThresholdResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
}
value = result.GetSuccess()
return
}
// Parameters:
// - Threshold
func (p *CloudScootClient) SetRebalanceThreshold(threshold int32) (err error) {
if err = p.sendSetRebalanceThreshold(threshold); err != nil {
return
}
return p.recvSetRebalanceThreshold()
}
func (p *CloudScootClient) sendSetRebalanceThreshold(threshold int32) (err error) {
oprot := p.OutputProtocol
if oprot == nil {
oprot = p.ProtocolFactory.GetProtocol(p.Transport)
p.OutputProtocol = oprot
}
p.SeqId++
if err = oprot.WriteMessageBegin("SetRebalanceThreshold", thrift.CALL, p.SeqId); err != nil {
return
}
args := CloudScootSetRebalanceThresholdArgs{
Threshold: threshold,
}
if err = args.Write(oprot); err != nil {
return
}
if err = oprot.WriteMessageEnd(); err != nil {
return
}
return oprot.Flush()
}
func (p *CloudScootClient) recvSetRebalanceThreshold() (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 != "SetRebalanceThreshold" {
err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "SetRebalanceThreshold failed: wrong method name")
return
}
if p.SeqId != seqId {
err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "SetRebalanceThreshold failed: out of sequence response")
return
}
if mTypeId == thrift.EXCEPTION {
error36 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
var error37 error
error37, err = error36.Read(iprot)
if err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
err = error37
return
}
if mTypeId != thrift.REPLY {
err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "SetRebalanceThreshold failed: invalid message type")
return
}
result := CloudScootSetRebalanceThresholdResult{}
if err = result.Read(iprot); err != nil {
return
}
if err = iprot.ReadMessageEnd(); err != nil {
return
}
if result.Ir != nil {
err = result.Ir
return
} else if result.Err != nil {
err = result.Err
return
}
return
}
type CloudScootProcessor struct {
processorMap map[string]thrift.TProcessorFunction
handler CloudScoot
}
func (p *CloudScootProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
p.processorMap[key] = processor
}
func (p *CloudScootProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
processor, ok = p.processorMap[key]
return processor, ok
}
func (p *CloudScootProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
return p.processorMap
}
func NewCloudScootProcessor(handler CloudScoot) *CloudScootProcessor {
self38 := &CloudScootProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
self38.processorMap["RunJob"] = &cloudScootProcessorRunJob{handler: handler}
self38.processorMap["GetStatus"] = &cloudScootProcessorGetStatus{handler: handler}
self38.processorMap["KillJob"] = &cloudScootProcessorKillJob{handler: handler}
self38.processorMap["OfflineWorker"] = &cloudScootProcessorOfflineWorker{handler: handler}
self38.processorMap["ReinstateWorker"] = &cloudScootProcessorReinstateWorker{handler: handler}
self38.processorMap["GetSchedulerStatus"] = &cloudScootProcessorGetSchedulerStatus{handler: handler}
self38.processorMap["SetSchedulerStatus"] = &cloudScootProcessorSetSchedulerStatus{handler: handler}
self38.processorMap["GetClassLoadPercents"] = &cloudScootProcessorGetClassLoadPercents{handler: handler}
self38.processorMap["SetClassLoadPercents"] = &cloudScootProcessorSetClassLoadPercents{handler: handler}
self38.processorMap["GetRequestorToClassMap"] = &cloudScootProcessorGetRequestorToClassMap{handler: handler}
self38.processorMap["SetRequestorToClassMap"] = &cloudScootProcessorSetRequestorToClassMap{handler: handler}
self38.processorMap["GetRebalanceMinimumDuration"] = &cloudScootProcessorGetRebalanceMinimumDuration{handler: handler}
self38.processorMap["SetRebalanceMinimumDuration"] = &cloudScootProcessorSetRebalanceMinimumDuration{handler: handler}
self38.processorMap["GetRebalanceThreshold"] = &cloudScootProcessorGetRebalanceThreshold{handler: handler}
self38.processorMap["SetRebalanceThreshold"] = &cloudScootProcessorSetRebalanceThreshold{handler: handler}
return self38
}
func (p *CloudScootProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
name, _, seqId, err := iprot.ReadMessageBegin()
if err != nil {
return false, err
}
if processor, ok := p.GetProcessorFunction(name); ok {
return processor.Process(seqId, iprot, oprot)
}
iprot.Skip(thrift.STRUCT)
iprot.ReadMessageEnd()
x39 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
x39.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, x39
}
type cloudScootProcessorRunJob struct {
handler CloudScoot
}
func (p *cloudScootProcessorRunJob) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootRunJobArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("RunJob", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootRunJobResult{}
var retval *JobId
var err2 error
if retval, err2 = p.handler.RunJob(args.Job); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *CanNotScheduleNow:
result.Cnsn = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing RunJob: "+err2.Error())
oprot.WriteMessageBegin("RunJob", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("RunJob", 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 cloudScootProcessorGetStatus struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetStatus) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetStatusArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetStatusResult{}
var retval *JobStatus
var err2 error
if retval, err2 = p.handler.GetStatus(args.JobId); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetStatus: "+err2.Error())
oprot.WriteMessageBegin("GetStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("GetStatus", 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 cloudScootProcessorKillJob struct {
handler CloudScoot
}
func (p *cloudScootProcessorKillJob) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootKillJobArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("KillJob", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootKillJobResult{}
var retval *JobStatus
var err2 error
if retval, err2 = p.handler.KillJob(args.JobId); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing KillJob: "+err2.Error())
oprot.WriteMessageBegin("KillJob", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("KillJob", 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 cloudScootProcessorOfflineWorker struct {
handler CloudScoot
}
func (p *cloudScootProcessorOfflineWorker) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootOfflineWorkerArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("OfflineWorker", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootOfflineWorkerResult{}
var err2 error
if err2 = p.handler.OfflineWorker(args.Req); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing OfflineWorker: "+err2.Error())
oprot.WriteMessageBegin("OfflineWorker", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("OfflineWorker", 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 cloudScootProcessorReinstateWorker struct {
handler CloudScoot
}
func (p *cloudScootProcessorReinstateWorker) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootReinstateWorkerArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("ReinstateWorker", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootReinstateWorkerResult{}
var err2 error
if err2 = p.handler.ReinstateWorker(args.Req); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ReinstateWorker: "+err2.Error())
oprot.WriteMessageBegin("ReinstateWorker", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("ReinstateWorker", 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 cloudScootProcessorGetSchedulerStatus struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetSchedulerStatus) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetSchedulerStatusArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetSchedulerStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetSchedulerStatusResult{}
var retval *SchedulerStatus
var err2 error
if retval, err2 = p.handler.GetSchedulerStatus(); err2 != nil {
switch v := err2.(type) {
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetSchedulerStatus: "+err2.Error())
oprot.WriteMessageBegin("GetSchedulerStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("GetSchedulerStatus", 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 cloudScootProcessorSetSchedulerStatus struct {
handler CloudScoot
}
func (p *cloudScootProcessorSetSchedulerStatus) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootSetSchedulerStatusArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("SetSchedulerStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootSetSchedulerStatusResult{}
var err2 error
if err2 = p.handler.SetSchedulerStatus(args.MaxTasks); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SetSchedulerStatus: "+err2.Error())
oprot.WriteMessageBegin("SetSchedulerStatus", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("SetSchedulerStatus", 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 cloudScootProcessorGetClassLoadPercents struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetClassLoadPercents) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetClassLoadPercentsArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetClassLoadPercents", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetClassLoadPercentsResult{}
var retval map[string]int32
var err2 error
if retval, err2 = p.handler.GetClassLoadPercents(); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetClassLoadPercents: "+err2.Error())
oprot.WriteMessageBegin("GetClassLoadPercents", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("GetClassLoadPercents", 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 cloudScootProcessorSetClassLoadPercents struct {
handler CloudScoot
}
func (p *cloudScootProcessorSetClassLoadPercents) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootSetClassLoadPercentsArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("SetClassLoadPercents", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootSetClassLoadPercentsResult{}
var err2 error
if err2 = p.handler.SetClassLoadPercents(args.LoadPercents); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SetClassLoadPercents: "+err2.Error())
oprot.WriteMessageBegin("SetClassLoadPercents", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("SetClassLoadPercents", 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 cloudScootProcessorGetRequestorToClassMap struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetRequestorToClassMap) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetRequestorToClassMapArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetRequestorToClassMap", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetRequestorToClassMapResult{}
var retval map[string]string
var err2 error
if retval, err2 = p.handler.GetRequestorToClassMap(); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetRequestorToClassMap: "+err2.Error())
oprot.WriteMessageBegin("GetRequestorToClassMap", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = retval
}
if err2 = oprot.WriteMessageBegin("GetRequestorToClassMap", 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 cloudScootProcessorSetRequestorToClassMap struct {
handler CloudScoot
}
func (p *cloudScootProcessorSetRequestorToClassMap) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootSetRequestorToClassMapArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("SetRequestorToClassMap", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootSetRequestorToClassMapResult{}
var err2 error
if err2 = p.handler.SetRequestorToClassMap(args.RequestorToClassMap); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SetRequestorToClassMap: "+err2.Error())
oprot.WriteMessageBegin("SetRequestorToClassMap", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("SetRequestorToClassMap", 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 cloudScootProcessorGetRebalanceMinimumDuration struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetRebalanceMinimumDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetRebalanceMinimumDurationArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetRebalanceMinimumDuration", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetRebalanceMinimumDurationResult{}
var retval int32
var err2 error
if retval, err2 = p.handler.GetRebalanceMinimumDuration(); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetRebalanceMinimumDuration: "+err2.Error())
oprot.WriteMessageBegin("GetRebalanceMinimumDuration", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = &retval
}
if err2 = oprot.WriteMessageBegin("GetRebalanceMinimumDuration", 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 cloudScootProcessorSetRebalanceMinimumDuration struct {
handler CloudScoot
}
func (p *cloudScootProcessorSetRebalanceMinimumDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootSetRebalanceMinimumDurationArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("SetRebalanceMinimumDuration", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootSetRebalanceMinimumDurationResult{}
var err2 error
if err2 = p.handler.SetRebalanceMinimumDuration(args.DurationMin); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SetRebalanceMinimumDuration: "+err2.Error())
oprot.WriteMessageBegin("SetRebalanceMinimumDuration", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("SetRebalanceMinimumDuration", 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 cloudScootProcessorGetRebalanceThreshold struct {
handler CloudScoot
}
func (p *cloudScootProcessorGetRebalanceThreshold) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootGetRebalanceThresholdArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("GetRebalanceThreshold", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootGetRebalanceThresholdResult{}
var retval int32
var err2 error
if retval, err2 = p.handler.GetRebalanceThreshold(); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetRebalanceThreshold: "+err2.Error())
oprot.WriteMessageBegin("GetRebalanceThreshold", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
} else {
result.Success = &retval
}
if err2 = oprot.WriteMessageBegin("GetRebalanceThreshold", 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 cloudScootProcessorSetRebalanceThreshold struct {
handler CloudScoot
}
func (p *cloudScootProcessorSetRebalanceThreshold) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
args := CloudScootSetRebalanceThresholdArgs{}
if err = args.Read(iprot); err != nil {
iprot.ReadMessageEnd()
x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
oprot.WriteMessageBegin("SetRebalanceThreshold", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return false, err
}
iprot.ReadMessageEnd()
result := CloudScootSetRebalanceThresholdResult{}
var err2 error
if err2 = p.handler.SetRebalanceThreshold(args.Threshold); err2 != nil {
switch v := err2.(type) {
case *InvalidRequest:
result.Ir = v
case *ScootServerError:
result.Err = v
default:
x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SetRebalanceThreshold: "+err2.Error())
oprot.WriteMessageBegin("SetRebalanceThreshold", thrift.EXCEPTION, seqId)
x.Write(oprot)
oprot.WriteMessageEnd()
oprot.Flush()
return true, err2
}
}
if err2 = oprot.WriteMessageBegin("SetRebalanceThreshold", 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
}
// HELPER FUNCTIONS AND STRUCTURES
// Attributes:
// - Job
type CloudScootRunJobArgs struct {
Job *JobDefinition `thrift:"job,1" json:"job"`
}
func NewCloudScootRunJobArgs() *CloudScootRunJobArgs {
return &CloudScootRunJobArgs{}
}
var CloudScootRunJobArgs_Job_DEFAULT *JobDefinition
func (p *CloudScootRunJobArgs) GetJob() *JobDefinition {
if !p.IsSetJob() {
return CloudScootRunJobArgs_Job_DEFAULT
}
return p.Job
}
func (p *CloudScootRunJobArgs) IsSetJob() bool {
return p.Job != nil
}
func (p *CloudScootRunJobArgs) 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
}
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 *CloudScootRunJobArgs) readField1(iprot thrift.TProtocol) error {
p.Job = &JobDefinition{}
if err := p.Job.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Job), err)
}
return nil
}
func (p *CloudScootRunJobArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("RunJob_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 := 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 *CloudScootRunJobArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("job", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:job: ", p), err)
}
if err := p.Job.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Job), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:job: ", p), err)
}
return err
}
func (p *CloudScootRunJobArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootRunJobArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
// - Cnsn
type CloudScootRunJobResult struct {
Success *JobId `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Cnsn *CanNotScheduleNow `thrift:"cnsn,2" json:"cnsn,omitempty"`
}
func NewCloudScootRunJobResult() *CloudScootRunJobResult {
return &CloudScootRunJobResult{}
}
var CloudScootRunJobResult_Success_DEFAULT *JobId
func (p *CloudScootRunJobResult) GetSuccess() *JobId {
if !p.IsSetSuccess() {
return CloudScootRunJobResult_Success_DEFAULT
}
return p.Success
}
var CloudScootRunJobResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootRunJobResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootRunJobResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootRunJobResult_Cnsn_DEFAULT *CanNotScheduleNow
func (p *CloudScootRunJobResult) GetCnsn() *CanNotScheduleNow {
if !p.IsSetCnsn() {
return CloudScootRunJobResult_Cnsn_DEFAULT
}
return p.Cnsn
}
func (p *CloudScootRunJobResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootRunJobResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootRunJobResult) IsSetCnsn() bool {
return p.Cnsn != nil
}
func (p *CloudScootRunJobResult) 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
}
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 *CloudScootRunJobResult) readField0(iprot thrift.TProtocol) error {
p.Success = &JobId{}
if err := p.Success.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
}
return nil
}
func (p *CloudScootRunJobResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootRunJobResult) readField2(iprot thrift.TProtocol) error {
p.Cnsn = &CanNotScheduleNow{}
if err := p.Cnsn.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Cnsn), err)
}
return nil
}
func (p *CloudScootRunJobResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("RunJob_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 := 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 *CloudScootRunJobResult) 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 *CloudScootRunJobResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootRunJobResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetCnsn() {
if err := oprot.WriteFieldBegin("cnsn", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:cnsn: ", p), err)
}
if err := p.Cnsn.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Cnsn), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:cnsn: ", p), err)
}
}
return err
}
func (p *CloudScootRunJobResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootRunJobResult(%+v)", *p)
}
// Attributes:
// - JobId
type CloudScootGetStatusArgs struct {
JobId string `thrift:"jobId,1" json:"jobId"`
}
func NewCloudScootGetStatusArgs() *CloudScootGetStatusArgs {
return &CloudScootGetStatusArgs{}
}
func (p *CloudScootGetStatusArgs) GetJobId() string {
return p.JobId
}
func (p *CloudScootGetStatusArgs) 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
}
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 *CloudScootGetStatusArgs) readField1(iprot thrift.TProtocol) error {
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 1: ", err)
} else {
p.JobId = v
}
return nil
}
func (p *CloudScootGetStatusArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetStatus_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 := 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 *CloudScootGetStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("jobId", thrift.STRING, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:jobId: ", p), err)
}
if err := oprot.WriteString(string(p.JobId)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.jobId (1) field write error: ", p), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:jobId: ", p), err)
}
return err
}
func (p *CloudScootGetStatusArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetStatusArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
// - Err
type CloudScootGetStatusResult struct {
Success *JobStatus `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootGetStatusResult() *CloudScootGetStatusResult {
return &CloudScootGetStatusResult{}
}
var CloudScootGetStatusResult_Success_DEFAULT *JobStatus
func (p *CloudScootGetStatusResult) GetSuccess() *JobStatus {
if !p.IsSetSuccess() {
return CloudScootGetStatusResult_Success_DEFAULT
}
return p.Success
}
var CloudScootGetStatusResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootGetStatusResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootGetStatusResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootGetStatusResult_Err_DEFAULT *ScootServerError
func (p *CloudScootGetStatusResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootGetStatusResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootGetStatusResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetStatusResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootGetStatusResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootGetStatusResult) 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
}
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 *CloudScootGetStatusResult) readField0(iprot thrift.TProtocol) error {
p.Success = &JobStatus{}
if err := p.Success.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
}
return nil
}
func (p *CloudScootGetStatusResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootGetStatusResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootGetStatusResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetStatus_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 := 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 *CloudScootGetStatusResult) 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 *CloudScootGetStatusResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootGetStatusResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootGetStatusResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetStatusResult(%+v)", *p)
}
// Attributes:
// - JobId
type CloudScootKillJobArgs struct {
JobId string `thrift:"jobId,1" json:"jobId"`
}
func NewCloudScootKillJobArgs() *CloudScootKillJobArgs {
return &CloudScootKillJobArgs{}
}
func (p *CloudScootKillJobArgs) GetJobId() string {
return p.JobId
}
func (p *CloudScootKillJobArgs) 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
}
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 *CloudScootKillJobArgs) readField1(iprot thrift.TProtocol) error {
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 1: ", err)
} else {
p.JobId = v
}
return nil
}
func (p *CloudScootKillJobArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("KillJob_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 := 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 *CloudScootKillJobArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("jobId", thrift.STRING, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:jobId: ", p), err)
}
if err := oprot.WriteString(string(p.JobId)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.jobId (1) field write error: ", p), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:jobId: ", p), err)
}
return err
}
func (p *CloudScootKillJobArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootKillJobArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
// - Err
type CloudScootKillJobResult struct {
Success *JobStatus `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootKillJobResult() *CloudScootKillJobResult {
return &CloudScootKillJobResult{}
}
var CloudScootKillJobResult_Success_DEFAULT *JobStatus
func (p *CloudScootKillJobResult) GetSuccess() *JobStatus {
if !p.IsSetSuccess() {
return CloudScootKillJobResult_Success_DEFAULT
}
return p.Success
}
var CloudScootKillJobResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootKillJobResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootKillJobResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootKillJobResult_Err_DEFAULT *ScootServerError
func (p *CloudScootKillJobResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootKillJobResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootKillJobResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootKillJobResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootKillJobResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootKillJobResult) 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
}
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 *CloudScootKillJobResult) readField0(iprot thrift.TProtocol) error {
p.Success = &JobStatus{}
if err := p.Success.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
}
return nil
}
func (p *CloudScootKillJobResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootKillJobResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootKillJobResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("KillJob_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 := 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 *CloudScootKillJobResult) 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 *CloudScootKillJobResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootKillJobResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootKillJobResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootKillJobResult(%+v)", *p)
}
// Attributes:
// - Req
type CloudScootOfflineWorkerArgs struct {
Req *OfflineWorkerReq `thrift:"req,1" json:"req"`
}
func NewCloudScootOfflineWorkerArgs() *CloudScootOfflineWorkerArgs {
return &CloudScootOfflineWorkerArgs{}
}
var CloudScootOfflineWorkerArgs_Req_DEFAULT *OfflineWorkerReq
func (p *CloudScootOfflineWorkerArgs) GetReq() *OfflineWorkerReq {
if !p.IsSetReq() {
return CloudScootOfflineWorkerArgs_Req_DEFAULT
}
return p.Req
}
func (p *CloudScootOfflineWorkerArgs) IsSetReq() bool {
return p.Req != nil
}
func (p *CloudScootOfflineWorkerArgs) 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
}
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 *CloudScootOfflineWorkerArgs) readField1(iprot thrift.TProtocol) error {
p.Req = &OfflineWorkerReq{}
if err := p.Req.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
}
return nil
}
func (p *CloudScootOfflineWorkerArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("OfflineWorker_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 := 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 *CloudScootOfflineWorkerArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
}
if err := p.Req.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
}
return err
}
func (p *CloudScootOfflineWorkerArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootOfflineWorkerArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootOfflineWorkerResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootOfflineWorkerResult() *CloudScootOfflineWorkerResult {
return &CloudScootOfflineWorkerResult{}
}
var CloudScootOfflineWorkerResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootOfflineWorkerResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootOfflineWorkerResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootOfflineWorkerResult_Err_DEFAULT *ScootServerError
func (p *CloudScootOfflineWorkerResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootOfflineWorkerResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootOfflineWorkerResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootOfflineWorkerResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootOfflineWorkerResult) 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 *CloudScootOfflineWorkerResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootOfflineWorkerResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootOfflineWorkerResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("OfflineWorker_result"); 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 *CloudScootOfflineWorkerResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootOfflineWorkerResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootOfflineWorkerResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootOfflineWorkerResult(%+v)", *p)
}
// Attributes:
// - Req
type CloudScootReinstateWorkerArgs struct {
Req *ReinstateWorkerReq `thrift:"req,1" json:"req"`
}
func NewCloudScootReinstateWorkerArgs() *CloudScootReinstateWorkerArgs {
return &CloudScootReinstateWorkerArgs{}
}
var CloudScootReinstateWorkerArgs_Req_DEFAULT *ReinstateWorkerReq
func (p *CloudScootReinstateWorkerArgs) GetReq() *ReinstateWorkerReq {
if !p.IsSetReq() {
return CloudScootReinstateWorkerArgs_Req_DEFAULT
}
return p.Req
}
func (p *CloudScootReinstateWorkerArgs) IsSetReq() bool {
return p.Req != nil
}
func (p *CloudScootReinstateWorkerArgs) 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
}
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 *CloudScootReinstateWorkerArgs) readField1(iprot thrift.TProtocol) error {
p.Req = &ReinstateWorkerReq{}
if err := p.Req.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err)
}
return nil
}
func (p *CloudScootReinstateWorkerArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("ReinstateWorker_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 := 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 *CloudScootReinstateWorkerArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:req: ", p), err)
}
if err := p.Req.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Req), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:req: ", p), err)
}
return err
}
func (p *CloudScootReinstateWorkerArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootReinstateWorkerArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootReinstateWorkerResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootReinstateWorkerResult() *CloudScootReinstateWorkerResult {
return &CloudScootReinstateWorkerResult{}
}
var CloudScootReinstateWorkerResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootReinstateWorkerResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootReinstateWorkerResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootReinstateWorkerResult_Err_DEFAULT *ScootServerError
func (p *CloudScootReinstateWorkerResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootReinstateWorkerResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootReinstateWorkerResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootReinstateWorkerResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootReinstateWorkerResult) 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 *CloudScootReinstateWorkerResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootReinstateWorkerResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootReinstateWorkerResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("ReinstateWorker_result"); 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 *CloudScootReinstateWorkerResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootReinstateWorkerResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootReinstateWorkerResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootReinstateWorkerResult(%+v)", *p)
}
type CloudScootGetSchedulerStatusArgs struct {
}
func NewCloudScootGetSchedulerStatusArgs() *CloudScootGetSchedulerStatusArgs {
return &CloudScootGetSchedulerStatusArgs{}
}
func (p *CloudScootGetSchedulerStatusArgs) 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
}
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 *CloudScootGetSchedulerStatusArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetSchedulerStatus_args"); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *CloudScootGetSchedulerStatusArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetSchedulerStatusArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Err
type CloudScootGetSchedulerStatusResult struct {
Success *SchedulerStatus `thrift:"success,0" json:"success,omitempty"`
Err *ScootServerError `thrift:"err,1" json:"err,omitempty"`
}
func NewCloudScootGetSchedulerStatusResult() *CloudScootGetSchedulerStatusResult {
return &CloudScootGetSchedulerStatusResult{}
}
var CloudScootGetSchedulerStatusResult_Success_DEFAULT *SchedulerStatus
func (p *CloudScootGetSchedulerStatusResult) GetSuccess() *SchedulerStatus {
if !p.IsSetSuccess() {
return CloudScootGetSchedulerStatusResult_Success_DEFAULT
}
return p.Success
}
var CloudScootGetSchedulerStatusResult_Err_DEFAULT *ScootServerError
func (p *CloudScootGetSchedulerStatusResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootGetSchedulerStatusResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootGetSchedulerStatusResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetSchedulerStatusResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootGetSchedulerStatusResult) 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
}
case 1:
if err := p.readField1(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 *CloudScootGetSchedulerStatusResult) readField0(iprot thrift.TProtocol) error {
p.Success = &SchedulerStatus{}
if err := p.Success.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
}
return nil
}
func (p *CloudScootGetSchedulerStatusResult) readField1(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootGetSchedulerStatusResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetSchedulerStatus_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 := p.writeField1(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 *CloudScootGetSchedulerStatusResult) 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 *CloudScootGetSchedulerStatusResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:err: ", p), err)
}
}
return err
}
func (p *CloudScootGetSchedulerStatusResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetSchedulerStatusResult(%+v)", *p)
}
// Attributes:
// - MaxTasks
type CloudScootSetSchedulerStatusArgs struct {
MaxTasks int32 `thrift:"maxTasks,1" json:"maxTasks"`
}
func NewCloudScootSetSchedulerStatusArgs() *CloudScootSetSchedulerStatusArgs {
return &CloudScootSetSchedulerStatusArgs{}
}
func (p *CloudScootSetSchedulerStatusArgs) GetMaxTasks() int32 {
return p.MaxTasks
}
func (p *CloudScootSetSchedulerStatusArgs) 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
}
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 *CloudScootSetSchedulerStatusArgs) readField1(iprot thrift.TProtocol) error {
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 1: ", err)
} else {
p.MaxTasks = v
}
return nil
}
func (p *CloudScootSetSchedulerStatusArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetSchedulerStatus_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 := 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 *CloudScootSetSchedulerStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("maxTasks", thrift.I32, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:maxTasks: ", p), err)
}
if err := oprot.WriteI32(int32(p.MaxTasks)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.maxTasks (1) field write error: ", p), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:maxTasks: ", p), err)
}
return err
}
func (p *CloudScootSetSchedulerStatusArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetSchedulerStatusArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootSetSchedulerStatusResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootSetSchedulerStatusResult() *CloudScootSetSchedulerStatusResult {
return &CloudScootSetSchedulerStatusResult{}
}
var CloudScootSetSchedulerStatusResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootSetSchedulerStatusResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootSetSchedulerStatusResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootSetSchedulerStatusResult_Err_DEFAULT *ScootServerError
func (p *CloudScootSetSchedulerStatusResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootSetSchedulerStatusResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootSetSchedulerStatusResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootSetSchedulerStatusResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootSetSchedulerStatusResult) 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 *CloudScootSetSchedulerStatusResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootSetSchedulerStatusResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootSetSchedulerStatusResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetSchedulerStatus_result"); 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 *CloudScootSetSchedulerStatusResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootSetSchedulerStatusResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootSetSchedulerStatusResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetSchedulerStatusResult(%+v)", *p)
}
type CloudScootGetClassLoadPercentsArgs struct {
}
func NewCloudScootGetClassLoadPercentsArgs() *CloudScootGetClassLoadPercentsArgs {
return &CloudScootGetClassLoadPercentsArgs{}
}
func (p *CloudScootGetClassLoadPercentsArgs) 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
}
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 *CloudScootGetClassLoadPercentsArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetClassLoadPercents_args"); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *CloudScootGetClassLoadPercentsArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetClassLoadPercentsArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
type CloudScootGetClassLoadPercentsResult struct {
Success map[string]int32 `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
}
func NewCloudScootGetClassLoadPercentsResult() *CloudScootGetClassLoadPercentsResult {
return &CloudScootGetClassLoadPercentsResult{}
}
var CloudScootGetClassLoadPercentsResult_Success_DEFAULT map[string]int32
func (p *CloudScootGetClassLoadPercentsResult) GetSuccess() map[string]int32 {
return p.Success
}
var CloudScootGetClassLoadPercentsResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootGetClassLoadPercentsResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootGetClassLoadPercentsResult_Ir_DEFAULT
}
return p.Ir
}
func (p *CloudScootGetClassLoadPercentsResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetClassLoadPercentsResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootGetClassLoadPercentsResult) 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
}
case 1:
if err := p.readField1(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 *CloudScootGetClassLoadPercentsResult) readField0(iprot thrift.TProtocol) error {
_, _, size, err := iprot.ReadMapBegin()
if err != nil {
return thrift.PrependError("error reading map begin: ", err)
}
tMap := make(map[string]int32, size)
p.Success = tMap
for i := 0; i < size; i++ {
var _key40 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_key40 = v
}
var _val41 int32
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_val41 = v
}
p.Success[_key40] = _val41
}
if err := iprot.ReadMapEnd(); err != nil {
return thrift.PrependError("error reading map end: ", err)
}
return nil
}
func (p *CloudScootGetClassLoadPercentsResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootGetClassLoadPercentsResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetClassLoadPercents_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 := p.writeField1(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 *CloudScootGetClassLoadPercentsResult) writeField0(oprot thrift.TProtocol) (err error) {
if p.IsSetSuccess() {
if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
}
if err := oprot.WriteMapBegin(thrift.STRING, thrift.I32, len(p.Success)); err != nil {
return thrift.PrependError("error writing map begin: ", err)
}
for k, v := range p.Success {
if err := oprot.WriteString(string(k)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
if err := oprot.WriteI32(int32(v)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
}
if err := oprot.WriteMapEnd(); err != nil {
return thrift.PrependError("error writing map end: ", 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 *CloudScootGetClassLoadPercentsResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootGetClassLoadPercentsResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetClassLoadPercentsResult(%+v)", *p)
}
// Attributes:
// - LoadPercents
type CloudScootSetClassLoadPercentsArgs struct {
LoadPercents map[string]int32 `thrift:"loadPercents,1" json:"loadPercents"`
}
func NewCloudScootSetClassLoadPercentsArgs() *CloudScootSetClassLoadPercentsArgs {
return &CloudScootSetClassLoadPercentsArgs{}
}
func (p *CloudScootSetClassLoadPercentsArgs) GetLoadPercents() map[string]int32 {
return p.LoadPercents
}
func (p *CloudScootSetClassLoadPercentsArgs) 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
}
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 *CloudScootSetClassLoadPercentsArgs) readField1(iprot thrift.TProtocol) error {
_, _, size, err := iprot.ReadMapBegin()
if err != nil {
return thrift.PrependError("error reading map begin: ", err)
}
tMap := make(map[string]int32, size)
p.LoadPercents = tMap
for i := 0; i < size; i++ {
var _key42 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_key42 = v
}
var _val43 int32
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_val43 = v
}
p.LoadPercents[_key42] = _val43
}
if err := iprot.ReadMapEnd(); err != nil {
return thrift.PrependError("error reading map end: ", err)
}
return nil
}
func (p *CloudScootSetClassLoadPercentsArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetClassLoadPercents_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 := 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 *CloudScootSetClassLoadPercentsArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("loadPercents", thrift.MAP, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:loadPercents: ", p), err)
}
if err := oprot.WriteMapBegin(thrift.STRING, thrift.I32, len(p.LoadPercents)); err != nil {
return thrift.PrependError("error writing map begin: ", err)
}
for k, v := range p.LoadPercents {
if err := oprot.WriteString(string(k)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
if err := oprot.WriteI32(int32(v)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
}
if err := oprot.WriteMapEnd(); err != nil {
return thrift.PrependError("error writing map end: ", err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:loadPercents: ", p), err)
}
return err
}
func (p *CloudScootSetClassLoadPercentsArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetClassLoadPercentsArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootSetClassLoadPercentsResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootSetClassLoadPercentsResult() *CloudScootSetClassLoadPercentsResult {
return &CloudScootSetClassLoadPercentsResult{}
}
var CloudScootSetClassLoadPercentsResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootSetClassLoadPercentsResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootSetClassLoadPercentsResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootSetClassLoadPercentsResult_Err_DEFAULT *ScootServerError
func (p *CloudScootSetClassLoadPercentsResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootSetClassLoadPercentsResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootSetClassLoadPercentsResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootSetClassLoadPercentsResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootSetClassLoadPercentsResult) 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 *CloudScootSetClassLoadPercentsResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootSetClassLoadPercentsResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootSetClassLoadPercentsResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetClassLoadPercents_result"); 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 *CloudScootSetClassLoadPercentsResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootSetClassLoadPercentsResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootSetClassLoadPercentsResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetClassLoadPercentsResult(%+v)", *p)
}
type CloudScootGetRequestorToClassMapArgs struct {
}
func NewCloudScootGetRequestorToClassMapArgs() *CloudScootGetRequestorToClassMapArgs {
return &CloudScootGetRequestorToClassMapArgs{}
}
func (p *CloudScootGetRequestorToClassMapArgs) 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
}
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 *CloudScootGetRequestorToClassMapArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRequestorToClassMap_args"); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *CloudScootGetRequestorToClassMapArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRequestorToClassMapArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
type CloudScootGetRequestorToClassMapResult struct {
Success map[string]string `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
}
func NewCloudScootGetRequestorToClassMapResult() *CloudScootGetRequestorToClassMapResult {
return &CloudScootGetRequestorToClassMapResult{}
}
var CloudScootGetRequestorToClassMapResult_Success_DEFAULT map[string]string
func (p *CloudScootGetRequestorToClassMapResult) GetSuccess() map[string]string {
return p.Success
}
var CloudScootGetRequestorToClassMapResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootGetRequestorToClassMapResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootGetRequestorToClassMapResult_Ir_DEFAULT
}
return p.Ir
}
func (p *CloudScootGetRequestorToClassMapResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetRequestorToClassMapResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootGetRequestorToClassMapResult) 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
}
case 1:
if err := p.readField1(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 *CloudScootGetRequestorToClassMapResult) readField0(iprot thrift.TProtocol) error {
_, _, size, err := iprot.ReadMapBegin()
if err != nil {
return thrift.PrependError("error reading map begin: ", err)
}
tMap := make(map[string]string, size)
p.Success = tMap
for i := 0; i < size; i++ {
var _key44 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_key44 = v
}
var _val45 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_val45 = v
}
p.Success[_key44] = _val45
}
if err := iprot.ReadMapEnd(); err != nil {
return thrift.PrependError("error reading map end: ", err)
}
return nil
}
func (p *CloudScootGetRequestorToClassMapResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootGetRequestorToClassMapResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRequestorToClassMap_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 := p.writeField1(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 *CloudScootGetRequestorToClassMapResult) writeField0(oprot thrift.TProtocol) (err error) {
if p.IsSetSuccess() {
if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
}
if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Success)); err != nil {
return thrift.PrependError("error writing map begin: ", err)
}
for k, v := range p.Success {
if err := oprot.WriteString(string(k)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
if err := oprot.WriteString(string(v)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
}
if err := oprot.WriteMapEnd(); err != nil {
return thrift.PrependError("error writing map end: ", 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 *CloudScootGetRequestorToClassMapResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootGetRequestorToClassMapResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRequestorToClassMapResult(%+v)", *p)
}
// Attributes:
// - RequestorToClassMap
type CloudScootSetRequestorToClassMapArgs struct {
RequestorToClassMap map[string]string `thrift:"requestorToClassMap,1" json:"requestorToClassMap"`
}
func NewCloudScootSetRequestorToClassMapArgs() *CloudScootSetRequestorToClassMapArgs {
return &CloudScootSetRequestorToClassMapArgs{}
}
func (p *CloudScootSetRequestorToClassMapArgs) GetRequestorToClassMap() map[string]string {
return p.RequestorToClassMap
}
func (p *CloudScootSetRequestorToClassMapArgs) 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
}
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 *CloudScootSetRequestorToClassMapArgs) readField1(iprot thrift.TProtocol) error {
_, _, size, err := iprot.ReadMapBegin()
if err != nil {
return thrift.PrependError("error reading map begin: ", err)
}
tMap := make(map[string]string, size)
p.RequestorToClassMap = tMap
for i := 0; i < size; i++ {
var _key46 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_key46 = v
}
var _val47 string
if v, err := iprot.ReadString(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
_val47 = v
}
p.RequestorToClassMap[_key46] = _val47
}
if err := iprot.ReadMapEnd(); err != nil {
return thrift.PrependError("error reading map end: ", err)
}
return nil
}
func (p *CloudScootSetRequestorToClassMapArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRequestorToClassMap_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 := 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 *CloudScootSetRequestorToClassMapArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("requestorToClassMap", thrift.MAP, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:requestorToClassMap: ", p), err)
}
if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.RequestorToClassMap)); err != nil {
return thrift.PrependError("error writing map begin: ", err)
}
for k, v := range p.RequestorToClassMap {
if err := oprot.WriteString(string(k)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
if err := oprot.WriteString(string(v)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
}
}
if err := oprot.WriteMapEnd(); err != nil {
return thrift.PrependError("error writing map end: ", err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:requestorToClassMap: ", p), err)
}
return err
}
func (p *CloudScootSetRequestorToClassMapArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRequestorToClassMapArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootSetRequestorToClassMapResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootSetRequestorToClassMapResult() *CloudScootSetRequestorToClassMapResult {
return &CloudScootSetRequestorToClassMapResult{}
}
var CloudScootSetRequestorToClassMapResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootSetRequestorToClassMapResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootSetRequestorToClassMapResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootSetRequestorToClassMapResult_Err_DEFAULT *ScootServerError
func (p *CloudScootSetRequestorToClassMapResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootSetRequestorToClassMapResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootSetRequestorToClassMapResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootSetRequestorToClassMapResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootSetRequestorToClassMapResult) 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 *CloudScootSetRequestorToClassMapResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootSetRequestorToClassMapResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootSetRequestorToClassMapResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRequestorToClassMap_result"); 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 *CloudScootSetRequestorToClassMapResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootSetRequestorToClassMapResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootSetRequestorToClassMapResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRequestorToClassMapResult(%+v)", *p)
}
type CloudScootGetRebalanceMinimumDurationArgs struct {
}
func NewCloudScootGetRebalanceMinimumDurationArgs() *CloudScootGetRebalanceMinimumDurationArgs {
return &CloudScootGetRebalanceMinimumDurationArgs{}
}
func (p *CloudScootGetRebalanceMinimumDurationArgs) 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
}
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 *CloudScootGetRebalanceMinimumDurationArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRebalanceMinimumDuration_args"); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *CloudScootGetRebalanceMinimumDurationArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRebalanceMinimumDurationArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
type CloudScootGetRebalanceMinimumDurationResult struct {
Success *int32 `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
}
func NewCloudScootGetRebalanceMinimumDurationResult() *CloudScootGetRebalanceMinimumDurationResult {
return &CloudScootGetRebalanceMinimumDurationResult{}
}
var CloudScootGetRebalanceMinimumDurationResult_Success_DEFAULT int32
func (p *CloudScootGetRebalanceMinimumDurationResult) GetSuccess() int32 {
if !p.IsSetSuccess() {
return CloudScootGetRebalanceMinimumDurationResult_Success_DEFAULT
}
return *p.Success
}
var CloudScootGetRebalanceMinimumDurationResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootGetRebalanceMinimumDurationResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootGetRebalanceMinimumDurationResult_Ir_DEFAULT
}
return p.Ir
}
func (p *CloudScootGetRebalanceMinimumDurationResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetRebalanceMinimumDurationResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootGetRebalanceMinimumDurationResult) 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
}
case 1:
if err := p.readField1(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 *CloudScootGetRebalanceMinimumDurationResult) readField0(iprot thrift.TProtocol) error {
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
p.Success = &v
}
return nil
}
func (p *CloudScootGetRebalanceMinimumDurationResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootGetRebalanceMinimumDurationResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRebalanceMinimumDuration_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 := p.writeField1(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 *CloudScootGetRebalanceMinimumDurationResult) writeField0(oprot thrift.TProtocol) (err error) {
if p.IsSetSuccess() {
if err := oprot.WriteFieldBegin("success", thrift.I32, 0); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
}
if err := oprot.WriteI32(int32(*p.Success)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), 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 *CloudScootGetRebalanceMinimumDurationResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootGetRebalanceMinimumDurationResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRebalanceMinimumDurationResult(%+v)", *p)
}
// Attributes:
// - DurationMin
type CloudScootSetRebalanceMinimumDurationArgs struct {
DurationMin int32 `thrift:"durationMin,1" json:"durationMin"`
}
func NewCloudScootSetRebalanceMinimumDurationArgs() *CloudScootSetRebalanceMinimumDurationArgs {
return &CloudScootSetRebalanceMinimumDurationArgs{}
}
func (p *CloudScootSetRebalanceMinimumDurationArgs) GetDurationMin() int32 {
return p.DurationMin
}
func (p *CloudScootSetRebalanceMinimumDurationArgs) 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
}
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 *CloudScootSetRebalanceMinimumDurationArgs) readField1(iprot thrift.TProtocol) error {
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 1: ", err)
} else {
p.DurationMin = v
}
return nil
}
func (p *CloudScootSetRebalanceMinimumDurationArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRebalanceMinimumDuration_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 := 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 *CloudScootSetRebalanceMinimumDurationArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("durationMin", thrift.I32, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:durationMin: ", p), err)
}
if err := oprot.WriteI32(int32(p.DurationMin)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.durationMin (1) field write error: ", p), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:durationMin: ", p), err)
}
return err
}
func (p *CloudScootSetRebalanceMinimumDurationArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRebalanceMinimumDurationArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootSetRebalanceMinimumDurationResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootSetRebalanceMinimumDurationResult() *CloudScootSetRebalanceMinimumDurationResult {
return &CloudScootSetRebalanceMinimumDurationResult{}
}
var CloudScootSetRebalanceMinimumDurationResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootSetRebalanceMinimumDurationResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootSetRebalanceMinimumDurationResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootSetRebalanceMinimumDurationResult_Err_DEFAULT *ScootServerError
func (p *CloudScootSetRebalanceMinimumDurationResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootSetRebalanceMinimumDurationResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootSetRebalanceMinimumDurationResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootSetRebalanceMinimumDurationResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootSetRebalanceMinimumDurationResult) 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 *CloudScootSetRebalanceMinimumDurationResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootSetRebalanceMinimumDurationResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootSetRebalanceMinimumDurationResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRebalanceMinimumDuration_result"); 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 *CloudScootSetRebalanceMinimumDurationResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootSetRebalanceMinimumDurationResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootSetRebalanceMinimumDurationResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRebalanceMinimumDurationResult(%+v)", *p)
}
type CloudScootGetRebalanceThresholdArgs struct {
}
func NewCloudScootGetRebalanceThresholdArgs() *CloudScootGetRebalanceThresholdArgs {
return &CloudScootGetRebalanceThresholdArgs{}
}
func (p *CloudScootGetRebalanceThresholdArgs) 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
}
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 *CloudScootGetRebalanceThresholdArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRebalanceThreshold_args"); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *CloudScootGetRebalanceThresholdArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRebalanceThresholdArgs(%+v)", *p)
}
// Attributes:
// - Success
// - Ir
type CloudScootGetRebalanceThresholdResult struct {
Success *int32 `thrift:"success,0" json:"success,omitempty"`
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
}
func NewCloudScootGetRebalanceThresholdResult() *CloudScootGetRebalanceThresholdResult {
return &CloudScootGetRebalanceThresholdResult{}
}
var CloudScootGetRebalanceThresholdResult_Success_DEFAULT int32
func (p *CloudScootGetRebalanceThresholdResult) GetSuccess() int32 {
if !p.IsSetSuccess() {
return CloudScootGetRebalanceThresholdResult_Success_DEFAULT
}
return *p.Success
}
var CloudScootGetRebalanceThresholdResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootGetRebalanceThresholdResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootGetRebalanceThresholdResult_Ir_DEFAULT
}
return p.Ir
}
func (p *CloudScootGetRebalanceThresholdResult) IsSetSuccess() bool {
return p.Success != nil
}
func (p *CloudScootGetRebalanceThresholdResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootGetRebalanceThresholdResult) 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
}
case 1:
if err := p.readField1(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 *CloudScootGetRebalanceThresholdResult) readField0(iprot thrift.TProtocol) error {
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 0: ", err)
} else {
p.Success = &v
}
return nil
}
func (p *CloudScootGetRebalanceThresholdResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootGetRebalanceThresholdResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("GetRebalanceThreshold_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 := p.writeField1(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 *CloudScootGetRebalanceThresholdResult) writeField0(oprot thrift.TProtocol) (err error) {
if p.IsSetSuccess() {
if err := oprot.WriteFieldBegin("success", thrift.I32, 0); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
}
if err := oprot.WriteI32(int32(*p.Success)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), 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 *CloudScootGetRebalanceThresholdResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootGetRebalanceThresholdResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootGetRebalanceThresholdResult(%+v)", *p)
}
// Attributes:
// - Threshold
type CloudScootSetRebalanceThresholdArgs struct {
Threshold int32 `thrift:"threshold,1" json:"threshold"`
}
func NewCloudScootSetRebalanceThresholdArgs() *CloudScootSetRebalanceThresholdArgs {
return &CloudScootSetRebalanceThresholdArgs{}
}
func (p *CloudScootSetRebalanceThresholdArgs) GetThreshold() int32 {
return p.Threshold
}
func (p *CloudScootSetRebalanceThresholdArgs) 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
}
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 *CloudScootSetRebalanceThresholdArgs) readField1(iprot thrift.TProtocol) error {
if v, err := iprot.ReadI32(); err != nil {
return thrift.PrependError("error reading field 1: ", err)
} else {
p.Threshold = v
}
return nil
}
func (p *CloudScootSetRebalanceThresholdArgs) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRebalanceThreshold_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 := 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 *CloudScootSetRebalanceThresholdArgs) writeField1(oprot thrift.TProtocol) (err error) {
if err := oprot.WriteFieldBegin("threshold", thrift.I32, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:threshold: ", p), err)
}
if err := oprot.WriteI32(int32(p.Threshold)); err != nil {
return thrift.PrependError(fmt.Sprintf("%T.threshold (1) field write error: ", p), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:threshold: ", p), err)
}
return err
}
func (p *CloudScootSetRebalanceThresholdArgs) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRebalanceThresholdArgs(%+v)", *p)
}
// Attributes:
// - Ir
// - Err
type CloudScootSetRebalanceThresholdResult struct {
Ir *InvalidRequest `thrift:"ir,1" json:"ir,omitempty"`
Err *ScootServerError `thrift:"err,2" json:"err,omitempty"`
}
func NewCloudScootSetRebalanceThresholdResult() *CloudScootSetRebalanceThresholdResult {
return &CloudScootSetRebalanceThresholdResult{}
}
var CloudScootSetRebalanceThresholdResult_Ir_DEFAULT *InvalidRequest
func (p *CloudScootSetRebalanceThresholdResult) GetIr() *InvalidRequest {
if !p.IsSetIr() {
return CloudScootSetRebalanceThresholdResult_Ir_DEFAULT
}
return p.Ir
}
var CloudScootSetRebalanceThresholdResult_Err_DEFAULT *ScootServerError
func (p *CloudScootSetRebalanceThresholdResult) GetErr() *ScootServerError {
if !p.IsSetErr() {
return CloudScootSetRebalanceThresholdResult_Err_DEFAULT
}
return p.Err
}
func (p *CloudScootSetRebalanceThresholdResult) IsSetIr() bool {
return p.Ir != nil
}
func (p *CloudScootSetRebalanceThresholdResult) IsSetErr() bool {
return p.Err != nil
}
func (p *CloudScootSetRebalanceThresholdResult) 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 *CloudScootSetRebalanceThresholdResult) readField1(iprot thrift.TProtocol) error {
p.Ir = &InvalidRequest{}
if err := p.Ir.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ir), err)
}
return nil
}
func (p *CloudScootSetRebalanceThresholdResult) readField2(iprot thrift.TProtocol) error {
p.Err = &ScootServerError{}
if err := p.Err.Read(iprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
}
return nil
}
func (p *CloudScootSetRebalanceThresholdResult) Write(oprot thrift.TProtocol) error {
if err := oprot.WriteStructBegin("SetRebalanceThreshold_result"); 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 *CloudScootSetRebalanceThresholdResult) writeField1(oprot thrift.TProtocol) (err error) {
if p.IsSetIr() {
if err := oprot.WriteFieldBegin("ir", thrift.STRUCT, 1); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ir: ", p), err)
}
if err := p.Ir.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ir), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ir: ", p), err)
}
}
return err
}
func (p *CloudScootSetRebalanceThresholdResult) writeField2(oprot thrift.TProtocol) (err error) {
if p.IsSetErr() {
if err := oprot.WriteFieldBegin("err", thrift.STRUCT, 2); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:err: ", p), err)
}
if err := p.Err.Write(oprot); err != nil {
return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Err), err)
}
if err := oprot.WriteFieldEnd(); err != nil {
return thrift.PrependError(fmt.Sprintf("%T write field end error 2:err: ", p), err)
}
}
return err
}
func (p *CloudScootSetRebalanceThresholdResult) String() string {
if p == nil {
return "<nil>"
}
return fmt.Sprintf("CloudScootSetRebalanceThresholdResult(%+v)", *p)
}