diff --git a/src/dbnode/generated/thrift/generate.sh b/src/dbnode/generated/thrift/generate.sh index abe305627d..4b52ee0a92 100755 --- a/src/dbnode/generated/thrift/generate.sh +++ b/src/dbnode/generated/thrift/generate.sh @@ -8,6 +8,7 @@ docker run --rm hello-world >/dev/null # generate files using dockerized thrift-gen THRIFT_IMAGE_VERSION=${THRIFT_IMAGE_VERSION:-"quay.io/m3db/thrift-gen:0.1.0"} +echo "Generating thrift files with image: $THRIFT_IMAGE_VERSION" UID_FLAGS="-u $(id -u)" if [[ -n "$BUILDKITE" ]]; then diff --git a/src/dbnode/generated/thrift/rpc.thrift b/src/dbnode/generated/thrift/rpc.thrift index 50855bf05a..dda00739c3 100644 --- a/src/dbnode/generated/thrift/rpc.thrift +++ b/src/dbnode/generated/thrift/rpc.thrift @@ -80,6 +80,8 @@ service Node { NodeWriteNewSeriesLimitPerShardPerSecondResult setWriteNewSeriesLimitPerShardPerSecond(1: NodeSetWriteNewSeriesLimitPerShardPerSecondRequest req) throws (1: Error err) // Debug endpoints + DebugProfileStartResult debugProfileStart(1: DebugProfileStartRequest req) throws (1: Error err) + DebugProfileStopResult debugProfileStop(1: DebugProfileStopRequest req) throws (1: Error err) DebugIndexMemorySegmentsResult debugIndexMemorySegments(1: DebugIndexMemorySegmentsRequest req) throws (1: Error err) } @@ -489,6 +491,27 @@ struct Query { 7: optional FieldQuery field } +struct DebugProfileStartRequest { + 1: required string name + 2: required string filePathTemplate + 3: optional string interval + 4: optional string duration + 5: optional i64 debug + 6: optional i64 conditionalNumGoroutinesGreaterThan + 7: optional i64 conditionalNumGoroutinesLessThan + 8: optional bool conditionalIsOverloaded +} + +struct DebugProfileStartResult { +} + +struct DebugProfileStopRequest { + 1: required string name +} + +struct DebugProfileStopResult { +} + struct DebugIndexMemorySegmentsRequest { 1: required string directory } diff --git a/src/dbnode/generated/thrift/rpc/rpc.go b/src/dbnode/generated/thrift/rpc/rpc.go index bfcb2952e3..66575da7fd 100644 --- a/src/dbnode/generated/thrift/rpc/rpc.go +++ b/src/dbnode/generated/thrift/rpc/rpc.go @@ -12907,24 +12907,121 @@ func (p *Query) String() string { } // Attributes: -// - Directory -type DebugIndexMemorySegmentsRequest struct { - Directory string `thrift:"directory,1,required" db:"directory" json:"directory"` +// - Name +// - FilePathTemplate +// - Interval +// - Duration +// - Debug +// - ConditionalNumGoroutinesGreaterThan +// - ConditionalNumGoroutinesLessThan +// - ConditionalIsOverloaded +type DebugProfileStartRequest struct { + Name string `thrift:"name,1,required" db:"name" json:"name"` + FilePathTemplate string `thrift:"filePathTemplate,2,required" db:"filePathTemplate" json:"filePathTemplate"` + Interval *string `thrift:"interval,3" db:"interval" json:"interval,omitempty"` + Duration *string `thrift:"duration,4" db:"duration" json:"duration,omitempty"` + Debug *int64 `thrift:"debug,5" db:"debug" json:"debug,omitempty"` + ConditionalNumGoroutinesGreaterThan *int64 `thrift:"conditionalNumGoroutinesGreaterThan,6" db:"conditionalNumGoroutinesGreaterThan" json:"conditionalNumGoroutinesGreaterThan,omitempty"` + ConditionalNumGoroutinesLessThan *int64 `thrift:"conditionalNumGoroutinesLessThan,7" db:"conditionalNumGoroutinesLessThan" json:"conditionalNumGoroutinesLessThan,omitempty"` + ConditionalIsOverloaded *bool `thrift:"conditionalIsOverloaded,8" db:"conditionalIsOverloaded" json:"conditionalIsOverloaded,omitempty"` +} + +func NewDebugProfileStartRequest() *DebugProfileStartRequest { + return &DebugProfileStartRequest{} +} + +func (p *DebugProfileStartRequest) GetName() string { + return p.Name } -func NewDebugIndexMemorySegmentsRequest() *DebugIndexMemorySegmentsRequest { - return &DebugIndexMemorySegmentsRequest{} +func (p *DebugProfileStartRequest) GetFilePathTemplate() string { + return p.FilePathTemplate } -func (p *DebugIndexMemorySegmentsRequest) GetDirectory() string { - return p.Directory +var DebugProfileStartRequest_Interval_DEFAULT string + +func (p *DebugProfileStartRequest) GetInterval() string { + if !p.IsSetInterval() { + return DebugProfileStartRequest_Interval_DEFAULT + } + return *p.Interval } -func (p *DebugIndexMemorySegmentsRequest) Read(iprot thrift.TProtocol) error { + +var DebugProfileStartRequest_Duration_DEFAULT string + +func (p *DebugProfileStartRequest) GetDuration() string { + if !p.IsSetDuration() { + return DebugProfileStartRequest_Duration_DEFAULT + } + return *p.Duration +} + +var DebugProfileStartRequest_Debug_DEFAULT int64 + +func (p *DebugProfileStartRequest) GetDebug() int64 { + if !p.IsSetDebug() { + return DebugProfileStartRequest_Debug_DEFAULT + } + return *p.Debug +} + +var DebugProfileStartRequest_ConditionalNumGoroutinesGreaterThan_DEFAULT int64 + +func (p *DebugProfileStartRequest) GetConditionalNumGoroutinesGreaterThan() int64 { + if !p.IsSetConditionalNumGoroutinesGreaterThan() { + return DebugProfileStartRequest_ConditionalNumGoroutinesGreaterThan_DEFAULT + } + return *p.ConditionalNumGoroutinesGreaterThan +} + +var DebugProfileStartRequest_ConditionalNumGoroutinesLessThan_DEFAULT int64 + +func (p *DebugProfileStartRequest) GetConditionalNumGoroutinesLessThan() int64 { + if !p.IsSetConditionalNumGoroutinesLessThan() { + return DebugProfileStartRequest_ConditionalNumGoroutinesLessThan_DEFAULT + } + return *p.ConditionalNumGoroutinesLessThan +} + +var DebugProfileStartRequest_ConditionalIsOverloaded_DEFAULT bool + +func (p *DebugProfileStartRequest) GetConditionalIsOverloaded() bool { + if !p.IsSetConditionalIsOverloaded() { + return DebugProfileStartRequest_ConditionalIsOverloaded_DEFAULT + } + return *p.ConditionalIsOverloaded +} +func (p *DebugProfileStartRequest) IsSetInterval() bool { + return p.Interval != nil +} + +func (p *DebugProfileStartRequest) IsSetDuration() bool { + return p.Duration != nil +} + +func (p *DebugProfileStartRequest) IsSetDebug() bool { + return p.Debug != nil +} + +func (p *DebugProfileStartRequest) IsSetConditionalNumGoroutinesGreaterThan() bool { + return p.ConditionalNumGoroutinesGreaterThan != nil +} + +func (p *DebugProfileStartRequest) IsSetConditionalNumGoroutinesLessThan() bool { + return p.ConditionalNumGoroutinesLessThan != nil +} + +func (p *DebugProfileStartRequest) IsSetConditionalIsOverloaded() bool { + return p.ConditionalIsOverloaded != nil +} + +func (p *DebugProfileStartRequest) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } - var issetDirectory bool = false + var issetName bool = false + var issetFilePathTemplate bool = false for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() @@ -12939,7 +13036,36 @@ func (p *DebugIndexMemorySegmentsRequest) Read(iprot thrift.TProtocol) error { if err := p.ReadField1(iprot); err != nil { return err } - issetDirectory = true + issetName = true + case 2: + if err := p.ReadField2(iprot); err != nil { + return err + } + issetFilePathTemplate = true + case 3: + if err := p.ReadField3(iprot); err != nil { + return err + } + case 4: + if err := p.ReadField4(iprot); err != nil { + return err + } + case 5: + if err := p.ReadField5(iprot); err != nil { + return err + } + case 6: + if err := p.ReadField6(iprot); err != nil { + return err + } + case 7: + if err := p.ReadField7(iprot); err != nil { + return err + } + case 8: + if err := p.ReadField8(iprot); err != nil { + return err + } default: if err := iprot.Skip(fieldTypeId); err != nil { return err @@ -12952,29 +13078,116 @@ func (p *DebugIndexMemorySegmentsRequest) Read(iprot thrift.TProtocol) error { if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - if !issetDirectory { - return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Directory is not set")) + if !issetName { + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Name is not set")) + } + if !issetFilePathTemplate { + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field FilePathTemplate is not set")) } return nil } -func (p *DebugIndexMemorySegmentsRequest) ReadField1(iprot thrift.TProtocol) error { +func (p *DebugProfileStartRequest) ReadField1(iprot thrift.TProtocol) error { if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { - p.Directory = v + p.Name = v } return nil } -func (p *DebugIndexMemorySegmentsRequest) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("DebugIndexMemorySegmentsRequest"); err != nil { +func (p *DebugProfileStartRequest) ReadField2(iprot thrift.TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return thrift.PrependError("error reading field 2: ", err) + } else { + p.FilePathTemplate = v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField3(iprot thrift.TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return thrift.PrependError("error reading field 3: ", err) + } else { + p.Interval = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField4(iprot thrift.TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return thrift.PrependError("error reading field 4: ", err) + } else { + p.Duration = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField5(iprot thrift.TProtocol) error { + if v, err := iprot.ReadI64(); err != nil { + return thrift.PrependError("error reading field 5: ", err) + } else { + p.Debug = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField6(iprot thrift.TProtocol) error { + if v, err := iprot.ReadI64(); err != nil { + return thrift.PrependError("error reading field 6: ", err) + } else { + p.ConditionalNumGoroutinesGreaterThan = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField7(iprot thrift.TProtocol) error { + if v, err := iprot.ReadI64(); err != nil { + return thrift.PrependError("error reading field 7: ", err) + } else { + p.ConditionalNumGoroutinesLessThan = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField8(iprot thrift.TProtocol) error { + if v, err := iprot.ReadBool(); err != nil { + return thrift.PrependError("error reading field 8: ", err) + } else { + p.ConditionalIsOverloaded = &v + } + return nil +} + +func (p *DebugProfileStartRequest) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugProfileStartRequest"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { if err := p.writeField1(oprot); err != nil { return err } + if err := p.writeField2(oprot); err != nil { + return err + } + if err := p.writeField3(oprot); err != nil { + return err + } + if err := p.writeField4(oprot); err != nil { + return err + } + if err := p.writeField5(oprot); err != nil { + return err + } + if err := p.writeField6(oprot); err != nil { + return err + } + if err := p.writeField7(oprot); err != nil { + return err + } + if err := p.writeField8(oprot); err != nil { + return err + } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) @@ -12985,34 +13198,137 @@ func (p *DebugIndexMemorySegmentsRequest) Write(oprot thrift.TProtocol) error { return nil } -func (p *DebugIndexMemorySegmentsRequest) writeField1(oprot thrift.TProtocol) (err error) { - if err := oprot.WriteFieldBegin("directory", thrift.STRING, 1); err != nil { - return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:directory: ", p), err) +func (p *DebugProfileStartRequest) writeField1(oprot thrift.TProtocol) (err error) { + if err := oprot.WriteFieldBegin("name", thrift.STRING, 1); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err) } - if err := oprot.WriteString(string(p.Directory)); err != nil { - return thrift.PrependError(fmt.Sprintf("%T.directory (1) field write error: ", p), err) + if err := oprot.WriteString(string(p.Name)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.name (1) field write error: ", p), err) } if err := oprot.WriteFieldEnd(); err != nil { - return thrift.PrependError(fmt.Sprintf("%T write field end error 1:directory: ", p), err) + return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err) } return err } -func (p *DebugIndexMemorySegmentsRequest) String() string { +func (p *DebugProfileStartRequest) writeField2(oprot thrift.TProtocol) (err error) { + if err := oprot.WriteFieldBegin("filePathTemplate", thrift.STRING, 2); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:filePathTemplate: ", p), err) + } + if err := oprot.WriteString(string(p.FilePathTemplate)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.filePathTemplate (2) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 2:filePathTemplate: ", p), err) + } + return err +} + +func (p *DebugProfileStartRequest) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetInterval() { + if err := oprot.WriteFieldBegin("interval", thrift.STRING, 3); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:interval: ", p), err) + } + if err := oprot.WriteString(string(*p.Interval)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.interval (3) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 3:interval: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetDuration() { + if err := oprot.WriteFieldBegin("duration", thrift.STRING, 4); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:duration: ", p), err) + } + if err := oprot.WriteString(string(*p.Duration)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.duration (4) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 4:duration: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetDebug() { + if err := oprot.WriteFieldBegin("debug", thrift.I64, 5); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:debug: ", p), err) + } + if err := oprot.WriteI64(int64(*p.Debug)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.debug (5) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 5:debug: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField6(oprot thrift.TProtocol) (err error) { + if p.IsSetConditionalNumGoroutinesGreaterThan() { + if err := oprot.WriteFieldBegin("conditionalNumGoroutinesGreaterThan", thrift.I64, 6); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:conditionalNumGoroutinesGreaterThan: ", p), err) + } + if err := oprot.WriteI64(int64(*p.ConditionalNumGoroutinesGreaterThan)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.conditionalNumGoroutinesGreaterThan (6) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 6:conditionalNumGoroutinesGreaterThan: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField7(oprot thrift.TProtocol) (err error) { + if p.IsSetConditionalNumGoroutinesLessThan() { + if err := oprot.WriteFieldBegin("conditionalNumGoroutinesLessThan", thrift.I64, 7); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:conditionalNumGoroutinesLessThan: ", p), err) + } + if err := oprot.WriteI64(int64(*p.ConditionalNumGoroutinesLessThan)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.conditionalNumGoroutinesLessThan (7) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 7:conditionalNumGoroutinesLessThan: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField8(oprot thrift.TProtocol) (err error) { + if p.IsSetConditionalIsOverloaded() { + if err := oprot.WriteFieldBegin("conditionalIsOverloaded", thrift.BOOL, 8); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:conditionalIsOverloaded: ", p), err) + } + if err := oprot.WriteBool(bool(*p.ConditionalIsOverloaded)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.conditionalIsOverloaded (8) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 8:conditionalIsOverloaded: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) String() string { if p == nil { return "" } - return fmt.Sprintf("DebugIndexMemorySegmentsRequest(%+v)", *p) + return fmt.Sprintf("DebugProfileStartRequest(%+v)", *p) } -type DebugIndexMemorySegmentsResult_ struct { +type DebugProfileStartResult_ struct { } -func NewDebugIndexMemorySegmentsResult_() *DebugIndexMemorySegmentsResult_ { - return &DebugIndexMemorySegmentsResult_{} +func NewDebugProfileStartResult_() *DebugProfileStartResult_ { + return &DebugProfileStartResult_{} } -func (p *DebugIndexMemorySegmentsResult_) Read(iprot thrift.TProtocol) error { +func (p *DebugProfileStartResult_) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -13038,8 +13354,8 @@ func (p *DebugIndexMemorySegmentsResult_) Read(iprot thrift.TProtocol) error { return nil } -func (p *DebugIndexMemorySegmentsResult_) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("DebugIndexMemorySegmentsResult"); err != nil { +func (p *DebugProfileStartResult_) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugProfileStartResult"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -13053,457 +13369,447 @@ func (p *DebugIndexMemorySegmentsResult_) Write(oprot thrift.TProtocol) error { return nil } -func (p *DebugIndexMemorySegmentsResult_) String() string { +func (p *DebugProfileStartResult_) String() string { if p == nil { return "" } - return fmt.Sprintf("DebugIndexMemorySegmentsResult_(%+v)", *p) + return fmt.Sprintf("DebugProfileStartResult_(%+v)", *p) } -type Node interface { - // Parameters: - // - Req - Query(req *QueryRequest) (r *QueryResult_, err error) - // Parameters: - // - Req - AggregateRaw(req *AggregateQueryRawRequest) (r *AggregateQueryRawResult_, err error) - // Parameters: - // - Req - Aggregate(req *AggregateQueryRequest) (r *AggregateQueryResult_, err error) - // Parameters: - // - Req - Fetch(req *FetchRequest) (r *FetchResult_, err error) - // Parameters: - // - Req - FetchTagged(req *FetchTaggedRequest) (r *FetchTaggedResult_, err error) - // Parameters: - // - Req - Write(req *WriteRequest) (err error) - // Parameters: - // - Req - WriteTagged(req *WriteTaggedRequest) (err error) - // Parameters: - // - Req - FetchBatchRaw(req *FetchBatchRawRequest) (r *FetchBatchRawResult_, err error) - // Parameters: - // - Req - FetchBatchRawV2(req *FetchBatchRawV2Request) (r *FetchBatchRawResult_, err error) - // Parameters: - // - Req - FetchBlocksRaw(req *FetchBlocksRawRequest) (r *FetchBlocksRawResult_, err error) - // Parameters: - // - Req - FetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (r *FetchBlocksMetadataRawV2Result_, err error) - // Parameters: - // - Req - WriteBatchRaw(req *WriteBatchRawRequest) (err error) - // Parameters: - // - Req - WriteBatchRawV2(req *WriteBatchRawV2Request) (err error) - // Parameters: - // - Req - WriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) - // Parameters: - // - Req - WriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) - Repair() (err error) - // Parameters: - // - Req - Truncate(req *TruncateRequest) (r *TruncateResult_, err error) - Health() (r *NodeHealthResult_, err error) - Bootstrapped() (r *NodeBootstrappedResult_, err error) - BootstrappedInPlacementOrNoPlacement() (r *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) - GetPersistRateLimit() (r *NodePersistRateLimitResult_, err error) - // Parameters: - // - Req - SetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (r *NodePersistRateLimitResult_, err error) - GetWriteNewSeriesAsync() (r *NodeWriteNewSeriesAsyncResult_, err error) - // Parameters: - // - Req - SetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (r *NodeWriteNewSeriesAsyncResult_, err error) - GetWriteNewSeriesBackoffDuration() (r *NodeWriteNewSeriesBackoffDurationResult_, err error) - // Parameters: - // - Req - SetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (r *NodeWriteNewSeriesBackoffDurationResult_, err error) - GetWriteNewSeriesLimitPerShardPerSecond() (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) - // Parameters: - // - Req - SetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) - // Parameters: - // - Req - DebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (r *DebugIndexMemorySegmentsResult_, err error) +// Attributes: +// - Name +type DebugProfileStopRequest struct { + Name string `thrift:"name,1,required" db:"name" json:"name"` } -type NodeClient struct { - Transport thrift.TTransport - ProtocolFactory thrift.TProtocolFactory - InputProtocol thrift.TProtocol - OutputProtocol thrift.TProtocol - SeqId int32 +func NewDebugProfileStopRequest() *DebugProfileStopRequest { + return &DebugProfileStopRequest{} } -func NewNodeClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *NodeClient { - return &NodeClient{Transport: t, - ProtocolFactory: f, - InputProtocol: f.GetProtocol(t), - OutputProtocol: f.GetProtocol(t), - SeqId: 0, - } +func (p *DebugProfileStopRequest) GetName() string { + return p.Name } +func (p *DebugProfileStopRequest) Read(iprot thrift.TProtocol) error { + if _, err := iprot.ReadStructBegin(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) + } -func NewNodeClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *NodeClient { - return &NodeClient{Transport: t, - ProtocolFactory: nil, - InputProtocol: iprot, - OutputProtocol: oprot, - SeqId: 0, + var issetName bool = false + + 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 + } + issetName = true + 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) } + if !issetName { + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Name is not set")) + } + return nil } -// Parameters: -// - Req -func (p *NodeClient) Query(req *QueryRequest) (r *QueryResult_, err error) { - if err = p.sendQuery(req); err != nil { - return +func (p *DebugProfileStopRequest) ReadField1(iprot thrift.TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return thrift.PrependError("error reading field 1: ", err) + } else { + p.Name = v } - return p.recvQuery() + return nil } -func (p *NodeClient) sendQuery(req *QueryRequest) (err error) { - oprot := p.OutputProtocol - if oprot == nil { - oprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.OutputProtocol = oprot - } - p.SeqId++ - if err = oprot.WriteMessageBegin("query", thrift.CALL, p.SeqId); err != nil { - return +func (p *DebugProfileStopRequest) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugProfileStopRequest"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } - args := NodeQueryArgs{ - Req: req, + if p != nil { + if err := p.writeField1(oprot); err != nil { + return err + } } - if err = args.Write(oprot); err != nil { - return + if err := oprot.WriteFieldStop(); err != nil { + return thrift.PrependError("write field stop error: ", err) } - if err = oprot.WriteMessageEnd(); err != nil { - return + if err := oprot.WriteStructEnd(); err != nil { + return thrift.PrependError("write struct stop error: ", err) } - return oprot.Flush() + return nil } -func (p *NodeClient) recvQuery() (value *QueryResult_, err error) { - iprot := p.InputProtocol - if iprot == nil { - iprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.InputProtocol = iprot +func (p *DebugProfileStopRequest) writeField1(oprot thrift.TProtocol) (err error) { + if err := oprot.WriteFieldBegin("name", thrift.STRING, 1); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err) } - method, mTypeId, seqId, err := iprot.ReadMessageBegin() - if err != nil { - return + if err := oprot.WriteString(string(p.Name)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.name (1) field write error: ", p), err) } - if method != "query" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "query failed: wrong method name") - return + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err) } - if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "query failed: out of sequence response") - return + return err +} + +func (p *DebugProfileStopRequest) String() string { + if p == nil { + return "" } - if mTypeId == thrift.EXCEPTION { - error35 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error36 error - error36, err = error35.Read(iprot) + return fmt.Sprintf("DebugProfileStopRequest(%+v)", *p) +} + +type DebugProfileStopResult_ struct { +} + +func NewDebugProfileStopResult_() *DebugProfileStopResult_ { + return &DebugProfileStopResult_{} +} + +func (p *DebugProfileStopResult_) 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 + return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } - if err = iprot.ReadMessageEnd(); err != nil { - return + if fieldTypeId == thrift.STOP { + break + } + if err := iprot.Skip(fieldTypeId); err != nil { + return err + } + if err := iprot.ReadFieldEnd(); err != nil { + return err } - err = error36 - return } - if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "query failed: invalid message type") - return + if err := iprot.ReadStructEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - result := NodeQueryResult{} - if err = result.Read(iprot); err != nil { - return + return nil +} + +func (p *DebugProfileStopResult_) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugProfileStopResult"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } - if err = iprot.ReadMessageEnd(); err != nil { - return + if p != nil { } - if result.Err != nil { - err = result.Err - return + if err := oprot.WriteFieldStop(); err != nil { + return thrift.PrependError("write field stop error: ", err) } - value = result.GetSuccess() - return + if err := oprot.WriteStructEnd(); err != nil { + return thrift.PrependError("write struct stop error: ", err) + } + return nil } -// Parameters: -// - Req -func (p *NodeClient) AggregateRaw(req *AggregateQueryRawRequest) (r *AggregateQueryRawResult_, err error) { - if err = p.sendAggregateRaw(req); err != nil { - return +func (p *DebugProfileStopResult_) String() string { + if p == nil { + return "" } - return p.recvAggregateRaw() + return fmt.Sprintf("DebugProfileStopResult_(%+v)", *p) } -func (p *NodeClient) sendAggregateRaw(req *AggregateQueryRawRequest) (err error) { - oprot := p.OutputProtocol - if oprot == nil { - oprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.OutputProtocol = oprot - } - p.SeqId++ - if err = oprot.WriteMessageBegin("aggregateRaw", thrift.CALL, p.SeqId); err != nil { - return - } - args := NodeAggregateRawArgs{ - Req: req, - } - if err = args.Write(oprot); err != nil { - return - } - if err = oprot.WriteMessageEnd(); err != nil { - return - } - return oprot.Flush() +// Attributes: +// - Directory +type DebugIndexMemorySegmentsRequest struct { + Directory string `thrift:"directory,1,required" db:"directory" json:"directory"` } -func (p *NodeClient) recvAggregateRaw() (value *AggregateQueryRawResult_, 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 != "aggregateRaw" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "aggregateRaw failed: wrong method name") - return - } - if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "aggregateRaw failed: out of sequence response") - return +func NewDebugIndexMemorySegmentsRequest() *DebugIndexMemorySegmentsRequest { + return &DebugIndexMemorySegmentsRequest{} +} + +func (p *DebugIndexMemorySegmentsRequest) GetDirectory() string { + return p.Directory +} +func (p *DebugIndexMemorySegmentsRequest) Read(iprot thrift.TProtocol) error { + if _, err := iprot.ReadStructBegin(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } - if mTypeId == thrift.EXCEPTION { - error37 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error38 error - error38, err = error37.Read(iprot) + + var issetDirectory bool = false + + for { + _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { - return + return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } - if err = iprot.ReadMessageEnd(); err != nil { - return + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if err := p.ReadField1(iprot); err != nil { + return err + } + issetDirectory = true + default: + if err := iprot.Skip(fieldTypeId); err != nil { + return err + } + } + if err := iprot.ReadFieldEnd(); err != nil { + return err } - err = error38 - return - } - if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "aggregateRaw failed: invalid message type") - return - } - result := NodeAggregateRawResult{} - if err = result.Read(iprot); err != nil { - return } - if err = iprot.ReadMessageEnd(); err != nil { - return + if err := iprot.ReadStructEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - if result.Err != nil { - err = result.Err - return + if !issetDirectory { + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Directory is not set")) } - value = result.GetSuccess() - return + return nil } -// Parameters: -// - Req -func (p *NodeClient) Aggregate(req *AggregateQueryRequest) (r *AggregateQueryResult_, err error) { - if err = p.sendAggregate(req); err != nil { - return +func (p *DebugIndexMemorySegmentsRequest) ReadField1(iprot thrift.TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return thrift.PrependError("error reading field 1: ", err) + } else { + p.Directory = v } - return p.recvAggregate() + return nil } -func (p *NodeClient) sendAggregate(req *AggregateQueryRequest) (err error) { - oprot := p.OutputProtocol - if oprot == nil { - oprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.OutputProtocol = oprot - } - p.SeqId++ - if err = oprot.WriteMessageBegin("aggregate", thrift.CALL, p.SeqId); err != nil { - return +func (p *DebugIndexMemorySegmentsRequest) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugIndexMemorySegmentsRequest"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } - args := NodeAggregateArgs{ - Req: req, + if p != nil { + if err := p.writeField1(oprot); err != nil { + return err + } } - if err = args.Write(oprot); err != nil { - return + if err := oprot.WriteFieldStop(); err != nil { + return thrift.PrependError("write field stop error: ", err) } - if err = oprot.WriteMessageEnd(); err != nil { - return + if err := oprot.WriteStructEnd(); err != nil { + return thrift.PrependError("write struct stop error: ", err) } - return oprot.Flush() + return nil } -func (p *NodeClient) recvAggregate() (value *AggregateQueryResult_, err error) { - iprot := p.InputProtocol - if iprot == nil { - iprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.InputProtocol = iprot +func (p *DebugIndexMemorySegmentsRequest) writeField1(oprot thrift.TProtocol) (err error) { + if err := oprot.WriteFieldBegin("directory", thrift.STRING, 1); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:directory: ", p), err) } - method, mTypeId, seqId, err := iprot.ReadMessageBegin() - if err != nil { - return + if err := oprot.WriteString(string(p.Directory)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.directory (1) field write error: ", p), err) } - if method != "aggregate" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "aggregate failed: wrong method name") - return + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 1:directory: ", p), err) } - if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "aggregate failed: out of sequence response") - return + return err +} + +func (p *DebugIndexMemorySegmentsRequest) String() string { + if p == nil { + return "" } - if mTypeId == thrift.EXCEPTION { - error39 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error40 error - error40, err = error39.Read(iprot) + return fmt.Sprintf("DebugIndexMemorySegmentsRequest(%+v)", *p) +} + +type DebugIndexMemorySegmentsResult_ struct { +} + +func NewDebugIndexMemorySegmentsResult_() *DebugIndexMemorySegmentsResult_ { + return &DebugIndexMemorySegmentsResult_{} +} + +func (p *DebugIndexMemorySegmentsResult_) 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 + return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } - if err = iprot.ReadMessageEnd(); err != nil { - return + if fieldTypeId == thrift.STOP { + break + } + if err := iprot.Skip(fieldTypeId); err != nil { + return err + } + if err := iprot.ReadFieldEnd(); err != nil { + return err } - err = error40 - return - } - if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "aggregate failed: invalid message type") - return - } - result := NodeAggregateResult{} - 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: -// - Req -func (p *NodeClient) Fetch(req *FetchRequest) (r *FetchResult_, err error) { - if err = p.sendFetch(req); err != nil { - return + if err := iprot.ReadStructEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - return p.recvFetch() + return nil } -func (p *NodeClient) sendFetch(req *FetchRequest) (err error) { - oprot := p.OutputProtocol - if oprot == nil { - oprot = p.ProtocolFactory.GetProtocol(p.Transport) - p.OutputProtocol = oprot - } - p.SeqId++ - if err = oprot.WriteMessageBegin("fetch", thrift.CALL, p.SeqId); err != nil { - return +func (p *DebugIndexMemorySegmentsResult_) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("DebugIndexMemorySegmentsResult"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } - args := NodeFetchArgs{ - Req: req, + if p != nil { } - if err = args.Write(oprot); err != nil { - return + if err := oprot.WriteFieldStop(); err != nil { + return thrift.PrependError("write field stop error: ", err) } - if err = oprot.WriteMessageEnd(); err != nil { - return + if err := oprot.WriteStructEnd(); err != nil { + return thrift.PrependError("write struct stop error: ", err) } - return oprot.Flush() + return nil } -func (p *NodeClient) recvFetch() (value *FetchResult_, 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 != "fetch" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetch failed: wrong method name") - return - } - if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetch failed: out of sequence response") - return +func (p *DebugIndexMemorySegmentsResult_) String() string { + if p == nil { + return "" } - if mTypeId == thrift.EXCEPTION { - error41 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error42 error - error42, err = error41.Read(iprot) - if err != nil { - return - } - if err = iprot.ReadMessageEnd(); err != nil { - return - } - err = error42 - return - } - if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetch failed: invalid message type") - return - } - result := NodeFetchResult{} - if err = result.Read(iprot); err != nil { - return - } - if err = iprot.ReadMessageEnd(); err != nil { - return + return fmt.Sprintf("DebugIndexMemorySegmentsResult_(%+v)", *p) +} + +type Node interface { + // Parameters: + // - Req + Query(req *QueryRequest) (r *QueryResult_, err error) + // Parameters: + // - Req + AggregateRaw(req *AggregateQueryRawRequest) (r *AggregateQueryRawResult_, err error) + // Parameters: + // - Req + Aggregate(req *AggregateQueryRequest) (r *AggregateQueryResult_, err error) + // Parameters: + // - Req + Fetch(req *FetchRequest) (r *FetchResult_, err error) + // Parameters: + // - Req + FetchTagged(req *FetchTaggedRequest) (r *FetchTaggedResult_, err error) + // Parameters: + // - Req + Write(req *WriteRequest) (err error) + // Parameters: + // - Req + WriteTagged(req *WriteTaggedRequest) (err error) + // Parameters: + // - Req + FetchBatchRaw(req *FetchBatchRawRequest) (r *FetchBatchRawResult_, err error) + // Parameters: + // - Req + FetchBatchRawV2(req *FetchBatchRawV2Request) (r *FetchBatchRawResult_, err error) + // Parameters: + // - Req + FetchBlocksRaw(req *FetchBlocksRawRequest) (r *FetchBlocksRawResult_, err error) + // Parameters: + // - Req + FetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (r *FetchBlocksMetadataRawV2Result_, err error) + // Parameters: + // - Req + WriteBatchRaw(req *WriteBatchRawRequest) (err error) + // Parameters: + // - Req + WriteBatchRawV2(req *WriteBatchRawV2Request) (err error) + // Parameters: + // - Req + WriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) + // Parameters: + // - Req + WriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) + Repair() (err error) + // Parameters: + // - Req + Truncate(req *TruncateRequest) (r *TruncateResult_, err error) + Health() (r *NodeHealthResult_, err error) + Bootstrapped() (r *NodeBootstrappedResult_, err error) + BootstrappedInPlacementOrNoPlacement() (r *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) + GetPersistRateLimit() (r *NodePersistRateLimitResult_, err error) + // Parameters: + // - Req + SetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (r *NodePersistRateLimitResult_, err error) + GetWriteNewSeriesAsync() (r *NodeWriteNewSeriesAsyncResult_, err error) + // Parameters: + // - Req + SetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (r *NodeWriteNewSeriesAsyncResult_, err error) + GetWriteNewSeriesBackoffDuration() (r *NodeWriteNewSeriesBackoffDurationResult_, err error) + // Parameters: + // - Req + SetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (r *NodeWriteNewSeriesBackoffDurationResult_, err error) + GetWriteNewSeriesLimitPerShardPerSecond() (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) + // Parameters: + // - Req + SetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) + // Parameters: + // - Req + DebugProfileStart(req *DebugProfileStartRequest) (r *DebugProfileStartResult_, err error) + // Parameters: + // - Req + DebugProfileStop(req *DebugProfileStopRequest) (r *DebugProfileStopResult_, err error) + // Parameters: + // - Req + DebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (r *DebugIndexMemorySegmentsResult_, err error) +} + +type NodeClient struct { + Transport thrift.TTransport + ProtocolFactory thrift.TProtocolFactory + InputProtocol thrift.TProtocol + OutputProtocol thrift.TProtocol + SeqId int32 +} + +func NewNodeClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *NodeClient { + return &NodeClient{Transport: t, + ProtocolFactory: f, + InputProtocol: f.GetProtocol(t), + OutputProtocol: f.GetProtocol(t), + SeqId: 0, } - if result.Err != nil { - err = result.Err - return +} + +func NewNodeClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *NodeClient { + return &NodeClient{Transport: t, + ProtocolFactory: nil, + InputProtocol: iprot, + OutputProtocol: oprot, + SeqId: 0, } - value = result.GetSuccess() - return } // Parameters: // - Req -func (p *NodeClient) FetchTagged(req *FetchTaggedRequest) (r *FetchTaggedResult_, err error) { - if err = p.sendFetchTagged(req); err != nil { +func (p *NodeClient) Query(req *QueryRequest) (r *QueryResult_, err error) { + if err = p.sendQuery(req); err != nil { return } - return p.recvFetchTagged() + return p.recvQuery() } -func (p *NodeClient) sendFetchTagged(req *FetchTaggedRequest) (err error) { +func (p *NodeClient) sendQuery(req *QueryRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("fetchTagged", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("query", thrift.CALL, p.SeqId); err != nil { return } - args := NodeFetchTaggedArgs{ + args := NodeQueryArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13515,7 +13821,7 @@ func (p *NodeClient) sendFetchTagged(req *FetchTaggedRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvFetchTagged() (value *FetchTaggedResult_, err error) { +func (p *NodeClient) recvQuery() (value *QueryResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13525,32 +13831,32 @@ func (p *NodeClient) recvFetchTagged() (value *FetchTaggedResult_, err error) { if err != nil { return } - if method != "fetchTagged" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchTagged failed: wrong method name") + if method != "query" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "query failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchTagged failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "query failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error43 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error44 error - error44, err = error43.Read(iprot) + error35 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error36 error + error36, err = error35.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error44 + err = error36 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchTagged failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "query failed: invalid message type") return } - result := NodeFetchTaggedResult{} + result := NodeQueryResult{} if err = result.Read(iprot); err != nil { return } @@ -13567,24 +13873,24 @@ func (p *NodeClient) recvFetchTagged() (value *FetchTaggedResult_, err error) { // Parameters: // - Req -func (p *NodeClient) Write(req *WriteRequest) (err error) { - if err = p.sendWrite(req); err != nil { +func (p *NodeClient) AggregateRaw(req *AggregateQueryRawRequest) (r *AggregateQueryRawResult_, err error) { + if err = p.sendAggregateRaw(req); err != nil { return } - return p.recvWrite() + return p.recvAggregateRaw() } -func (p *NodeClient) sendWrite(req *WriteRequest) (err error) { +func (p *NodeClient) sendAggregateRaw(req *AggregateQueryRawRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("write", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("aggregateRaw", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteArgs{ + args := NodeAggregateRawArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13596,7 +13902,7 @@ func (p *NodeClient) sendWrite(req *WriteRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvWrite() (err error) { +func (p *NodeClient) recvAggregateRaw() (value *AggregateQueryRawResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13606,32 +13912,32 @@ func (p *NodeClient) recvWrite() (err error) { if err != nil { return } - if method != "write" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "write failed: wrong method name") + if method != "aggregateRaw" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "aggregateRaw failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "write failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "aggregateRaw failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error45 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error46 error - error46, err = error45.Read(iprot) + error37 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error38 error + error38, err = error37.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error46 + err = error38 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "write failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "aggregateRaw failed: invalid message type") return } - result := NodeWriteResult{} + result := NodeAggregateRawResult{} if err = result.Read(iprot); err != nil { return } @@ -13642,29 +13948,30 @@ func (p *NodeClient) recvWrite() (err error) { err = result.Err return } + value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) WriteTagged(req *WriteTaggedRequest) (err error) { - if err = p.sendWriteTagged(req); err != nil { +func (p *NodeClient) Aggregate(req *AggregateQueryRequest) (r *AggregateQueryResult_, err error) { + if err = p.sendAggregate(req); err != nil { return } - return p.recvWriteTagged() + return p.recvAggregate() } -func (p *NodeClient) sendWriteTagged(req *WriteTaggedRequest) (err error) { +func (p *NodeClient) sendAggregate(req *AggregateQueryRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("writeTagged", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("aggregate", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteTaggedArgs{ + args := NodeAggregateArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13676,7 +13983,7 @@ func (p *NodeClient) sendWriteTagged(req *WriteTaggedRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvWriteTagged() (err error) { +func (p *NodeClient) recvAggregate() (value *AggregateQueryResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13686,32 +13993,32 @@ func (p *NodeClient) recvWriteTagged() (err error) { if err != nil { return } - if method != "writeTagged" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTagged failed: wrong method name") + if method != "aggregate" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "aggregate failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTagged failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "aggregate failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error47 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error48 error - error48, err = error47.Read(iprot) + error39 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error40 error + error40, err = error39.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error48 + err = error40 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTagged failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "aggregate failed: invalid message type") return } - result := NodeWriteTaggedResult{} + result := NodeAggregateResult{} if err = result.Read(iprot); err != nil { return } @@ -13722,29 +14029,30 @@ func (p *NodeClient) recvWriteTagged() (err error) { err = result.Err return } + value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) FetchBatchRaw(req *FetchBatchRawRequest) (r *FetchBatchRawResult_, err error) { - if err = p.sendFetchBatchRaw(req); err != nil { +func (p *NodeClient) Fetch(req *FetchRequest) (r *FetchResult_, err error) { + if err = p.sendFetch(req); err != nil { return } - return p.recvFetchBatchRaw() + return p.recvFetch() } -func (p *NodeClient) sendFetchBatchRaw(req *FetchBatchRawRequest) (err error) { +func (p *NodeClient) sendFetch(req *FetchRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("fetchBatchRaw", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetch", thrift.CALL, p.SeqId); err != nil { return } - args := NodeFetchBatchRawArgs{ + args := NodeFetchArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13756,7 +14064,7 @@ func (p *NodeClient) sendFetchBatchRaw(req *FetchBatchRawRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvFetchBatchRaw() (value *FetchBatchRawResult_, err error) { +func (p *NodeClient) recvFetch() (value *FetchResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13766,32 +14074,32 @@ func (p *NodeClient) recvFetchBatchRaw() (value *FetchBatchRawResult_, err error if err != nil { return } - if method != "fetchBatchRaw" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBatchRaw failed: wrong method name") + if method != "fetch" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetch failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBatchRaw failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetch failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error49 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error50 error - error50, err = error49.Read(iprot) + error41 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error42 error + error42, err = error41.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error50 + err = error42 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBatchRaw failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetch failed: invalid message type") return } - result := NodeFetchBatchRawResult{} + result := NodeFetchResult{} if err = result.Read(iprot); err != nil { return } @@ -13808,24 +14116,24 @@ func (p *NodeClient) recvFetchBatchRaw() (value *FetchBatchRawResult_, err error // Parameters: // - Req -func (p *NodeClient) FetchBatchRawV2(req *FetchBatchRawV2Request) (r *FetchBatchRawResult_, err error) { - if err = p.sendFetchBatchRawV2(req); err != nil { +func (p *NodeClient) FetchTagged(req *FetchTaggedRequest) (r *FetchTaggedResult_, err error) { + if err = p.sendFetchTagged(req); err != nil { return } - return p.recvFetchBatchRawV2() + return p.recvFetchTagged() } -func (p *NodeClient) sendFetchBatchRawV2(req *FetchBatchRawV2Request) (err error) { +func (p *NodeClient) sendFetchTagged(req *FetchTaggedRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("fetchBatchRawV2", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetchTagged", thrift.CALL, p.SeqId); err != nil { return } - args := NodeFetchBatchRawV2Args{ + args := NodeFetchTaggedArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13837,7 +14145,7 @@ func (p *NodeClient) sendFetchBatchRawV2(req *FetchBatchRawV2Request) (err error return oprot.Flush() } -func (p *NodeClient) recvFetchBatchRawV2() (value *FetchBatchRawResult_, err error) { +func (p *NodeClient) recvFetchTagged() (value *FetchTaggedResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13847,32 +14155,32 @@ func (p *NodeClient) recvFetchBatchRawV2() (value *FetchBatchRawResult_, err err if err != nil { return } - if method != "fetchBatchRawV2" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBatchRawV2 failed: wrong method name") + if method != "fetchTagged" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchTagged failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBatchRawV2 failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchTagged failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error51 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error52 error - error52, err = error51.Read(iprot) + error43 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error44 error + error44, err = error43.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error52 + err = error44 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBatchRawV2 failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchTagged failed: invalid message type") return } - result := NodeFetchBatchRawV2Result{} + result := NodeFetchTaggedResult{} if err = result.Read(iprot); err != nil { return } @@ -13889,24 +14197,24 @@ func (p *NodeClient) recvFetchBatchRawV2() (value *FetchBatchRawResult_, err err // Parameters: // - Req -func (p *NodeClient) FetchBlocksRaw(req *FetchBlocksRawRequest) (r *FetchBlocksRawResult_, err error) { - if err = p.sendFetchBlocksRaw(req); err != nil { +func (p *NodeClient) Write(req *WriteRequest) (err error) { + if err = p.sendWrite(req); err != nil { return } - return p.recvFetchBlocksRaw() + return p.recvWrite() } -func (p *NodeClient) sendFetchBlocksRaw(req *FetchBlocksRawRequest) (err error) { +func (p *NodeClient) sendWrite(req *WriteRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("fetchBlocksRaw", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("write", thrift.CALL, p.SeqId); err != nil { return } - args := NodeFetchBlocksRawArgs{ + args := NodeWriteArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13918,7 +14226,7 @@ func (p *NodeClient) sendFetchBlocksRaw(req *FetchBlocksRawRequest) (err error) return oprot.Flush() } -func (p *NodeClient) recvFetchBlocksRaw() (value *FetchBlocksRawResult_, err error) { +func (p *NodeClient) recvWrite() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -13928,32 +14236,32 @@ func (p *NodeClient) recvFetchBlocksRaw() (value *FetchBlocksRawResult_, err err if err != nil { return } - if method != "fetchBlocksRaw" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBlocksRaw failed: wrong method name") + if method != "write" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "write failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBlocksRaw failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "write failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error53 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error54 error - error54, err = error53.Read(iprot) + error45 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error46 error + error46, err = error45.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error54 + err = error46 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBlocksRaw failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "write failed: invalid message type") return } - result := NodeFetchBlocksRawResult{} + result := NodeWriteResult{} if err = result.Read(iprot); err != nil { return } @@ -13964,30 +14272,29 @@ func (p *NodeClient) recvFetchBlocksRaw() (value *FetchBlocksRawResult_, err err err = result.Err return } - value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) FetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (r *FetchBlocksMetadataRawV2Result_, err error) { - if err = p.sendFetchBlocksMetadataRawV2(req); err != nil { +func (p *NodeClient) WriteTagged(req *WriteTaggedRequest) (err error) { + if err = p.sendWriteTagged(req); err != nil { return } - return p.recvFetchBlocksMetadataRawV2() + return p.recvWriteTagged() } -func (p *NodeClient) sendFetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (err error) { +func (p *NodeClient) sendWriteTagged(req *WriteTaggedRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("writeTagged", thrift.CALL, p.SeqId); err != nil { return } - args := NodeFetchBlocksMetadataRawV2Args{ + args := NodeWriteTaggedArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -13999,7 +14306,7 @@ func (p *NodeClient) sendFetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2R return oprot.Flush() } -func (p *NodeClient) recvFetchBlocksMetadataRawV2() (value *FetchBlocksMetadataRawV2Result_, err error) { +func (p *NodeClient) recvWriteTagged() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14009,32 +14316,32 @@ func (p *NodeClient) recvFetchBlocksMetadataRawV2() (value *FetchBlocksMetadataR if err != nil { return } - if method != "fetchBlocksMetadataRawV2" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBlocksMetadataRawV2 failed: wrong method name") + if method != "writeTagged" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTagged failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBlocksMetadataRawV2 failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTagged failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error55 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error56 error - error56, err = error55.Read(iprot) + error47 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error48 error + error48, err = error47.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error56 + err = error48 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBlocksMetadataRawV2 failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTagged failed: invalid message type") return } - result := NodeFetchBlocksMetadataRawV2Result{} + result := NodeWriteTaggedResult{} if err = result.Read(iprot); err != nil { return } @@ -14045,30 +14352,29 @@ func (p *NodeClient) recvFetchBlocksMetadataRawV2() (value *FetchBlocksMetadataR err = result.Err return } - value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) WriteBatchRaw(req *WriteBatchRawRequest) (err error) { - if err = p.sendWriteBatchRaw(req); err != nil { +func (p *NodeClient) FetchBatchRaw(req *FetchBatchRawRequest) (r *FetchBatchRawResult_, err error) { + if err = p.sendFetchBatchRaw(req); err != nil { return } - return p.recvWriteBatchRaw() + return p.recvFetchBatchRaw() } -func (p *NodeClient) sendWriteBatchRaw(req *WriteBatchRawRequest) (err error) { +func (p *NodeClient) sendFetchBatchRaw(req *FetchBatchRawRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("writeBatchRaw", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetchBatchRaw", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteBatchRawArgs{ + args := NodeFetchBatchRawArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -14080,7 +14386,7 @@ func (p *NodeClient) sendWriteBatchRaw(req *WriteBatchRawRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvWriteBatchRaw() (err error) { +func (p *NodeClient) recvFetchBatchRaw() (value *FetchBatchRawResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14090,32 +14396,32 @@ func (p *NodeClient) recvWriteBatchRaw() (err error) { if err != nil { return } - if method != "writeBatchRaw" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeBatchRaw failed: wrong method name") + if method != "fetchBatchRaw" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBatchRaw failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeBatchRaw failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBatchRaw failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error57 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error58 error - error58, err = error57.Read(iprot) + error49 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error50 error + error50, err = error49.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error58 + err = error50 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeBatchRaw failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBatchRaw failed: invalid message type") return } - result := NodeWriteBatchRawResult{} + result := NodeFetchBatchRawResult{} if err = result.Read(iprot); err != nil { return } @@ -14126,29 +14432,30 @@ func (p *NodeClient) recvWriteBatchRaw() (err error) { err = result.Err return } + value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) WriteBatchRawV2(req *WriteBatchRawV2Request) (err error) { - if err = p.sendWriteBatchRawV2(req); err != nil { +func (p *NodeClient) FetchBatchRawV2(req *FetchBatchRawV2Request) (r *FetchBatchRawResult_, err error) { + if err = p.sendFetchBatchRawV2(req); err != nil { return } - return p.recvWriteBatchRawV2() + return p.recvFetchBatchRawV2() } -func (p *NodeClient) sendWriteBatchRawV2(req *WriteBatchRawV2Request) (err error) { +func (p *NodeClient) sendFetchBatchRawV2(req *FetchBatchRawV2Request) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("writeBatchRawV2", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetchBatchRawV2", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteBatchRawV2Args{ + args := NodeFetchBatchRawV2Args{ Req: req, } if err = args.Write(oprot); err != nil { @@ -14160,7 +14467,7 @@ func (p *NodeClient) sendWriteBatchRawV2(req *WriteBatchRawV2Request) (err error return oprot.Flush() } -func (p *NodeClient) recvWriteBatchRawV2() (err error) { +func (p *NodeClient) recvFetchBatchRawV2() (value *FetchBatchRawResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14170,32 +14477,32 @@ func (p *NodeClient) recvWriteBatchRawV2() (err error) { if err != nil { return } - if method != "writeBatchRawV2" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeBatchRawV2 failed: wrong method name") + if method != "fetchBatchRawV2" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBatchRawV2 failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeBatchRawV2 failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBatchRawV2 failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error59 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error60 error - error60, err = error59.Read(iprot) + error51 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error52 error + error52, err = error51.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error60 + err = error52 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeBatchRawV2 failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBatchRawV2 failed: invalid message type") return } - result := NodeWriteBatchRawV2Result{} + result := NodeFetchBatchRawV2Result{} if err = result.Read(iprot); err != nil { return } @@ -14206,29 +14513,30 @@ func (p *NodeClient) recvWriteBatchRawV2() (err error) { err = result.Err return } + value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) WriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) { - if err = p.sendWriteTaggedBatchRaw(req); err != nil { +func (p *NodeClient) FetchBlocksRaw(req *FetchBlocksRawRequest) (r *FetchBlocksRawResult_, err error) { + if err = p.sendFetchBlocksRaw(req); err != nil { return } - return p.recvWriteTaggedBatchRaw() + return p.recvFetchBlocksRaw() } -func (p *NodeClient) sendWriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) { +func (p *NodeClient) sendFetchBlocksRaw(req *FetchBlocksRawRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetchBlocksRaw", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteTaggedBatchRawArgs{ + args := NodeFetchBlocksRawArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -14240,7 +14548,7 @@ func (p *NodeClient) sendWriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (e return oprot.Flush() } -func (p *NodeClient) recvWriteTaggedBatchRaw() (err error) { +func (p *NodeClient) recvFetchBlocksRaw() (value *FetchBlocksRawResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14250,32 +14558,32 @@ func (p *NodeClient) recvWriteTaggedBatchRaw() (err error) { if err != nil { return } - if method != "writeTaggedBatchRaw" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTaggedBatchRaw failed: wrong method name") + if method != "fetchBlocksRaw" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBlocksRaw failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTaggedBatchRaw failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBlocksRaw failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error61 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error62 error - error62, err = error61.Read(iprot) + error53 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error54 error + error54, err = error53.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error62 + err = error54 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTaggedBatchRaw failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBlocksRaw failed: invalid message type") return } - result := NodeWriteTaggedBatchRawResult{} + result := NodeFetchBlocksRawResult{} if err = result.Read(iprot); err != nil { return } @@ -14286,29 +14594,30 @@ func (p *NodeClient) recvWriteTaggedBatchRaw() (err error) { err = result.Err return } + value = result.GetSuccess() return } // Parameters: // - Req -func (p *NodeClient) WriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) { - if err = p.sendWriteTaggedBatchRawV2(req); err != nil { +func (p *NodeClient) FetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (r *FetchBlocksMetadataRawV2Result_, err error) { + if err = p.sendFetchBlocksMetadataRawV2(req); err != nil { return } - return p.recvWriteTaggedBatchRawV2() + return p.recvFetchBlocksMetadataRawV2() } -func (p *NodeClient) sendWriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) { +func (p *NodeClient) sendFetchBlocksMetadataRawV2(req *FetchBlocksMetadataRawV2Request) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.CALL, p.SeqId); err != nil { return } - args := NodeWriteTaggedBatchRawV2Args{ + args := NodeFetchBlocksMetadataRawV2Args{ Req: req, } if err = args.Write(oprot); err != nil { @@ -14320,7 +14629,7 @@ func (p *NodeClient) sendWriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request return oprot.Flush() } -func (p *NodeClient) recvWriteTaggedBatchRawV2() (err error) { +func (p *NodeClient) recvFetchBlocksMetadataRawV2() (value *FetchBlocksMetadataRawV2Result_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14330,32 +14639,32 @@ func (p *NodeClient) recvWriteTaggedBatchRawV2() (err error) { if err != nil { return } - if method != "writeTaggedBatchRawV2" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTaggedBatchRawV2 failed: wrong method name") + if method != "fetchBlocksMetadataRawV2" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "fetchBlocksMetadataRawV2 failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTaggedBatchRawV2 failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "fetchBlocksMetadataRawV2 failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error63 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error64 error - error64, err = error63.Read(iprot) + error55 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error56 error + error56, err = error55.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error64 + err = error56 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTaggedBatchRawV2 failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "fetchBlocksMetadataRawV2 failed: invalid message type") return } - result := NodeWriteTaggedBatchRawV2Result{} + result := NodeFetchBlocksMetadataRawV2Result{} if err = result.Read(iprot); err != nil { return } @@ -14366,27 +14675,32 @@ func (p *NodeClient) recvWriteTaggedBatchRawV2() (err error) { err = result.Err return } + value = result.GetSuccess() return } -func (p *NodeClient) Repair() (err error) { - if err = p.sendRepair(); err != nil { +// Parameters: +// - Req +func (p *NodeClient) WriteBatchRaw(req *WriteBatchRawRequest) (err error) { + if err = p.sendWriteBatchRaw(req); err != nil { return } - return p.recvRepair() + return p.recvWriteBatchRaw() } -func (p *NodeClient) sendRepair() (err error) { +func (p *NodeClient) sendWriteBatchRaw(req *WriteBatchRawRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("repair", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("writeBatchRaw", thrift.CALL, p.SeqId); err != nil { return } - args := NodeRepairArgs{} + args := NodeWriteBatchRawArgs{ + Req: req, + } if err = args.Write(oprot); err != nil { return } @@ -14396,7 +14710,7 @@ func (p *NodeClient) sendRepair() (err error) { return oprot.Flush() } -func (p *NodeClient) recvRepair() (err error) { +func (p *NodeClient) recvWriteBatchRaw() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14406,32 +14720,32 @@ func (p *NodeClient) recvRepair() (err error) { if err != nil { return } - if method != "repair" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "repair failed: wrong method name") + if method != "writeBatchRaw" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeBatchRaw failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "repair failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeBatchRaw failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error65 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error66 error - error66, err = error65.Read(iprot) + error57 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error58 error + error58, err = error57.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error66 + err = error58 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "repair failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeBatchRaw failed: invalid message type") return } - result := NodeRepairResult{} + result := NodeWriteBatchRawResult{} if err = result.Read(iprot); err != nil { return } @@ -14447,24 +14761,24 @@ func (p *NodeClient) recvRepair() (err error) { // Parameters: // - Req -func (p *NodeClient) Truncate(req *TruncateRequest) (r *TruncateResult_, err error) { - if err = p.sendTruncate(req); err != nil { +func (p *NodeClient) WriteBatchRawV2(req *WriteBatchRawV2Request) (err error) { + if err = p.sendWriteBatchRawV2(req); err != nil { return } - return p.recvTruncate() + return p.recvWriteBatchRawV2() } -func (p *NodeClient) sendTruncate(req *TruncateRequest) (err error) { +func (p *NodeClient) sendWriteBatchRawV2(req *WriteBatchRawV2Request) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("truncate", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("writeBatchRawV2", thrift.CALL, p.SeqId); err != nil { return } - args := NodeTruncateArgs{ + args := NodeWriteBatchRawV2Args{ Req: req, } if err = args.Write(oprot); err != nil { @@ -14476,7 +14790,7 @@ func (p *NodeClient) sendTruncate(req *TruncateRequest) (err error) { return oprot.Flush() } -func (p *NodeClient) recvTruncate() (value *TruncateResult_, err error) { +func (p *NodeClient) recvWriteBatchRawV2() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14486,32 +14800,32 @@ func (p *NodeClient) recvTruncate() (value *TruncateResult_, err error) { if err != nil { return } - if method != "truncate" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "truncate failed: wrong method name") + if method != "writeBatchRawV2" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeBatchRawV2 failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "truncate failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeBatchRawV2 failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error67 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error68 error - error68, err = error67.Read(iprot) + error59 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error60 error + error60, err = error59.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error68 + err = error60 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "truncate failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeBatchRawV2 failed: invalid message type") return } - result := NodeTruncateResult{} + result := NodeWriteBatchRawV2Result{} if err = result.Read(iprot); err != nil { return } @@ -14522,28 +14836,31 @@ func (p *NodeClient) recvTruncate() (value *TruncateResult_, err error) { err = result.Err return } - value = result.GetSuccess() return } -func (p *NodeClient) Health() (r *NodeHealthResult_, err error) { - if err = p.sendHealth(); err != nil { +// Parameters: +// - Req +func (p *NodeClient) WriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) { + if err = p.sendWriteTaggedBatchRaw(req); err != nil { return } - return p.recvHealth() + return p.recvWriteTaggedBatchRaw() } -func (p *NodeClient) sendHealth() (err error) { +func (p *NodeClient) sendWriteTaggedBatchRaw(req *WriteTaggedBatchRawRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("health", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.CALL, p.SeqId); err != nil { return } - args := NodeHealthArgs{} + args := NodeWriteTaggedBatchRawArgs{ + Req: req, + } if err = args.Write(oprot); err != nil { return } @@ -14553,7 +14870,7 @@ func (p *NodeClient) sendHealth() (err error) { return oprot.Flush() } -func (p *NodeClient) recvHealth() (value *NodeHealthResult_, err error) { +func (p *NodeClient) recvWriteTaggedBatchRaw() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14563,32 +14880,32 @@ func (p *NodeClient) recvHealth() (value *NodeHealthResult_, err error) { if err != nil { return } - if method != "health" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "health failed: wrong method name") + if method != "writeTaggedBatchRaw" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTaggedBatchRaw failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "health failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTaggedBatchRaw failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error69 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error70 error - error70, err = error69.Read(iprot) + error61 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error62 error + error62, err = error61.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error70 + err = error62 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "health failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTaggedBatchRaw failed: invalid message type") return } - result := NodeHealthResult{} + result := NodeWriteTaggedBatchRawResult{} if err = result.Read(iprot); err != nil { return } @@ -14599,28 +14916,31 @@ func (p *NodeClient) recvHealth() (value *NodeHealthResult_, err error) { err = result.Err return } - value = result.GetSuccess() return } -func (p *NodeClient) Bootstrapped() (r *NodeBootstrappedResult_, err error) { - if err = p.sendBootstrapped(); err != nil { +// Parameters: +// - Req +func (p *NodeClient) WriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) { + if err = p.sendWriteTaggedBatchRawV2(req); err != nil { return } - return p.recvBootstrapped() + return p.recvWriteTaggedBatchRawV2() } -func (p *NodeClient) sendBootstrapped() (err error) { +func (p *NodeClient) sendWriteTaggedBatchRawV2(req *WriteTaggedBatchRawV2Request) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("bootstrapped", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.CALL, p.SeqId); err != nil { return } - args := NodeBootstrappedArgs{} + args := NodeWriteTaggedBatchRawV2Args{ + Req: req, + } if err = args.Write(oprot); err != nil { return } @@ -14630,7 +14950,7 @@ func (p *NodeClient) sendBootstrapped() (err error) { return oprot.Flush() } -func (p *NodeClient) recvBootstrapped() (value *NodeBootstrappedResult_, err error) { +func (p *NodeClient) recvWriteTaggedBatchRawV2() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14640,32 +14960,32 @@ func (p *NodeClient) recvBootstrapped() (value *NodeBootstrappedResult_, err err if err != nil { return } - if method != "bootstrapped" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "bootstrapped failed: wrong method name") + if method != "writeTaggedBatchRawV2" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "writeTaggedBatchRawV2 failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "bootstrapped failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "writeTaggedBatchRawV2 failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error71 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error72 error - error72, err = error71.Read(iprot) + error63 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error64 error + error64, err = error63.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error72 + err = error64 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "bootstrapped failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "writeTaggedBatchRawV2 failed: invalid message type") return } - result := NodeBootstrappedResult{} + result := NodeWriteTaggedBatchRawV2Result{} if err = result.Read(iprot); err != nil { return } @@ -14676,28 +14996,27 @@ func (p *NodeClient) recvBootstrapped() (value *NodeBootstrappedResult_, err err err = result.Err return } - value = result.GetSuccess() return } -func (p *NodeClient) BootstrappedInPlacementOrNoPlacement() (r *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) { - if err = p.sendBootstrappedInPlacementOrNoPlacement(); err != nil { +func (p *NodeClient) Repair() (err error) { + if err = p.sendRepair(); err != nil { return } - return p.recvBootstrappedInPlacementOrNoPlacement() + return p.recvRepair() } -func (p *NodeClient) sendBootstrappedInPlacementOrNoPlacement() (err error) { +func (p *NodeClient) sendRepair() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("repair", thrift.CALL, p.SeqId); err != nil { return } - args := NodeBootstrappedInPlacementOrNoPlacementArgs{} + args := NodeRepairArgs{} if err = args.Write(oprot); err != nil { return } @@ -14707,7 +15026,7 @@ func (p *NodeClient) sendBootstrappedInPlacementOrNoPlacement() (err error) { return oprot.Flush() } -func (p *NodeClient) recvBootstrappedInPlacementOrNoPlacement() (value *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) { +func (p *NodeClient) recvRepair() (err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14717,32 +15036,32 @@ func (p *NodeClient) recvBootstrappedInPlacementOrNoPlacement() (value *NodeBoot if err != nil { return } - if method != "bootstrappedInPlacementOrNoPlacement" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "bootstrappedInPlacementOrNoPlacement failed: wrong method name") + if method != "repair" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "repair failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "bootstrappedInPlacementOrNoPlacement failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "repair failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error73 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error74 error - error74, err = error73.Read(iprot) + error65 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error66 error + error66, err = error65.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error74 + err = error66 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "bootstrappedInPlacementOrNoPlacement failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "repair failed: invalid message type") return } - result := NodeBootstrappedInPlacementOrNoPlacementResult{} + result := NodeRepairResult{} if err = result.Read(iprot); err != nil { return } @@ -14753,28 +15072,31 @@ func (p *NodeClient) recvBootstrappedInPlacementOrNoPlacement() (value *NodeBoot err = result.Err return } - value = result.GetSuccess() return } -func (p *NodeClient) GetPersistRateLimit() (r *NodePersistRateLimitResult_, err error) { - if err = p.sendGetPersistRateLimit(); err != nil { +// Parameters: +// - Req +func (p *NodeClient) Truncate(req *TruncateRequest) (r *TruncateResult_, err error) { + if err = p.sendTruncate(req); err != nil { return } - return p.recvGetPersistRateLimit() + return p.recvTruncate() } -func (p *NodeClient) sendGetPersistRateLimit() (err error) { +func (p *NodeClient) sendTruncate(req *TruncateRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("getPersistRateLimit", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("truncate", thrift.CALL, p.SeqId); err != nil { return } - args := NodeGetPersistRateLimitArgs{} + args := NodeTruncateArgs{ + Req: req, + } if err = args.Write(oprot); err != nil { return } @@ -14784,7 +15106,7 @@ func (p *NodeClient) sendGetPersistRateLimit() (err error) { return oprot.Flush() } -func (p *NodeClient) recvGetPersistRateLimit() (value *NodePersistRateLimitResult_, err error) { +func (p *NodeClient) recvTruncate() (value *TruncateResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14794,32 +15116,32 @@ func (p *NodeClient) recvGetPersistRateLimit() (value *NodePersistRateLimitResul if err != nil { return } - if method != "getPersistRateLimit" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getPersistRateLimit failed: wrong method name") + if method != "truncate" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "truncate failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getPersistRateLimit failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "truncate failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error75 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error76 error - error76, err = error75.Read(iprot) + error67 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error68 error + error68, err = error67.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error76 + err = error68 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getPersistRateLimit failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "truncate failed: invalid message type") return } - result := NodeGetPersistRateLimitResult{} + result := NodeTruncateResult{} if err = result.Read(iprot); err != nil { return } @@ -14834,28 +15156,24 @@ func (p *NodeClient) recvGetPersistRateLimit() (value *NodePersistRateLimitResul return } -// Parameters: -// - Req -func (p *NodeClient) SetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (r *NodePersistRateLimitResult_, err error) { - if err = p.sendSetPersistRateLimit(req); err != nil { +func (p *NodeClient) Health() (r *NodeHealthResult_, err error) { + if err = p.sendHealth(); err != nil { return } - return p.recvSetPersistRateLimit() + return p.recvHealth() } -func (p *NodeClient) sendSetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (err error) { +func (p *NodeClient) sendHealth() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("setPersistRateLimit", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("health", thrift.CALL, p.SeqId); err != nil { return } - args := NodeSetPersistRateLimitArgs{ - Req: req, - } + args := NodeHealthArgs{} if err = args.Write(oprot); err != nil { return } @@ -14865,7 +15183,7 @@ func (p *NodeClient) sendSetPersistRateLimit(req *NodeSetPersistRateLimitRequest return oprot.Flush() } -func (p *NodeClient) recvSetPersistRateLimit() (value *NodePersistRateLimitResult_, err error) { +func (p *NodeClient) recvHealth() (value *NodeHealthResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14875,32 +15193,32 @@ func (p *NodeClient) recvSetPersistRateLimit() (value *NodePersistRateLimitResul if err != nil { return } - if method != "setPersistRateLimit" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setPersistRateLimit failed: wrong method name") + if method != "health" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "health failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setPersistRateLimit failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "health failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error77 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error78 error - error78, err = error77.Read(iprot) + error69 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error70 error + error70, err = error69.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error78 + err = error70 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setPersistRateLimit failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "health failed: invalid message type") return } - result := NodeSetPersistRateLimitResult{} + result := NodeHealthResult{} if err = result.Read(iprot); err != nil { return } @@ -14915,24 +15233,24 @@ func (p *NodeClient) recvSetPersistRateLimit() (value *NodePersistRateLimitResul return } -func (p *NodeClient) GetWriteNewSeriesAsync() (r *NodeWriteNewSeriesAsyncResult_, err error) { - if err = p.sendGetWriteNewSeriesAsync(); err != nil { +func (p *NodeClient) Bootstrapped() (r *NodeBootstrappedResult_, err error) { + if err = p.sendBootstrapped(); err != nil { return } - return p.recvGetWriteNewSeriesAsync() + return p.recvBootstrapped() } -func (p *NodeClient) sendGetWriteNewSeriesAsync() (err error) { +func (p *NodeClient) sendBootstrapped() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("bootstrapped", thrift.CALL, p.SeqId); err != nil { return } - args := NodeGetWriteNewSeriesAsyncArgs{} + args := NodeBootstrappedArgs{} if err = args.Write(oprot); err != nil { return } @@ -14942,7 +15260,7 @@ func (p *NodeClient) sendGetWriteNewSeriesAsync() (err error) { return oprot.Flush() } -func (p *NodeClient) recvGetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyncResult_, err error) { +func (p *NodeClient) recvBootstrapped() (value *NodeBootstrappedResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -14952,32 +15270,32 @@ func (p *NodeClient) recvGetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyn if err != nil { return } - if method != "getWriteNewSeriesAsync" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesAsync failed: wrong method name") + if method != "bootstrapped" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "bootstrapped failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesAsync failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "bootstrapped failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error79 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error80 error - error80, err = error79.Read(iprot) + error71 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error72 error + error72, err = error71.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error80 + err = error72 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesAsync failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "bootstrapped failed: invalid message type") return } - result := NodeGetWriteNewSeriesAsyncResult{} + result := NodeBootstrappedResult{} if err = result.Read(iprot); err != nil { return } @@ -14992,28 +15310,24 @@ func (p *NodeClient) recvGetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyn return } -// Parameters: -// - Req -func (p *NodeClient) SetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (r *NodeWriteNewSeriesAsyncResult_, err error) { - if err = p.sendSetWriteNewSeriesAsync(req); err != nil { +func (p *NodeClient) BootstrappedInPlacementOrNoPlacement() (r *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) { + if err = p.sendBootstrappedInPlacementOrNoPlacement(); err != nil { return } - return p.recvSetWriteNewSeriesAsync() + return p.recvBootstrappedInPlacementOrNoPlacement() } -func (p *NodeClient) sendSetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (err error) { +func (p *NodeClient) sendBootstrappedInPlacementOrNoPlacement() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.CALL, p.SeqId); err != nil { return } - args := NodeSetWriteNewSeriesAsyncArgs{ - Req: req, - } + args := NodeBootstrappedInPlacementOrNoPlacementArgs{} if err = args.Write(oprot); err != nil { return } @@ -15023,7 +15337,7 @@ func (p *NodeClient) sendSetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncR return oprot.Flush() } -func (p *NodeClient) recvSetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyncResult_, err error) { +func (p *NodeClient) recvBootstrappedInPlacementOrNoPlacement() (value *NodeBootstrappedInPlacementOrNoPlacementResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15033,32 +15347,32 @@ func (p *NodeClient) recvSetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyn if err != nil { return } - if method != "setWriteNewSeriesAsync" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesAsync failed: wrong method name") + if method != "bootstrappedInPlacementOrNoPlacement" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "bootstrappedInPlacementOrNoPlacement failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesAsync failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "bootstrappedInPlacementOrNoPlacement failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error81 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error82 error - error82, err = error81.Read(iprot) + error73 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error74 error + error74, err = error73.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error82 + err = error74 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesAsync failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "bootstrappedInPlacementOrNoPlacement failed: invalid message type") return } - result := NodeSetWriteNewSeriesAsyncResult{} + result := NodeBootstrappedInPlacementOrNoPlacementResult{} if err = result.Read(iprot); err != nil { return } @@ -15073,24 +15387,24 @@ func (p *NodeClient) recvSetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyn return } -func (p *NodeClient) GetWriteNewSeriesBackoffDuration() (r *NodeWriteNewSeriesBackoffDurationResult_, err error) { - if err = p.sendGetWriteNewSeriesBackoffDuration(); err != nil { +func (p *NodeClient) GetPersistRateLimit() (r *NodePersistRateLimitResult_, err error) { + if err = p.sendGetPersistRateLimit(); err != nil { return } - return p.recvGetWriteNewSeriesBackoffDuration() + return p.recvGetPersistRateLimit() } -func (p *NodeClient) sendGetWriteNewSeriesBackoffDuration() (err error) { +func (p *NodeClient) sendGetPersistRateLimit() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("getPersistRateLimit", thrift.CALL, p.SeqId); err != nil { return } - args := NodeGetWriteNewSeriesBackoffDurationArgs{} + args := NodeGetPersistRateLimitArgs{} if err = args.Write(oprot); err != nil { return } @@ -15100,7 +15414,7 @@ func (p *NodeClient) sendGetWriteNewSeriesBackoffDuration() (err error) { return oprot.Flush() } -func (p *NodeClient) recvGetWriteNewSeriesBackoffDuration() (value *NodeWriteNewSeriesBackoffDurationResult_, err error) { +func (p *NodeClient) recvGetPersistRateLimit() (value *NodePersistRateLimitResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15110,32 +15424,32 @@ func (p *NodeClient) recvGetWriteNewSeriesBackoffDuration() (value *NodeWriteNew if err != nil { return } - if method != "getWriteNewSeriesBackoffDuration" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesBackoffDuration failed: wrong method name") + if method != "getPersistRateLimit" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getPersistRateLimit failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesBackoffDuration failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getPersistRateLimit failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error83 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error84 error - error84, err = error83.Read(iprot) + error75 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error76 error + error76, err = error75.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error84 + err = error76 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesBackoffDuration failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getPersistRateLimit failed: invalid message type") return } - result := NodeGetWriteNewSeriesBackoffDurationResult{} + result := NodeGetPersistRateLimitResult{} if err = result.Read(iprot); err != nil { return } @@ -15152,24 +15466,24 @@ func (p *NodeClient) recvGetWriteNewSeriesBackoffDuration() (value *NodeWriteNew // Parameters: // - Req -func (p *NodeClient) SetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (r *NodeWriteNewSeriesBackoffDurationResult_, err error) { - if err = p.sendSetWriteNewSeriesBackoffDuration(req); err != nil { +func (p *NodeClient) SetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (r *NodePersistRateLimitResult_, err error) { + if err = p.sendSetPersistRateLimit(req); err != nil { return } - return p.recvSetWriteNewSeriesBackoffDuration() + return p.recvSetPersistRateLimit() } -func (p *NodeClient) sendSetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (err error) { +func (p *NodeClient) sendSetPersistRateLimit(req *NodeSetPersistRateLimitRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("setPersistRateLimit", thrift.CALL, p.SeqId); err != nil { return } - args := NodeSetWriteNewSeriesBackoffDurationArgs{ + args := NodeSetPersistRateLimitArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -15181,7 +15495,7 @@ func (p *NodeClient) sendSetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSe return oprot.Flush() } -func (p *NodeClient) recvSetWriteNewSeriesBackoffDuration() (value *NodeWriteNewSeriesBackoffDurationResult_, err error) { +func (p *NodeClient) recvSetPersistRateLimit() (value *NodePersistRateLimitResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15191,32 +15505,32 @@ func (p *NodeClient) recvSetWriteNewSeriesBackoffDuration() (value *NodeWriteNew if err != nil { return } - if method != "setWriteNewSeriesBackoffDuration" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesBackoffDuration failed: wrong method name") + if method != "setPersistRateLimit" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setPersistRateLimit failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesBackoffDuration failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setPersistRateLimit failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error85 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error86 error - error86, err = error85.Read(iprot) + error77 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error78 error + error78, err = error77.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error86 + err = error78 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesBackoffDuration failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setPersistRateLimit failed: invalid message type") return } - result := NodeSetWriteNewSeriesBackoffDurationResult{} + result := NodeSetPersistRateLimitResult{} if err = result.Read(iprot); err != nil { return } @@ -15231,24 +15545,24 @@ func (p *NodeClient) recvSetWriteNewSeriesBackoffDuration() (value *NodeWriteNew return } -func (p *NodeClient) GetWriteNewSeriesLimitPerShardPerSecond() (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { - if err = p.sendGetWriteNewSeriesLimitPerShardPerSecond(); err != nil { +func (p *NodeClient) GetWriteNewSeriesAsync() (r *NodeWriteNewSeriesAsyncResult_, err error) { + if err = p.sendGetWriteNewSeriesAsync(); err != nil { return } - return p.recvGetWriteNewSeriesLimitPerShardPerSecond() + return p.recvGetWriteNewSeriesAsync() } -func (p *NodeClient) sendGetWriteNewSeriesLimitPerShardPerSecond() (err error) { +func (p *NodeClient) sendGetWriteNewSeriesAsync() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.CALL, p.SeqId); err != nil { return } - args := NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} + args := NodeGetWriteNewSeriesAsyncArgs{} if err = args.Write(oprot); err != nil { return } @@ -15258,7 +15572,7 @@ func (p *NodeClient) sendGetWriteNewSeriesLimitPerShardPerSecond() (err error) { return oprot.Flush() } -func (p *NodeClient) recvGetWriteNewSeriesLimitPerShardPerSecond() (value *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { +func (p *NodeClient) recvGetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyncResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15268,32 +15582,32 @@ func (p *NodeClient) recvGetWriteNewSeriesLimitPerShardPerSecond() (value *NodeW if err != nil { return } - if method != "getWriteNewSeriesLimitPerShardPerSecond" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesLimitPerShardPerSecond failed: wrong method name") + if method != "getWriteNewSeriesAsync" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesAsync failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesLimitPerShardPerSecond failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesAsync failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error87 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error88 error - error88, err = error87.Read(iprot) + error79 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error80 error + error80, err = error79.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error88 + err = error80 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesLimitPerShardPerSecond failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesAsync failed: invalid message type") return } - result := NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} + result := NodeGetWriteNewSeriesAsyncResult{} if err = result.Read(iprot); err != nil { return } @@ -15310,24 +15624,24 @@ func (p *NodeClient) recvGetWriteNewSeriesLimitPerShardPerSecond() (value *NodeW // Parameters: // - Req -func (p *NodeClient) SetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { - if err = p.sendSetWriteNewSeriesLimitPerShardPerSecond(req); err != nil { +func (p *NodeClient) SetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (r *NodeWriteNewSeriesAsyncResult_, err error) { + if err = p.sendSetWriteNewSeriesAsync(req); err != nil { return } - return p.recvSetWriteNewSeriesLimitPerShardPerSecond() + return p.recvSetWriteNewSeriesAsync() } -func (p *NodeClient) sendSetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (err error) { +func (p *NodeClient) sendSetWriteNewSeriesAsync(req *NodeSetWriteNewSeriesAsyncRequest) (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.CALL, p.SeqId); err != nil { return } - args := NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{ + args := NodeSetWriteNewSeriesAsyncArgs{ Req: req, } if err = args.Write(oprot); err != nil { @@ -15339,7 +15653,7 @@ func (p *NodeClient) sendSetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWri return oprot.Flush() } -func (p *NodeClient) recvSetWriteNewSeriesLimitPerShardPerSecond() (value *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { +func (p *NodeClient) recvSetWriteNewSeriesAsync() (value *NodeWriteNewSeriesAsyncResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15349,32 +15663,32 @@ func (p *NodeClient) recvSetWriteNewSeriesLimitPerShardPerSecond() (value *NodeW if err != nil { return } - if method != "setWriteNewSeriesLimitPerShardPerSecond" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesLimitPerShardPerSecond failed: wrong method name") + if method != "setWriteNewSeriesAsync" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesAsync failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesLimitPerShardPerSecond failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesAsync failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error89 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error90 error - error90, err = error89.Read(iprot) + error81 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error82 error + error82, err = error81.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error90 + err = error82 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesLimitPerShardPerSecond failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesAsync failed: invalid message type") return } - result := NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} + result := NodeSetWriteNewSeriesAsyncResult{} if err = result.Read(iprot); err != nil { return } @@ -15389,28 +15703,24 @@ func (p *NodeClient) recvSetWriteNewSeriesLimitPerShardPerSecond() (value *NodeW return } -// Parameters: -// - Req -func (p *NodeClient) DebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (r *DebugIndexMemorySegmentsResult_, err error) { - if err = p.sendDebugIndexMemorySegments(req); err != nil { +func (p *NodeClient) GetWriteNewSeriesBackoffDuration() (r *NodeWriteNewSeriesBackoffDurationResult_, err error) { + if err = p.sendGetWriteNewSeriesBackoffDuration(); err != nil { return } - return p.recvDebugIndexMemorySegments() + return p.recvGetWriteNewSeriesBackoffDuration() } -func (p *NodeClient) sendDebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (err error) { +func (p *NodeClient) sendGetWriteNewSeriesBackoffDuration() (err error) { oprot := p.OutputProtocol if oprot == nil { oprot = p.ProtocolFactory.GetProtocol(p.Transport) p.OutputProtocol = oprot } p.SeqId++ - if err = oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.CALL, p.SeqId); err != nil { + if err = oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.CALL, p.SeqId); err != nil { return } - args := NodeDebugIndexMemorySegmentsArgs{ - Req: req, - } + args := NodeGetWriteNewSeriesBackoffDurationArgs{} if err = args.Write(oprot); err != nil { return } @@ -15420,7 +15730,7 @@ func (p *NodeClient) sendDebugIndexMemorySegments(req *DebugIndexMemorySegmentsR return oprot.Flush() } -func (p *NodeClient) recvDebugIndexMemorySegments() (value *DebugIndexMemorySegmentsResult_, err error) { +func (p *NodeClient) recvGetWriteNewSeriesBackoffDuration() (value *NodeWriteNewSeriesBackoffDurationResult_, err error) { iprot := p.InputProtocol if iprot == nil { iprot = p.ProtocolFactory.GetProtocol(p.Transport) @@ -15430,32 +15740,32 @@ func (p *NodeClient) recvDebugIndexMemorySegments() (value *DebugIndexMemorySegm if err != nil { return } - if method != "debugIndexMemorySegments" { - err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "debugIndexMemorySegments failed: wrong method name") + if method != "getWriteNewSeriesBackoffDuration" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesBackoffDuration failed: wrong method name") return } if p.SeqId != seqId { - err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "debugIndexMemorySegments failed: out of sequence response") + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesBackoffDuration failed: out of sequence response") return } if mTypeId == thrift.EXCEPTION { - error91 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error92 error - error92, err = error91.Read(iprot) + error83 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error84 error + error84, err = error83.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error92 + err = error84 return } if mTypeId != thrift.REPLY { - err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "debugIndexMemorySegments failed: invalid message type") + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesBackoffDuration failed: invalid message type") return } - result := NodeDebugIndexMemorySegmentsResult{} + result := NodeGetWriteNewSeriesBackoffDurationResult{} if err = result.Read(iprot); err != nil { return } @@ -15470,453 +15780,572 @@ func (p *NodeClient) recvDebugIndexMemorySegments() (value *DebugIndexMemorySegm return } -type NodeProcessor struct { - processorMap map[string]thrift.TProcessorFunction - handler Node -} - -func (p *NodeProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { - p.processorMap[key] = processor -} - -func (p *NodeProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { - processor, ok = p.processorMap[key] - return processor, ok -} - -func (p *NodeProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { - return p.processorMap -} - -func NewNodeProcessor(handler Node) *NodeProcessor { - - self93 := &NodeProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} - self93.processorMap["query"] = &nodeProcessorQuery{handler: handler} - self93.processorMap["aggregateRaw"] = &nodeProcessorAggregateRaw{handler: handler} - self93.processorMap["aggregate"] = &nodeProcessorAggregate{handler: handler} - self93.processorMap["fetch"] = &nodeProcessorFetch{handler: handler} - self93.processorMap["fetchTagged"] = &nodeProcessorFetchTagged{handler: handler} - self93.processorMap["write"] = &nodeProcessorWrite{handler: handler} - self93.processorMap["writeTagged"] = &nodeProcessorWriteTagged{handler: handler} - self93.processorMap["fetchBatchRaw"] = &nodeProcessorFetchBatchRaw{handler: handler} - self93.processorMap["fetchBatchRawV2"] = &nodeProcessorFetchBatchRawV2{handler: handler} - self93.processorMap["fetchBlocksRaw"] = &nodeProcessorFetchBlocksRaw{handler: handler} - self93.processorMap["fetchBlocksMetadataRawV2"] = &nodeProcessorFetchBlocksMetadataRawV2{handler: handler} - self93.processorMap["writeBatchRaw"] = &nodeProcessorWriteBatchRaw{handler: handler} - self93.processorMap["writeBatchRawV2"] = &nodeProcessorWriteBatchRawV2{handler: handler} - self93.processorMap["writeTaggedBatchRaw"] = &nodeProcessorWriteTaggedBatchRaw{handler: handler} - self93.processorMap["writeTaggedBatchRawV2"] = &nodeProcessorWriteTaggedBatchRawV2{handler: handler} - self93.processorMap["repair"] = &nodeProcessorRepair{handler: handler} - self93.processorMap["truncate"] = &nodeProcessorTruncate{handler: handler} - self93.processorMap["health"] = &nodeProcessorHealth{handler: handler} - self93.processorMap["bootstrapped"] = &nodeProcessorBootstrapped{handler: handler} - self93.processorMap["bootstrappedInPlacementOrNoPlacement"] = &nodeProcessorBootstrappedInPlacementOrNoPlacement{handler: handler} - self93.processorMap["getPersistRateLimit"] = &nodeProcessorGetPersistRateLimit{handler: handler} - self93.processorMap["setPersistRateLimit"] = &nodeProcessorSetPersistRateLimit{handler: handler} - self93.processorMap["getWriteNewSeriesAsync"] = &nodeProcessorGetWriteNewSeriesAsync{handler: handler} - self93.processorMap["setWriteNewSeriesAsync"] = &nodeProcessorSetWriteNewSeriesAsync{handler: handler} - self93.processorMap["getWriteNewSeriesBackoffDuration"] = &nodeProcessorGetWriteNewSeriesBackoffDuration{handler: handler} - self93.processorMap["setWriteNewSeriesBackoffDuration"] = &nodeProcessorSetWriteNewSeriesBackoffDuration{handler: handler} - self93.processorMap["getWriteNewSeriesLimitPerShardPerSecond"] = &nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond{handler: handler} - self93.processorMap["setWriteNewSeriesLimitPerShardPerSecond"] = &nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond{handler: handler} - self93.processorMap["debugIndexMemorySegments"] = &nodeProcessorDebugIndexMemorySegments{handler: handler} - return self93 +// Parameters: +// - Req +func (p *NodeClient) SetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (r *NodeWriteNewSeriesBackoffDurationResult_, err error) { + if err = p.sendSetWriteNewSeriesBackoffDuration(req); err != nil { + return + } + return p.recvSetWriteNewSeriesBackoffDuration() } -func (p *NodeProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - name, _, seqId, err := iprot.ReadMessageBegin() - if err != nil { - return false, err +func (p *NodeClient) sendSetWriteNewSeriesBackoffDuration(req *NodeSetWriteNewSeriesBackoffDurationRequest) (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot } - if processor, ok := p.GetProcessorFunction(name); ok { - return processor.Process(seqId, iprot, oprot) + p.SeqId++ + if err = oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.CALL, p.SeqId); err != nil { + return } - iprot.Skip(thrift.STRUCT) - iprot.ReadMessageEnd() - x94 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) - oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) - x94.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, x94 - + args := NodeSetWriteNewSeriesBackoffDurationArgs{ + Req: req, + } + if err = args.Write(oprot); err != nil { + return + } + if err = oprot.WriteMessageEnd(); err != nil { + return + } + return oprot.Flush() } -type nodeProcessorQuery struct { - handler Node -} - -func (p *nodeProcessorQuery) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeQueryArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("query", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeClient) recvSetWriteNewSeriesBackoffDuration() (value *NodeWriteNewSeriesBackoffDurationResult_, err error) { + iprot := p.InputProtocol + if iprot == nil { + iprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.InputProtocol = iprot } - - iprot.ReadMessageEnd() - result := NodeQueryResult{} - var retval *QueryResult_ - var err2 error - if retval, err2 = p.handler.Query(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query: "+err2.Error()) - oprot.WriteMessageBegin("query", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval + method, mTypeId, seqId, err := iprot.ReadMessageBegin() + if err != nil { + return } - if err2 = oprot.WriteMessageBegin("query", thrift.REPLY, seqId); err2 != nil { - err = err2 + if method != "setWriteNewSeriesBackoffDuration" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesBackoffDuration failed: wrong method name") + return } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesBackoffDuration failed: out of sequence response") + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if mTypeId == thrift.EXCEPTION { + error85 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error86 error + error86, err = error85.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error86 + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesBackoffDuration failed: invalid message type") + return } - if err != nil { + result := NodeSetWriteNewSeriesBackoffDurationResult{} + if err = result.Read(iprot); err != nil { return } - return true, err + if err = iprot.ReadMessageEnd(); err != nil { + return + } + if result.Err != nil { + err = result.Err + return + } + value = result.GetSuccess() + return } -type nodeProcessorAggregateRaw struct { - handler Node +func (p *NodeClient) GetWriteNewSeriesLimitPerShardPerSecond() (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { + if err = p.sendGetWriteNewSeriesLimitPerShardPerSecond(); err != nil { + return + } + return p.recvGetWriteNewSeriesLimitPerShardPerSecond() } -func (p *nodeProcessorAggregateRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeAggregateRawArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("aggregateRaw", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeClient) sendGetWriteNewSeriesLimitPerShardPerSecond() (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot + } + p.SeqId++ + if err = oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.CALL, p.SeqId); err != nil { + return + } + args := NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} + if err = args.Write(oprot); err != nil { + return } + if err = oprot.WriteMessageEnd(); err != nil { + return + } + return oprot.Flush() +} - iprot.ReadMessageEnd() - result := NodeAggregateRawResult{} - var retval *AggregateQueryRawResult_ - var err2 error - if retval, err2 = p.handler.AggregateRaw(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing aggregateRaw: "+err2.Error()) - oprot.WriteMessageBegin("aggregateRaw", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval +func (p *NodeClient) recvGetWriteNewSeriesLimitPerShardPerSecond() (value *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { + iprot := p.InputProtocol + if iprot == nil { + iprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.InputProtocol = iprot } - if err2 = oprot.WriteMessageBegin("aggregateRaw", thrift.REPLY, seqId); err2 != nil { - err = err2 + method, mTypeId, seqId, err := iprot.ReadMessageBegin() + if err != nil { + return } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if method != "getWriteNewSeriesLimitPerShardPerSecond" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "getWriteNewSeriesLimitPerShardPerSecond failed: wrong method name") + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getWriteNewSeriesLimitPerShardPerSecond failed: out of sequence response") + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + if mTypeId == thrift.EXCEPTION { + error87 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error88 error + error88, err = error87.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error88 + return } - if err != nil { + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "getWriteNewSeriesLimitPerShardPerSecond failed: invalid message type") return } - return true, err + result := NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} + 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 } -type nodeProcessorAggregate struct { - handler Node +// Parameters: +// - Req +func (p *NodeClient) SetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (r *NodeWriteNewSeriesLimitPerShardPerSecondResult_, err error) { + if err = p.sendSetWriteNewSeriesLimitPerShardPerSecond(req); err != nil { + return + } + return p.recvSetWriteNewSeriesLimitPerShardPerSecond() } -func (p *nodeProcessorAggregate) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeAggregateArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("aggregate", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeClient) sendSetWriteNewSeriesLimitPerShardPerSecond(req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot } - - iprot.ReadMessageEnd() - result := NodeAggregateResult{} - var retval *AggregateQueryResult_ - var err2 error - if retval, err2 = p.handler.Aggregate(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing aggregate: "+err2.Error()) - oprot.WriteMessageBegin("aggregate", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval + p.SeqId++ + if err = oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.CALL, p.SeqId); err != nil { + return } - if err2 = oprot.WriteMessageBegin("aggregate", thrift.REPLY, seqId); err2 != nil { - err = err2 + args := NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{ + Req: req, } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if err = args.Write(oprot); err != nil { + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if err = oprot.WriteMessageEnd(); err != nil { + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + return oprot.Flush() +} + +func (p *NodeClient) recvSetWriteNewSeriesLimitPerShardPerSecond() (value *NodeWriteNewSeriesLimitPerShardPerSecondResult_, 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 } - return true, err -} - -type nodeProcessorFetch struct { - handler Node -} - -func (p *nodeProcessorFetch) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetch", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err + if method != "setWriteNewSeriesLimitPerShardPerSecond" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "setWriteNewSeriesLimitPerShardPerSecond failed: wrong method name") + return } - - iprot.ReadMessageEnd() - result := NodeFetchResult{} - var retval *FetchResult_ - var err2 error - if retval, err2 = p.handler.Fetch(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetch: "+err2.Error()) - oprot.WriteMessageBegin("fetch", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "setWriteNewSeriesLimitPerShardPerSecond failed: out of sequence response") + return } - if err2 = oprot.WriteMessageBegin("fetch", thrift.REPLY, seqId); err2 != nil { - err = err2 + if mTypeId == thrift.EXCEPTION { + error89 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error90 error + error90, err = error89.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error90 + return } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "setWriteNewSeriesLimitPerShardPerSecond failed: invalid message type") + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + result := NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} + if err = result.Read(iprot); err != nil { + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + if err = iprot.ReadMessageEnd(); err != nil { + return } - if err != nil { + if result.Err != nil { + err = result.Err return } - return true, err + value = result.GetSuccess() + return } -type nodeProcessorFetchTagged struct { - handler Node +// Parameters: +// - Req +func (p *NodeClient) DebugProfileStart(req *DebugProfileStartRequest) (r *DebugProfileStartResult_, err error) { + if err = p.sendDebugProfileStart(req); err != nil { + return + } + return p.recvDebugProfileStart() } -func (p *nodeProcessorFetchTagged) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchTaggedArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetchTagged", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeClient) sendDebugProfileStart(req *DebugProfileStartRequest) (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot } - - iprot.ReadMessageEnd() - result := NodeFetchTaggedResult{} - var retval *FetchTaggedResult_ - var err2 error - if retval, err2 = p.handler.FetchTagged(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchTagged: "+err2.Error()) - oprot.WriteMessageBegin("fetchTagged", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval + p.SeqId++ + if err = oprot.WriteMessageBegin("debugProfileStart", thrift.CALL, p.SeqId); err != nil { + return } - if err2 = oprot.WriteMessageBegin("fetchTagged", thrift.REPLY, seqId); err2 != nil { - err = err2 + args := NodeDebugProfileStartArgs{ + Req: req, } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if err = args.Write(oprot); err != nil { + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if err = oprot.WriteMessageEnd(); err != nil { + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + return oprot.Flush() +} + +func (p *NodeClient) recvDebugProfileStart() (value *DebugProfileStartResult_, 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 } - return true, err -} - -type nodeProcessorWrite struct { - handler Node -} - -func (p *nodeProcessorWrite) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("write", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err + if method != "debugProfileStart" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "debugProfileStart failed: wrong method name") + return } - - iprot.ReadMessageEnd() - result := NodeWriteResult{} - var err2 error - if err2 = p.handler.Write(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing write: "+err2.Error()) - oprot.WriteMessageBegin("write", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "debugProfileStart failed: out of sequence response") + return } - if err2 = oprot.WriteMessageBegin("write", thrift.REPLY, seqId); err2 != nil { - err = err2 + if mTypeId == thrift.EXCEPTION { + error91 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error92 error + error92, err = error91.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error92 + return } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "debugProfileStart failed: invalid message type") + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + result := NodeDebugProfileStartResult{} + if err = result.Read(iprot); err != nil { + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + if err = iprot.ReadMessageEnd(); err != nil { + return } - if err != nil { + if result.Err != nil { + err = result.Err return } - return true, err + value = result.GetSuccess() + return } -type nodeProcessorWriteTagged struct { - handler Node +// Parameters: +// - Req +func (p *NodeClient) DebugProfileStop(req *DebugProfileStopRequest) (r *DebugProfileStopResult_, err error) { + if err = p.sendDebugProfileStop(req); err != nil { + return + } + return p.recvDebugProfileStop() } -func (p *nodeProcessorWriteTagged) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteTaggedArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("writeTagged", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeClient) sendDebugProfileStop(req *DebugProfileStopRequest) (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot } - - iprot.ReadMessageEnd() - result := NodeWriteTaggedResult{} - var err2 error - if err2 = p.handler.WriteTagged(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTagged: "+err2.Error()) - oprot.WriteMessageBegin("writeTagged", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } + p.SeqId++ + if err = oprot.WriteMessageBegin("debugProfileStop", thrift.CALL, p.SeqId); err != nil { + return } - if err2 = oprot.WriteMessageBegin("writeTagged", thrift.REPLY, seqId); err2 != nil { - err = err2 + args := NodeDebugProfileStopArgs{ + Req: req, } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if err = args.Write(oprot); err != nil { + return } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if err = oprot.WriteMessageEnd(); err != nil { + return } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + return oprot.Flush() +} + +func (p *NodeClient) recvDebugProfileStop() (value *DebugProfileStopResult_, 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 } - return true, err + if method != "debugProfileStop" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "debugProfileStop failed: wrong method name") + return + } + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "debugProfileStop failed: out of sequence response") + return + } + if mTypeId == thrift.EXCEPTION { + error93 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error94 error + error94, err = error93.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error94 + return + } + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "debugProfileStop failed: invalid message type") + return + } + result := NodeDebugProfileStopResult{} + 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 } -type nodeProcessorFetchBatchRaw struct { +// Parameters: +// - Req +func (p *NodeClient) DebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (r *DebugIndexMemorySegmentsResult_, err error) { + if err = p.sendDebugIndexMemorySegments(req); err != nil { + return + } + return p.recvDebugIndexMemorySegments() +} + +func (p *NodeClient) sendDebugIndexMemorySegments(req *DebugIndexMemorySegmentsRequest) (err error) { + oprot := p.OutputProtocol + if oprot == nil { + oprot = p.ProtocolFactory.GetProtocol(p.Transport) + p.OutputProtocol = oprot + } + p.SeqId++ + if err = oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.CALL, p.SeqId); err != nil { + return + } + args := NodeDebugIndexMemorySegmentsArgs{ + Req: req, + } + if err = args.Write(oprot); err != nil { + return + } + if err = oprot.WriteMessageEnd(); err != nil { + return + } + return oprot.Flush() +} + +func (p *NodeClient) recvDebugIndexMemorySegments() (value *DebugIndexMemorySegmentsResult_, 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 != "debugIndexMemorySegments" { + err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "debugIndexMemorySegments failed: wrong method name") + return + } + if p.SeqId != seqId { + err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "debugIndexMemorySegments failed: out of sequence response") + return + } + if mTypeId == thrift.EXCEPTION { + error95 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error96 error + error96, err = error95.Read(iprot) + if err != nil { + return + } + if err = iprot.ReadMessageEnd(); err != nil { + return + } + err = error96 + return + } + if mTypeId != thrift.REPLY { + err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "debugIndexMemorySegments failed: invalid message type") + return + } + result := NodeDebugIndexMemorySegmentsResult{} + 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 +} + +type NodeProcessor struct { + processorMap map[string]thrift.TProcessorFunction + handler Node +} + +func (p *NodeProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { + p.processorMap[key] = processor +} + +func (p *NodeProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { + processor, ok = p.processorMap[key] + return processor, ok +} + +func (p *NodeProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { + return p.processorMap +} + +func NewNodeProcessor(handler Node) *NodeProcessor { + + self97 := &NodeProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} + self97.processorMap["query"] = &nodeProcessorQuery{handler: handler} + self97.processorMap["aggregateRaw"] = &nodeProcessorAggregateRaw{handler: handler} + self97.processorMap["aggregate"] = &nodeProcessorAggregate{handler: handler} + self97.processorMap["fetch"] = &nodeProcessorFetch{handler: handler} + self97.processorMap["fetchTagged"] = &nodeProcessorFetchTagged{handler: handler} + self97.processorMap["write"] = &nodeProcessorWrite{handler: handler} + self97.processorMap["writeTagged"] = &nodeProcessorWriteTagged{handler: handler} + self97.processorMap["fetchBatchRaw"] = &nodeProcessorFetchBatchRaw{handler: handler} + self97.processorMap["fetchBatchRawV2"] = &nodeProcessorFetchBatchRawV2{handler: handler} + self97.processorMap["fetchBlocksRaw"] = &nodeProcessorFetchBlocksRaw{handler: handler} + self97.processorMap["fetchBlocksMetadataRawV2"] = &nodeProcessorFetchBlocksMetadataRawV2{handler: handler} + self97.processorMap["writeBatchRaw"] = &nodeProcessorWriteBatchRaw{handler: handler} + self97.processorMap["writeBatchRawV2"] = &nodeProcessorWriteBatchRawV2{handler: handler} + self97.processorMap["writeTaggedBatchRaw"] = &nodeProcessorWriteTaggedBatchRaw{handler: handler} + self97.processorMap["writeTaggedBatchRawV2"] = &nodeProcessorWriteTaggedBatchRawV2{handler: handler} + self97.processorMap["repair"] = &nodeProcessorRepair{handler: handler} + self97.processorMap["truncate"] = &nodeProcessorTruncate{handler: handler} + self97.processorMap["health"] = &nodeProcessorHealth{handler: handler} + self97.processorMap["bootstrapped"] = &nodeProcessorBootstrapped{handler: handler} + self97.processorMap["bootstrappedInPlacementOrNoPlacement"] = &nodeProcessorBootstrappedInPlacementOrNoPlacement{handler: handler} + self97.processorMap["getPersistRateLimit"] = &nodeProcessorGetPersistRateLimit{handler: handler} + self97.processorMap["setPersistRateLimit"] = &nodeProcessorSetPersistRateLimit{handler: handler} + self97.processorMap["getWriteNewSeriesAsync"] = &nodeProcessorGetWriteNewSeriesAsync{handler: handler} + self97.processorMap["setWriteNewSeriesAsync"] = &nodeProcessorSetWriteNewSeriesAsync{handler: handler} + self97.processorMap["getWriteNewSeriesBackoffDuration"] = &nodeProcessorGetWriteNewSeriesBackoffDuration{handler: handler} + self97.processorMap["setWriteNewSeriesBackoffDuration"] = &nodeProcessorSetWriteNewSeriesBackoffDuration{handler: handler} + self97.processorMap["getWriteNewSeriesLimitPerShardPerSecond"] = &nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond{handler: handler} + self97.processorMap["setWriteNewSeriesLimitPerShardPerSecond"] = &nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond{handler: handler} + self97.processorMap["debugProfileStart"] = &nodeProcessorDebugProfileStart{handler: handler} + self97.processorMap["debugProfileStop"] = &nodeProcessorDebugProfileStop{handler: handler} + self97.processorMap["debugIndexMemorySegments"] = &nodeProcessorDebugIndexMemorySegments{handler: handler} + return self97 +} + +func (p *NodeProcessor) 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() + x98 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) + oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) + x98.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, x98 + +} + +type nodeProcessorQuery struct { handler Node } -func (p *nodeProcessorFetchBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchBatchRawArgs{} +func (p *nodeProcessorQuery) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeQueryArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetchBatchRaw", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("query", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -15924,16 +16353,16 @@ func (p *nodeProcessorFetchBatchRaw) Process(seqId int32, iprot, oprot thrift.TP } iprot.ReadMessageEnd() - result := NodeFetchBatchRawResult{} - var retval *FetchBatchRawResult_ + result := NodeQueryResult{} + var retval *QueryResult_ var err2 error - if retval, err2 = p.handler.FetchBatchRaw(args.Req); err2 != nil { + if retval, err2 = p.handler.Query(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBatchRaw: "+err2.Error()) - oprot.WriteMessageBegin("fetchBatchRaw", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query: "+err2.Error()) + oprot.WriteMessageBegin("query", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -15942,7 +16371,7 @@ func (p *nodeProcessorFetchBatchRaw) Process(seqId int32, iprot, oprot thrift.TP } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("fetchBatchRaw", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("query", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -15960,16 +16389,16 @@ func (p *nodeProcessorFetchBatchRaw) Process(seqId int32, iprot, oprot thrift.TP return true, err } -type nodeProcessorFetchBatchRawV2 struct { +type nodeProcessorAggregateRaw struct { handler Node } -func (p *nodeProcessorFetchBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchBatchRawV2Args{} +func (p *nodeProcessorAggregateRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeAggregateRawArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetchBatchRawV2", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("aggregateRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -15977,16 +16406,16 @@ func (p *nodeProcessorFetchBatchRawV2) Process(seqId int32, iprot, oprot thrift. } iprot.ReadMessageEnd() - result := NodeFetchBatchRawV2Result{} - var retval *FetchBatchRawResult_ + result := NodeAggregateRawResult{} + var retval *AggregateQueryRawResult_ var err2 error - if retval, err2 = p.handler.FetchBatchRawV2(args.Req); err2 != nil { + if retval, err2 = p.handler.AggregateRaw(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBatchRawV2: "+err2.Error()) - oprot.WriteMessageBegin("fetchBatchRawV2", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing aggregateRaw: "+err2.Error()) + oprot.WriteMessageBegin("aggregateRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -15995,7 +16424,7 @@ func (p *nodeProcessorFetchBatchRawV2) Process(seqId int32, iprot, oprot thrift. } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("fetchBatchRawV2", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("aggregateRaw", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16013,16 +16442,16 @@ func (p *nodeProcessorFetchBatchRawV2) Process(seqId int32, iprot, oprot thrift. return true, err } -type nodeProcessorFetchBlocksRaw struct { +type nodeProcessorAggregate struct { handler Node } -func (p *nodeProcessorFetchBlocksRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchBlocksRawArgs{} +func (p *nodeProcessorAggregate) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeAggregateArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetchBlocksRaw", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("aggregate", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16030,16 +16459,16 @@ func (p *nodeProcessorFetchBlocksRaw) Process(seqId int32, iprot, oprot thrift.T } iprot.ReadMessageEnd() - result := NodeFetchBlocksRawResult{} - var retval *FetchBlocksRawResult_ + result := NodeAggregateResult{} + var retval *AggregateQueryResult_ var err2 error - if retval, err2 = p.handler.FetchBlocksRaw(args.Req); err2 != nil { + if retval, err2 = p.handler.Aggregate(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBlocksRaw: "+err2.Error()) - oprot.WriteMessageBegin("fetchBlocksRaw", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing aggregate: "+err2.Error()) + oprot.WriteMessageBegin("aggregate", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16048,7 +16477,7 @@ func (p *nodeProcessorFetchBlocksRaw) Process(seqId int32, iprot, oprot thrift.T } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("fetchBlocksRaw", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("aggregate", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16066,16 +16495,16 @@ func (p *nodeProcessorFetchBlocksRaw) Process(seqId int32, iprot, oprot thrift.T return true, err } -type nodeProcessorFetchBlocksMetadataRawV2 struct { +type nodeProcessorFetch struct { handler Node } -func (p *nodeProcessorFetchBlocksMetadataRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeFetchBlocksMetadataRawV2Args{} +func (p *nodeProcessorFetch) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetch", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16083,16 +16512,16 @@ func (p *nodeProcessorFetchBlocksMetadataRawV2) Process(seqId int32, iprot, opro } iprot.ReadMessageEnd() - result := NodeFetchBlocksMetadataRawV2Result{} - var retval *FetchBlocksMetadataRawV2Result_ + result := NodeFetchResult{} + var retval *FetchResult_ var err2 error - if retval, err2 = p.handler.FetchBlocksMetadataRawV2(args.Req); err2 != nil { + if retval, err2 = p.handler.Fetch(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBlocksMetadataRawV2: "+err2.Error()) - oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetch: "+err2.Error()) + oprot.WriteMessageBegin("fetch", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16101,7 +16530,7 @@ func (p *nodeProcessorFetchBlocksMetadataRawV2) Process(seqId int32, iprot, opro } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetch", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16119,16 +16548,16 @@ func (p *nodeProcessorFetchBlocksMetadataRawV2) Process(seqId int32, iprot, opro return true, err } -type nodeProcessorWriteBatchRaw struct { +type nodeProcessorFetchTagged struct { handler Node } -func (p *nodeProcessorWriteBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteBatchRawArgs{} +func (p *nodeProcessorFetchTagged) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchTaggedArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("writeBatchRaw", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetchTagged", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16136,22 +16565,25 @@ func (p *nodeProcessorWriteBatchRaw) Process(seqId int32, iprot, oprot thrift.TP } iprot.ReadMessageEnd() - result := NodeWriteBatchRawResult{} + result := NodeFetchTaggedResult{} + var retval *FetchTaggedResult_ var err2 error - if err2 = p.handler.WriteBatchRaw(args.Req); err2 != nil { + if retval, err2 = p.handler.FetchTagged(args.Req); err2 != nil { switch v := err2.(type) { - case *WriteBatchRawErrors: + case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeBatchRaw: "+err2.Error()) - oprot.WriteMessageBegin("writeBatchRaw", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchTagged: "+err2.Error()) + oprot.WriteMessageBegin("fetchTagged", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } + } else { + result.Success = retval } - if err2 = oprot.WriteMessageBegin("writeBatchRaw", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetchTagged", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16169,16 +16601,16 @@ func (p *nodeProcessorWriteBatchRaw) Process(seqId int32, iprot, oprot thrift.TP return true, err } -type nodeProcessorWriteBatchRawV2 struct { +type nodeProcessorWrite struct { handler Node } -func (p *nodeProcessorWriteBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteBatchRawV2Args{} +func (p *nodeProcessorWrite) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("writeBatchRawV2", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("write", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16186,22 +16618,22 @@ func (p *nodeProcessorWriteBatchRawV2) Process(seqId int32, iprot, oprot thrift. } iprot.ReadMessageEnd() - result := NodeWriteBatchRawV2Result{} + result := NodeWriteResult{} var err2 error - if err2 = p.handler.WriteBatchRawV2(args.Req); err2 != nil { + if err2 = p.handler.Write(args.Req); err2 != nil { switch v := err2.(type) { - case *WriteBatchRawErrors: + case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeBatchRawV2: "+err2.Error()) - oprot.WriteMessageBegin("writeBatchRawV2", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing write: "+err2.Error()) + oprot.WriteMessageBegin("write", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } } - if err2 = oprot.WriteMessageBegin("writeBatchRawV2", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("write", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16219,16 +16651,16 @@ func (p *nodeProcessorWriteBatchRawV2) Process(seqId int32, iprot, oprot thrift. return true, err } -type nodeProcessorWriteTaggedBatchRaw struct { +type nodeProcessorWriteTagged struct { handler Node } -func (p *nodeProcessorWriteTaggedBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteTaggedBatchRawArgs{} +func (p *nodeProcessorWriteTagged) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteTaggedArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("writeTagged", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16236,22 +16668,22 @@ func (p *nodeProcessorWriteTaggedBatchRaw) Process(seqId int32, iprot, oprot thr } iprot.ReadMessageEnd() - result := NodeWriteTaggedBatchRawResult{} + result := NodeWriteTaggedResult{} var err2 error - if err2 = p.handler.WriteTaggedBatchRaw(args.Req); err2 != nil { + if err2 = p.handler.WriteTagged(args.Req); err2 != nil { switch v := err2.(type) { - case *WriteBatchRawErrors: + case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTaggedBatchRaw: "+err2.Error()) - oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTagged: "+err2.Error()) + oprot.WriteMessageBegin("writeTagged", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } } - if err2 = oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("writeTagged", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16269,16 +16701,16 @@ func (p *nodeProcessorWriteTaggedBatchRaw) Process(seqId int32, iprot, oprot thr return true, err } -type nodeProcessorWriteTaggedBatchRawV2 struct { +type nodeProcessorFetchBatchRaw struct { handler Node } -func (p *nodeProcessorWriteTaggedBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeWriteTaggedBatchRawV2Args{} +func (p *nodeProcessorFetchBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchBatchRawArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetchBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16286,22 +16718,25 @@ func (p *nodeProcessorWriteTaggedBatchRawV2) Process(seqId int32, iprot, oprot t } iprot.ReadMessageEnd() - result := NodeWriteTaggedBatchRawV2Result{} + result := NodeFetchBatchRawResult{} + var retval *FetchBatchRawResult_ var err2 error - if err2 = p.handler.WriteTaggedBatchRawV2(args.Req); err2 != nil { + if retval, err2 = p.handler.FetchBatchRaw(args.Req); err2 != nil { switch v := err2.(type) { - case *WriteBatchRawErrors: + case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTaggedBatchRawV2: "+err2.Error()) - oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBatchRaw: "+err2.Error()) + oprot.WriteMessageBegin("fetchBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } + } else { + result.Success = retval } - if err2 = oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetchBatchRaw", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16319,16 +16754,16 @@ func (p *nodeProcessorWriteTaggedBatchRawV2) Process(seqId int32, iprot, oprot t return true, err } -type nodeProcessorRepair struct { +type nodeProcessorFetchBatchRawV2 struct { handler Node } -func (p *nodeProcessorRepair) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeRepairArgs{} +func (p *nodeProcessorFetchBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchBatchRawV2Args{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("repair", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetchBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16336,22 +16771,25 @@ func (p *nodeProcessorRepair) Process(seqId int32, iprot, oprot thrift.TProtocol } iprot.ReadMessageEnd() - result := NodeRepairResult{} + result := NodeFetchBatchRawV2Result{} + var retval *FetchBatchRawResult_ var err2 error - if err2 = p.handler.Repair(); err2 != nil { + if retval, err2 = p.handler.FetchBatchRawV2(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing repair: "+err2.Error()) - oprot.WriteMessageBegin("repair", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBatchRawV2: "+err2.Error()) + oprot.WriteMessageBegin("fetchBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } + } else { + result.Success = retval } - if err2 = oprot.WriteMessageBegin("repair", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetchBatchRawV2", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16369,16 +16807,16 @@ func (p *nodeProcessorRepair) Process(seqId int32, iprot, oprot thrift.TProtocol return true, err } -type nodeProcessorTruncate struct { +type nodeProcessorFetchBlocksRaw struct { handler Node } -func (p *nodeProcessorTruncate) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeTruncateArgs{} +func (p *nodeProcessorFetchBlocksRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchBlocksRawArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("truncate", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetchBlocksRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16386,16 +16824,16 @@ func (p *nodeProcessorTruncate) Process(seqId int32, iprot, oprot thrift.TProtoc } iprot.ReadMessageEnd() - result := NodeTruncateResult{} - var retval *TruncateResult_ + result := NodeFetchBlocksRawResult{} + var retval *FetchBlocksRawResult_ var err2 error - if retval, err2 = p.handler.Truncate(args.Req); err2 != nil { + if retval, err2 = p.handler.FetchBlocksRaw(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing truncate: "+err2.Error()) - oprot.WriteMessageBegin("truncate", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBlocksRaw: "+err2.Error()) + oprot.WriteMessageBegin("fetchBlocksRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16404,7 +16842,7 @@ func (p *nodeProcessorTruncate) Process(seqId int32, iprot, oprot thrift.TProtoc } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("truncate", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetchBlocksRaw", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16422,16 +16860,16 @@ func (p *nodeProcessorTruncate) Process(seqId int32, iprot, oprot thrift.TProtoc return true, err } -type nodeProcessorHealth struct { +type nodeProcessorFetchBlocksMetadataRawV2 struct { handler Node } -func (p *nodeProcessorHealth) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeHealthArgs{} +func (p *nodeProcessorFetchBlocksMetadataRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeFetchBlocksMetadataRawV2Args{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("health", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16439,16 +16877,16 @@ func (p *nodeProcessorHealth) Process(seqId int32, iprot, oprot thrift.TProtocol } iprot.ReadMessageEnd() - result := NodeHealthResult{} - var retval *NodeHealthResult_ + result := NodeFetchBlocksMetadataRawV2Result{} + var retval *FetchBlocksMetadataRawV2Result_ var err2 error - if retval, err2 = p.handler.Health(); err2 != nil { + if retval, err2 = p.handler.FetchBlocksMetadataRawV2(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing health: "+err2.Error()) - oprot.WriteMessageBegin("health", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing fetchBlocksMetadataRawV2: "+err2.Error()) + oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16457,7 +16895,7 @@ func (p *nodeProcessorHealth) Process(seqId int32, iprot, oprot thrift.TProtocol } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("health", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("fetchBlocksMetadataRawV2", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16475,16 +16913,16 @@ func (p *nodeProcessorHealth) Process(seqId int32, iprot, oprot thrift.TProtocol return true, err } -type nodeProcessorBootstrapped struct { +type nodeProcessorWriteBatchRaw struct { handler Node } -func (p *nodeProcessorBootstrapped) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeBootstrappedArgs{} +func (p *nodeProcessorWriteBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteBatchRawArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("bootstrapped", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("writeBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16492,25 +16930,22 @@ func (p *nodeProcessorBootstrapped) Process(seqId int32, iprot, oprot thrift.TPr } iprot.ReadMessageEnd() - result := NodeBootstrappedResult{} - var retval *NodeBootstrappedResult_ + result := NodeWriteBatchRawResult{} var err2 error - if retval, err2 = p.handler.Bootstrapped(); err2 != nil { + if err2 = p.handler.WriteBatchRaw(args.Req); err2 != nil { switch v := err2.(type) { - case *Error: + case *WriteBatchRawErrors: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing bootstrapped: "+err2.Error()) - oprot.WriteMessageBegin("bootstrapped", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeBatchRaw: "+err2.Error()) + oprot.WriteMessageBegin("writeBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } - } else { - result.Success = retval } - if err2 = oprot.WriteMessageBegin("bootstrapped", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("writeBatchRaw", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16528,16 +16963,16 @@ func (p *nodeProcessorBootstrapped) Process(seqId int32, iprot, oprot thrift.TPr return true, err } -type nodeProcessorBootstrappedInPlacementOrNoPlacement struct { +type nodeProcessorWriteBatchRawV2 struct { handler Node } -func (p *nodeProcessorBootstrappedInPlacementOrNoPlacement) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeBootstrappedInPlacementOrNoPlacementArgs{} +func (p *nodeProcessorWriteBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteBatchRawV2Args{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("writeBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16545,25 +16980,22 @@ func (p *nodeProcessorBootstrappedInPlacementOrNoPlacement) Process(seqId int32, } iprot.ReadMessageEnd() - result := NodeBootstrappedInPlacementOrNoPlacementResult{} - var retval *NodeBootstrappedInPlacementOrNoPlacementResult_ + result := NodeWriteBatchRawV2Result{} var err2 error - if retval, err2 = p.handler.BootstrappedInPlacementOrNoPlacement(); err2 != nil { + if err2 = p.handler.WriteBatchRawV2(args.Req); err2 != nil { switch v := err2.(type) { - case *Error: + case *WriteBatchRawErrors: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing bootstrappedInPlacementOrNoPlacement: "+err2.Error()) - oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeBatchRawV2: "+err2.Error()) + oprot.WriteMessageBegin("writeBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } - } else { - result.Success = retval } - if err2 = oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("writeBatchRawV2", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16581,16 +17013,16 @@ func (p *nodeProcessorBootstrappedInPlacementOrNoPlacement) Process(seqId int32, return true, err } -type nodeProcessorGetPersistRateLimit struct { +type nodeProcessorWriteTaggedBatchRaw struct { handler Node } -func (p *nodeProcessorGetPersistRateLimit) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeGetPersistRateLimitArgs{} +func (p *nodeProcessorWriteTaggedBatchRaw) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteTaggedBatchRawArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("getPersistRateLimit", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16598,25 +17030,22 @@ func (p *nodeProcessorGetPersistRateLimit) Process(seqId int32, iprot, oprot thr } iprot.ReadMessageEnd() - result := NodeGetPersistRateLimitResult{} - var retval *NodePersistRateLimitResult_ + result := NodeWriteTaggedBatchRawResult{} var err2 error - if retval, err2 = p.handler.GetPersistRateLimit(); err2 != nil { + if err2 = p.handler.WriteTaggedBatchRaw(args.Req); err2 != nil { switch v := err2.(type) { - case *Error: + case *WriteBatchRawErrors: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getPersistRateLimit: "+err2.Error()) - oprot.WriteMessageBegin("getPersistRateLimit", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTaggedBatchRaw: "+err2.Error()) + oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } - } else { - result.Success = retval } - if err2 = oprot.WriteMessageBegin("getPersistRateLimit", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("writeTaggedBatchRaw", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16634,16 +17063,16 @@ func (p *nodeProcessorGetPersistRateLimit) Process(seqId int32, iprot, oprot thr return true, err } -type nodeProcessorSetPersistRateLimit struct { +type nodeProcessorWriteTaggedBatchRawV2 struct { handler Node } -func (p *nodeProcessorSetPersistRateLimit) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeSetPersistRateLimitArgs{} +func (p *nodeProcessorWriteTaggedBatchRawV2) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeWriteTaggedBatchRawV2Args{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("setPersistRateLimit", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16651,25 +17080,22 @@ func (p *nodeProcessorSetPersistRateLimit) Process(seqId int32, iprot, oprot thr } iprot.ReadMessageEnd() - result := NodeSetPersistRateLimitResult{} - var retval *NodePersistRateLimitResult_ + result := NodeWriteTaggedBatchRawV2Result{} var err2 error - if retval, err2 = p.handler.SetPersistRateLimit(args.Req); err2 != nil { + if err2 = p.handler.WriteTaggedBatchRawV2(args.Req); err2 != nil { switch v := err2.(type) { - case *Error: + case *WriteBatchRawErrors: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setPersistRateLimit: "+err2.Error()) - oprot.WriteMessageBegin("setPersistRateLimit", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing writeTaggedBatchRawV2: "+err2.Error()) + oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } - } else { - result.Success = retval } - if err2 = oprot.WriteMessageBegin("setPersistRateLimit", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("writeTaggedBatchRawV2", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16687,16 +17113,16 @@ func (p *nodeProcessorSetPersistRateLimit) Process(seqId int32, iprot, oprot thr return true, err } -type nodeProcessorGetWriteNewSeriesAsync struct { +type nodeProcessorRepair struct { handler Node } -func (p *nodeProcessorGetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeGetWriteNewSeriesAsyncArgs{} +func (p *nodeProcessorRepair) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeRepairArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("repair", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16704,25 +17130,22 @@ func (p *nodeProcessorGetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot } iprot.ReadMessageEnd() - result := NodeGetWriteNewSeriesAsyncResult{} - var retval *NodeWriteNewSeriesAsyncResult_ + result := NodeRepairResult{} var err2 error - if retval, err2 = p.handler.GetWriteNewSeriesAsync(); err2 != nil { + if err2 = p.handler.Repair(); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesAsync: "+err2.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing repair: "+err2.Error()) + oprot.WriteMessageBegin("repair", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() return true, err2 } - } else { - result.Success = retval } - if err2 = oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("repair", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16740,16 +17163,16 @@ func (p *nodeProcessorGetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot return true, err } -type nodeProcessorSetWriteNewSeriesAsync struct { +type nodeProcessorTruncate struct { handler Node } -func (p *nodeProcessorSetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeSetWriteNewSeriesAsyncArgs{} +func (p *nodeProcessorTruncate) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeTruncateArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("truncate", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16757,16 +17180,16 @@ func (p *nodeProcessorSetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot } iprot.ReadMessageEnd() - result := NodeSetWriteNewSeriesAsyncResult{} - var retval *NodeWriteNewSeriesAsyncResult_ + result := NodeTruncateResult{} + var retval *TruncateResult_ var err2 error - if retval, err2 = p.handler.SetWriteNewSeriesAsync(args.Req); err2 != nil { + if retval, err2 = p.handler.Truncate(args.Req); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesAsync: "+err2.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing truncate: "+err2.Error()) + oprot.WriteMessageBegin("truncate", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16775,7 +17198,7 @@ func (p *nodeProcessorSetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("truncate", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16793,16 +17216,16 @@ func (p *nodeProcessorSetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot return true, err } -type nodeProcessorGetWriteNewSeriesBackoffDuration struct { +type nodeProcessorHealth struct { handler Node } -func (p *nodeProcessorGetWriteNewSeriesBackoffDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeGetWriteNewSeriesBackoffDurationArgs{} +func (p *nodeProcessorHealth) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeHealthArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("health", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16810,16 +17233,16 @@ func (p *nodeProcessorGetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr } iprot.ReadMessageEnd() - result := NodeGetWriteNewSeriesBackoffDurationResult{} - var retval *NodeWriteNewSeriesBackoffDurationResult_ + result := NodeHealthResult{} + var retval *NodeHealthResult_ var err2 error - if retval, err2 = p.handler.GetWriteNewSeriesBackoffDuration(); err2 != nil { + if retval, err2 = p.handler.Health(); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesBackoffDuration: "+err2.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing health: "+err2.Error()) + oprot.WriteMessageBegin("health", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16828,7 +17251,7 @@ func (p *nodeProcessorGetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("health", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16846,16 +17269,16 @@ func (p *nodeProcessorGetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr return true, err } -type nodeProcessorSetWriteNewSeriesBackoffDuration struct { +type nodeProcessorBootstrapped struct { handler Node } -func (p *nodeProcessorSetWriteNewSeriesBackoffDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeSetWriteNewSeriesBackoffDurationArgs{} +func (p *nodeProcessorBootstrapped) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeBootstrappedArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("bootstrapped", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16863,16 +17286,16 @@ func (p *nodeProcessorSetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr } iprot.ReadMessageEnd() - result := NodeSetWriteNewSeriesBackoffDurationResult{} - var retval *NodeWriteNewSeriesBackoffDurationResult_ + result := NodeBootstrappedResult{} + var retval *NodeBootstrappedResult_ var err2 error - if retval, err2 = p.handler.SetWriteNewSeriesBackoffDuration(args.Req); err2 != nil { + if retval, err2 = p.handler.Bootstrapped(); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesBackoffDuration: "+err2.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing bootstrapped: "+err2.Error()) + oprot.WriteMessageBegin("bootstrapped", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16881,7 +17304,7 @@ func (p *nodeProcessorSetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("bootstrapped", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16899,16 +17322,16 @@ func (p *nodeProcessorSetWriteNewSeriesBackoffDuration) Process(seqId int32, ipr return true, err } -type nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond struct { +type nodeProcessorBootstrappedInPlacementOrNoPlacement struct { handler Node } -func (p *nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} +func (p *nodeProcessorBootstrappedInPlacementOrNoPlacement) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeBootstrappedInPlacementOrNoPlacementArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16916,16 +17339,16 @@ func (p *nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int } iprot.ReadMessageEnd() - result := NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} - var retval *NodeWriteNewSeriesLimitPerShardPerSecondResult_ + result := NodeBootstrappedInPlacementOrNoPlacementResult{} + var retval *NodeBootstrappedInPlacementOrNoPlacementResult_ var err2 error - if retval, err2 = p.handler.GetWriteNewSeriesLimitPerShardPerSecond(); err2 != nil { + if retval, err2 = p.handler.BootstrappedInPlacementOrNoPlacement(); err2 != nil { switch v := err2.(type) { case *Error: result.Err = v default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesLimitPerShardPerSecond: "+err2.Error()) - oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing bootstrappedInPlacementOrNoPlacement: "+err2.Error()) + oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() @@ -16934,7 +17357,166 @@ func (p *nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("bootstrappedInPlacementOrNoPlacement", 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 nodeProcessorGetPersistRateLimit struct { + handler Node +} + +func (p *nodeProcessorGetPersistRateLimit) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeGetPersistRateLimitArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getPersistRateLimit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeGetPersistRateLimitResult{} + var retval *NodePersistRateLimitResult_ + var err2 error + if retval, err2 = p.handler.GetPersistRateLimit(); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getPersistRateLimit: "+err2.Error()) + oprot.WriteMessageBegin("getPersistRateLimit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getPersistRateLimit", 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 nodeProcessorSetPersistRateLimit struct { + handler Node +} + +func (p *nodeProcessorSetPersistRateLimit) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeSetPersistRateLimitArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("setPersistRateLimit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeSetPersistRateLimitResult{} + var retval *NodePersistRateLimitResult_ + var err2 error + if retval, err2 = p.handler.SetPersistRateLimit(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setPersistRateLimit: "+err2.Error()) + oprot.WriteMessageBegin("setPersistRateLimit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("setPersistRateLimit", 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 nodeProcessorGetWriteNewSeriesAsync struct { + handler Node +} + +func (p *nodeProcessorGetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeGetWriteNewSeriesAsyncArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeGetWriteNewSeriesAsyncResult{} + var retval *NodeWriteNewSeriesAsyncResult_ + var err2 error + if retval, err2 = p.handler.GetWriteNewSeriesAsync(); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesAsync: "+err2.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getWriteNewSeriesAsync", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -16952,137 +17534,965 @@ func (p *nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int return true, err } -type nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond struct { - handler Node +type nodeProcessorSetWriteNewSeriesAsync struct { + handler Node +} + +func (p *nodeProcessorSetWriteNewSeriesAsync) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeSetWriteNewSeriesAsyncArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeSetWriteNewSeriesAsyncResult{} + var retval *NodeWriteNewSeriesAsyncResult_ + var err2 error + if retval, err2 = p.handler.SetWriteNewSeriesAsync(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesAsync: "+err2.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesAsync", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("setWriteNewSeriesAsync", 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 nodeProcessorGetWriteNewSeriesBackoffDuration struct { + handler Node +} + +func (p *nodeProcessorGetWriteNewSeriesBackoffDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeGetWriteNewSeriesBackoffDurationArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeGetWriteNewSeriesBackoffDurationResult{} + var retval *NodeWriteNewSeriesBackoffDurationResult_ + var err2 error + if retval, err2 = p.handler.GetWriteNewSeriesBackoffDuration(); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesBackoffDuration: "+err2.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getWriteNewSeriesBackoffDuration", 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 nodeProcessorSetWriteNewSeriesBackoffDuration struct { + handler Node +} + +func (p *nodeProcessorSetWriteNewSeriesBackoffDuration) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeSetWriteNewSeriesBackoffDurationArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeSetWriteNewSeriesBackoffDurationResult{} + var retval *NodeWriteNewSeriesBackoffDurationResult_ + var err2 error + if retval, err2 = p.handler.SetWriteNewSeriesBackoffDuration(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesBackoffDuration: "+err2.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("setWriteNewSeriesBackoffDuration", 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 nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond struct { + handler Node +} + +func (p *nodeProcessorGetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} + var retval *NodeWriteNewSeriesLimitPerShardPerSecondResult_ + var err2 error + if retval, err2 = p.handler.GetWriteNewSeriesLimitPerShardPerSecond(); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getWriteNewSeriesLimitPerShardPerSecond: "+err2.Error()) + oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getWriteNewSeriesLimitPerShardPerSecond", 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 nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond struct { + handler Node +} + +func (p *nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} + var retval *NodeWriteNewSeriesLimitPerShardPerSecondResult_ + var err2 error + if retval, err2 = p.handler.SetWriteNewSeriesLimitPerShardPerSecond(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesLimitPerShardPerSecond: "+err2.Error()) + oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", 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 nodeProcessorDebugProfileStart struct { + handler Node +} + +func (p *nodeProcessorDebugProfileStart) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeDebugProfileStartArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("debugProfileStart", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeDebugProfileStartResult{} + var retval *DebugProfileStartResult_ + var err2 error + if retval, err2 = p.handler.DebugProfileStart(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing debugProfileStart: "+err2.Error()) + oprot.WriteMessageBegin("debugProfileStart", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("debugProfileStart", 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 nodeProcessorDebugProfileStop struct { + handler Node +} + +func (p *nodeProcessorDebugProfileStop) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeDebugProfileStopArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("debugProfileStop", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeDebugProfileStopResult{} + var retval *DebugProfileStopResult_ + var err2 error + if retval, err2 = p.handler.DebugProfileStop(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing debugProfileStop: "+err2.Error()) + oprot.WriteMessageBegin("debugProfileStop", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("debugProfileStop", 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 nodeProcessorDebugIndexMemorySegments struct { + handler Node +} + +func (p *nodeProcessorDebugIndexMemorySegments) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := NodeDebugIndexMemorySegmentsArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return false, err + } + + iprot.ReadMessageEnd() + result := NodeDebugIndexMemorySegmentsResult{} + var retval *DebugIndexMemorySegmentsResult_ + var err2 error + if retval, err2 = p.handler.DebugIndexMemorySegments(args.Req); err2 != nil { + switch v := err2.(type) { + case *Error: + result.Err = v + default: + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing debugIndexMemorySegments: "+err2.Error()) + oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush() + return true, err2 + } + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("debugIndexMemorySegments", 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: +// - Req +type NodeQueryArgs struct { + Req *QueryRequest `thrift:"req,1" db:"req" json:"req"` +} + +func NewNodeQueryArgs() *NodeQueryArgs { + return &NodeQueryArgs{} +} + +var NodeQueryArgs_Req_DEFAULT *QueryRequest + +func (p *NodeQueryArgs) GetReq() *QueryRequest { + if !p.IsSetReq() { + return NodeQueryArgs_Req_DEFAULT + } + return p.Req +} +func (p *NodeQueryArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *NodeQueryArgs) 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 *NodeQueryArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &QueryRequest{ + RangeType: 0, + + ResultTimeType: 0, + } + if err := p.Req.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) + } + return nil +} + +func (p *NodeQueryArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("query_args"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) + } + if p != nil { + 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 *NodeQueryArgs) 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 *NodeQueryArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("NodeQueryArgs(%+v)", *p) +} + +// Attributes: +// - Success +// - Err +type NodeQueryResult struct { + Success *QueryResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +} + +func NewNodeQueryResult() *NodeQueryResult { + return &NodeQueryResult{} +} + +var NodeQueryResult_Success_DEFAULT *QueryResult_ + +func (p *NodeQueryResult) GetSuccess() *QueryResult_ { + if !p.IsSetSuccess() { + return NodeQueryResult_Success_DEFAULT + } + return p.Success +} + +var NodeQueryResult_Err_DEFAULT *Error + +func (p *NodeQueryResult) GetErr() *Error { + if !p.IsSetErr() { + return NodeQueryResult_Err_DEFAULT + } + return p.Err +} +func (p *NodeQueryResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeQueryResult) IsSetErr() bool { + return p.Err != nil +} + +func (p *NodeQueryResult) 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 *NodeQueryResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &QueryResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil +} + +func (p *NodeQueryResult) ReadField1(iprot thrift.TProtocol) error { + p.Err = &Error{ + Type: 0, + } + if err := p.Err.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) + } + return nil +} + +func (p *NodeQueryResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("query_result"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) + } + if p != nil { + 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 *NodeQueryResult) 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 *NodeQueryResult) 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 *NodeQueryResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("NodeQueryResult(%+v)", *p) +} + +// Attributes: +// - Req +type NodeAggregateRawArgs struct { + Req *AggregateQueryRawRequest `thrift:"req,1" db:"req" json:"req"` +} + +func NewNodeAggregateRawArgs() *NodeAggregateRawArgs { + return &NodeAggregateRawArgs{} +} + +var NodeAggregateRawArgs_Req_DEFAULT *AggregateQueryRawRequest + +func (p *NodeAggregateRawArgs) GetReq() *AggregateQueryRawRequest { + if !p.IsSetReq() { + return NodeAggregateRawArgs_Req_DEFAULT + } + return p.Req +} +func (p *NodeAggregateRawArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *NodeAggregateRawArgs) 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 *NodeAggregateRawArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &AggregateQueryRawRequest{ + AggregateQueryType: 1, + + RangeType: 0, + } + if err := p.Req.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) + } + return nil +} + +func (p *NodeAggregateRawArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("aggregateRaw_args"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) + } + if p != nil { + 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 *NodeAggregateRawArgs) 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 *NodeAggregateRawArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("NodeAggregateRawArgs(%+v)", *p) +} + +// Attributes: +// - Success +// - Err +type NodeAggregateRawResult struct { + Success *AggregateQueryRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +} + +func NewNodeAggregateRawResult() *NodeAggregateRawResult { + return &NodeAggregateRawResult{} +} + +var NodeAggregateRawResult_Success_DEFAULT *AggregateQueryRawResult_ + +func (p *NodeAggregateRawResult) GetSuccess() *AggregateQueryRawResult_ { + if !p.IsSetSuccess() { + return NodeAggregateRawResult_Success_DEFAULT + } + return p.Success +} + +var NodeAggregateRawResult_Err_DEFAULT *Error + +func (p *NodeAggregateRawResult) GetErr() *Error { + if !p.IsSetErr() { + return NodeAggregateRawResult_Err_DEFAULT + } + return p.Err +} +func (p *NodeAggregateRawResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeAggregateRawResult) IsSetErr() bool { + return p.Err != nil } -func (p *nodeProcessorSetWriteNewSeriesLimitPerShardPerSecond) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeAggregateRawResult) Read(iprot thrift.TProtocol) error { + if _, err := iprot.ReadStructBegin(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } - iprot.ReadMessageEnd() - result := NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} - var retval *NodeWriteNewSeriesLimitPerShardPerSecondResult_ - var err2 error - if retval, err2 = p.handler.SetWriteNewSeriesLimitPerShardPerSecond(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v + 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: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing setWriteNewSeriesLimitPerShardPerSecond: "+err2.Error()) - oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 + if err := iprot.Skip(fieldTypeId); err != nil { + return err + } + } + if err := iprot.ReadFieldEnd(); err != nil { + return err } - } else { - result.Success = retval - } - if err2 = oprot.WriteMessageBegin("setWriteNewSeriesLimitPerShardPerSecond", 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 + if err := iprot.ReadStructEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - return true, err + return nil } -type nodeProcessorDebugIndexMemorySegments struct { - handler Node +func (p *NodeAggregateRawResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &AggregateQueryRawResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil } -func (p *nodeProcessorDebugIndexMemorySegments) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := NodeDebugIndexMemorySegmentsArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return false, err +func (p *NodeAggregateRawResult) ReadField1(iprot thrift.TProtocol) error { + p.Err = &Error{ + Type: 0, } + if err := p.Err.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) + } + return nil +} - iprot.ReadMessageEnd() - result := NodeDebugIndexMemorySegmentsResult{} - var retval *DebugIndexMemorySegmentsResult_ - var err2 error - if retval, err2 = p.handler.DebugIndexMemorySegments(args.Req); err2 != nil { - switch v := err2.(type) { - case *Error: - result.Err = v - default: - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing debugIndexMemorySegments: "+err2.Error()) - oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush() - return true, err2 - } - } else { - result.Success = retval +func (p *NodeAggregateRawResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("aggregateRaw_result"); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } - if err2 = oprot.WriteMessageBegin("debugIndexMemorySegments", thrift.REPLY, seqId); err2 != nil { - err = err2 + if p != nil { + if err := p.writeField0(oprot); err != nil { + return err + } + if err := p.writeField1(oprot); err != nil { + return err + } } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 + if err := oprot.WriteFieldStop(); err != nil { + return thrift.PrependError("write field stop error: ", err) } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if err := oprot.WriteStructEnd(); err != nil { + return thrift.PrependError("write struct stop error: ", err) } - if err2 = oprot.Flush(); err == nil && err2 != nil { - err = err2 + return nil +} + +func (p *NodeAggregateRawResult) 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) + } } - if err != nil { - return + return err +} + +func (p *NodeAggregateRawResult) 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 true, err + return err } -// HELPER FUNCTIONS AND STRUCTURES +func (p *NodeAggregateRawResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("NodeAggregateRawResult(%+v)", *p) +} // Attributes: // - Req -type NodeQueryArgs struct { - Req *QueryRequest `thrift:"req,1" db:"req" json:"req"` +type NodeAggregateArgs struct { + Req *AggregateQueryRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeQueryArgs() *NodeQueryArgs { - return &NodeQueryArgs{} +func NewNodeAggregateArgs() *NodeAggregateArgs { + return &NodeAggregateArgs{} } -var NodeQueryArgs_Req_DEFAULT *QueryRequest +var NodeAggregateArgs_Req_DEFAULT *AggregateQueryRequest -func (p *NodeQueryArgs) GetReq() *QueryRequest { +func (p *NodeAggregateArgs) GetReq() *AggregateQueryRequest { if !p.IsSetReq() { - return NodeQueryArgs_Req_DEFAULT + return NodeAggregateArgs_Req_DEFAULT } return p.Req } -func (p *NodeQueryArgs) IsSetReq() bool { +func (p *NodeAggregateArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeQueryArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeAggregateArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17115,11 +18525,11 @@ func (p *NodeQueryArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeQueryArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &QueryRequest{ - RangeType: 0, +func (p *NodeAggregateArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &AggregateQueryRequest{ + AggregateQueryType: 1, - ResultTimeType: 0, + RangeType: 0, } if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) @@ -17127,8 +18537,8 @@ func (p *NodeQueryArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeQueryArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("query_args"); err != nil { +func (p *NodeAggregateArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("aggregate_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17145,7 +18555,7 @@ func (p *NodeQueryArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeQueryArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeAggregateArgs) 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) } @@ -17158,51 +18568,51 @@ func (p *NodeQueryArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeQueryArgs) String() string { +func (p *NodeAggregateArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeQueryArgs(%+v)", *p) + return fmt.Sprintf("NodeAggregateArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeQueryResult struct { - Success *QueryResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeAggregateResult struct { + Success *AggregateQueryResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeQueryResult() *NodeQueryResult { - return &NodeQueryResult{} +func NewNodeAggregateResult() *NodeAggregateResult { + return &NodeAggregateResult{} } -var NodeQueryResult_Success_DEFAULT *QueryResult_ +var NodeAggregateResult_Success_DEFAULT *AggregateQueryResult_ -func (p *NodeQueryResult) GetSuccess() *QueryResult_ { +func (p *NodeAggregateResult) GetSuccess() *AggregateQueryResult_ { if !p.IsSetSuccess() { - return NodeQueryResult_Success_DEFAULT + return NodeAggregateResult_Success_DEFAULT } return p.Success } -var NodeQueryResult_Err_DEFAULT *Error +var NodeAggregateResult_Err_DEFAULT *Error -func (p *NodeQueryResult) GetErr() *Error { +func (p *NodeAggregateResult) GetErr() *Error { if !p.IsSetErr() { - return NodeQueryResult_Err_DEFAULT + return NodeAggregateResult_Err_DEFAULT } return p.Err } -func (p *NodeQueryResult) IsSetSuccess() bool { +func (p *NodeAggregateResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeQueryResult) IsSetErr() bool { +func (p *NodeAggregateResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeQueryResult) Read(iprot thrift.TProtocol) error { +func (p *NodeAggregateResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17239,15 +18649,15 @@ func (p *NodeQueryResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeQueryResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &QueryResult_{} +func (p *NodeAggregateResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &AggregateQueryResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeQueryResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeAggregateResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -17257,8 +18667,8 @@ func (p *NodeQueryResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeQueryResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("query_result"); err != nil { +func (p *NodeAggregateResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("aggregate_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17278,7 +18688,7 @@ func (p *NodeQueryResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeQueryResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeAggregateResult) 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) @@ -17293,7 +18703,7 @@ func (p *NodeQueryResult) writeField0(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeQueryResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeAggregateResult) 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) @@ -17308,36 +18718,36 @@ func (p *NodeQueryResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeQueryResult) String() string { +func (p *NodeAggregateResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeQueryResult(%+v)", *p) + return fmt.Sprintf("NodeAggregateResult(%+v)", *p) } // Attributes: // - Req -type NodeAggregateRawArgs struct { - Req *AggregateQueryRawRequest `thrift:"req,1" db:"req" json:"req"` +type NodeFetchArgs struct { + Req *FetchRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeAggregateRawArgs() *NodeAggregateRawArgs { - return &NodeAggregateRawArgs{} +func NewNodeFetchArgs() *NodeFetchArgs { + return &NodeFetchArgs{} } -var NodeAggregateRawArgs_Req_DEFAULT *AggregateQueryRawRequest +var NodeFetchArgs_Req_DEFAULT *FetchRequest -func (p *NodeAggregateRawArgs) GetReq() *AggregateQueryRawRequest { +func (p *NodeFetchArgs) GetReq() *FetchRequest { if !p.IsSetReq() { - return NodeAggregateRawArgs_Req_DEFAULT + return NodeFetchArgs_Req_DEFAULT } return p.Req } -func (p *NodeAggregateRawArgs) IsSetReq() bool { +func (p *NodeFetchArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeAggregateRawArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17370,11 +18780,11 @@ func (p *NodeAggregateRawArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &AggregateQueryRawRequest{ - AggregateQueryType: 1, - +func (p *NodeFetchArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchRequest{ RangeType: 0, + + ResultTimeType: 0, } if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) @@ -17382,8 +18792,8 @@ func (p *NodeAggregateRawArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("aggregateRaw_args"); err != nil { +func (p *NodeFetchArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetch_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17400,7 +18810,7 @@ func (p *NodeAggregateRawArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchArgs) 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) } @@ -17413,51 +18823,51 @@ func (p *NodeAggregateRawArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeAggregateRawArgs) String() string { +func (p *NodeFetchArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeAggregateRawArgs(%+v)", *p) + return fmt.Sprintf("NodeFetchArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeAggregateRawResult struct { - Success *AggregateQueryRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchResult struct { + Success *FetchResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeAggregateRawResult() *NodeAggregateRawResult { - return &NodeAggregateRawResult{} +func NewNodeFetchResult() *NodeFetchResult { + return &NodeFetchResult{} } -var NodeAggregateRawResult_Success_DEFAULT *AggregateQueryRawResult_ +var NodeFetchResult_Success_DEFAULT *FetchResult_ -func (p *NodeAggregateRawResult) GetSuccess() *AggregateQueryRawResult_ { +func (p *NodeFetchResult) GetSuccess() *FetchResult_ { if !p.IsSetSuccess() { - return NodeAggregateRawResult_Success_DEFAULT + return NodeFetchResult_Success_DEFAULT } return p.Success } -var NodeAggregateRawResult_Err_DEFAULT *Error +var NodeFetchResult_Err_DEFAULT *Error -func (p *NodeAggregateRawResult) GetErr() *Error { +func (p *NodeFetchResult) GetErr() *Error { if !p.IsSetErr() { - return NodeAggregateRawResult_Err_DEFAULT + return NodeFetchResult_Err_DEFAULT } return p.Err } -func (p *NodeAggregateRawResult) IsSetSuccess() bool { +func (p *NodeFetchResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeAggregateRawResult) IsSetErr() bool { +func (p *NodeFetchResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeAggregateRawResult) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17494,15 +18904,15 @@ func (p *NodeAggregateRawResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &AggregateQueryRawResult_{} +func (p *NodeFetchResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeAggregateRawResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -17512,8 +18922,8 @@ func (p *NodeAggregateRawResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("aggregateRaw_result"); err != nil { +func (p *NodeFetchResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetch_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17533,7 +18943,7 @@ func (p *NodeAggregateRawResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateRawResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchResult) 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) @@ -17548,7 +18958,7 @@ func (p *NodeAggregateRawResult) writeField0(oprot thrift.TProtocol) (err error) return err } -func (p *NodeAggregateRawResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchResult) 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) @@ -17563,36 +18973,36 @@ func (p *NodeAggregateRawResult) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeAggregateRawResult) String() string { +func (p *NodeFetchResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeAggregateRawResult(%+v)", *p) + return fmt.Sprintf("NodeFetchResult(%+v)", *p) } // Attributes: // - Req -type NodeAggregateArgs struct { - Req *AggregateQueryRequest `thrift:"req,1" db:"req" json:"req"` +type NodeFetchTaggedArgs struct { + Req *FetchTaggedRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeAggregateArgs() *NodeAggregateArgs { - return &NodeAggregateArgs{} +func NewNodeFetchTaggedArgs() *NodeFetchTaggedArgs { + return &NodeFetchTaggedArgs{} } -var NodeAggregateArgs_Req_DEFAULT *AggregateQueryRequest +var NodeFetchTaggedArgs_Req_DEFAULT *FetchTaggedRequest -func (p *NodeAggregateArgs) GetReq() *AggregateQueryRequest { +func (p *NodeFetchTaggedArgs) GetReq() *FetchTaggedRequest { if !p.IsSetReq() { - return NodeAggregateArgs_Req_DEFAULT + return NodeFetchTaggedArgs_Req_DEFAULT } return p.Req } -func (p *NodeAggregateArgs) IsSetReq() bool { +func (p *NodeFetchTaggedArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeAggregateArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchTaggedArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17625,11 +19035,9 @@ func (p *NodeAggregateArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &AggregateQueryRequest{ - AggregateQueryType: 1, - - RangeType: 0, +func (p *NodeFetchTaggedArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchTaggedRequest{ + RangeTimeType: 0, } if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) @@ -17637,8 +19045,8 @@ func (p *NodeAggregateArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("aggregate_args"); err != nil { +func (p *NodeFetchTaggedArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchTagged_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17655,7 +19063,7 @@ func (p *NodeAggregateArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchTaggedArgs) 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) } @@ -17668,51 +19076,51 @@ func (p *NodeAggregateArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeAggregateArgs) String() string { +func (p *NodeFetchTaggedArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeAggregateArgs(%+v)", *p) + return fmt.Sprintf("NodeFetchTaggedArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeAggregateResult struct { - Success *AggregateQueryResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchTaggedResult struct { + Success *FetchTaggedResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeAggregateResult() *NodeAggregateResult { - return &NodeAggregateResult{} +func NewNodeFetchTaggedResult() *NodeFetchTaggedResult { + return &NodeFetchTaggedResult{} } -var NodeAggregateResult_Success_DEFAULT *AggregateQueryResult_ +var NodeFetchTaggedResult_Success_DEFAULT *FetchTaggedResult_ -func (p *NodeAggregateResult) GetSuccess() *AggregateQueryResult_ { +func (p *NodeFetchTaggedResult) GetSuccess() *FetchTaggedResult_ { if !p.IsSetSuccess() { - return NodeAggregateResult_Success_DEFAULT + return NodeFetchTaggedResult_Success_DEFAULT } return p.Success } -var NodeAggregateResult_Err_DEFAULT *Error +var NodeFetchTaggedResult_Err_DEFAULT *Error -func (p *NodeAggregateResult) GetErr() *Error { +func (p *NodeFetchTaggedResult) GetErr() *Error { if !p.IsSetErr() { - return NodeAggregateResult_Err_DEFAULT + return NodeFetchTaggedResult_Err_DEFAULT } return p.Err } -func (p *NodeAggregateResult) IsSetSuccess() bool { +func (p *NodeFetchTaggedResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeAggregateResult) IsSetErr() bool { +func (p *NodeFetchTaggedResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeAggregateResult) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchTaggedResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17749,15 +19157,15 @@ func (p *NodeAggregateResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &AggregateQueryResult_{} +func (p *NodeFetchTaggedResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchTaggedResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeAggregateResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchTaggedResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -17767,8 +19175,8 @@ func (p *NodeAggregateResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("aggregate_result"); err != nil { +func (p *NodeFetchTaggedResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchTagged_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17788,7 +19196,7 @@ func (p *NodeAggregateResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeAggregateResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchTaggedResult) 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) @@ -17803,7 +19211,7 @@ func (p *NodeAggregateResult) writeField0(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeAggregateResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchTaggedResult) 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) @@ -17818,36 +19226,36 @@ func (p *NodeAggregateResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeAggregateResult) String() string { +func (p *NodeFetchTaggedResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeAggregateResult(%+v)", *p) + return fmt.Sprintf("NodeFetchTaggedResult(%+v)", *p) } // Attributes: // - Req -type NodeFetchArgs struct { - Req *FetchRequest `thrift:"req,1" db:"req" json:"req"` +type NodeWriteArgs struct { + Req *WriteRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchArgs() *NodeFetchArgs { - return &NodeFetchArgs{} +func NewNodeWriteArgs() *NodeWriteArgs { + return &NodeWriteArgs{} } -var NodeFetchArgs_Req_DEFAULT *FetchRequest +var NodeWriteArgs_Req_DEFAULT *WriteRequest -func (p *NodeFetchArgs) GetReq() *FetchRequest { +func (p *NodeWriteArgs) GetReq() *WriteRequest { if !p.IsSetReq() { - return NodeFetchArgs_Req_DEFAULT + return NodeWriteArgs_Req_DEFAULT } return p.Req } -func (p *NodeFetchArgs) IsSetReq() bool { +func (p *NodeWriteArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17880,20 +19288,16 @@ func (p *NodeFetchArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchRequest{ - RangeType: 0, - - ResultTimeType: 0, - } +func (p *NodeWriteArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetch_args"); err != nil { +func (p *NodeWriteArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("write_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -17910,7 +19314,7 @@ func (p *NodeFetchArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteArgs) 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) } @@ -17923,51 +19327,36 @@ func (p *NodeFetchArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeFetchArgs) String() string { +func (p *NodeWriteArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchArgs(%+v)", *p) + return fmt.Sprintf("NodeWriteArgs(%+v)", *p) } // Attributes: -// - Success // - Err -type NodeFetchResult struct { - Success *FetchResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` -} - -func NewNodeFetchResult() *NodeFetchResult { - return &NodeFetchResult{} +type NodeWriteResult struct { + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -var NodeFetchResult_Success_DEFAULT *FetchResult_ - -func (p *NodeFetchResult) GetSuccess() *FetchResult_ { - if !p.IsSetSuccess() { - return NodeFetchResult_Success_DEFAULT - } - return p.Success +func NewNodeWriteResult() *NodeWriteResult { + return &NodeWriteResult{} } -var NodeFetchResult_Err_DEFAULT *Error +var NodeWriteResult_Err_DEFAULT *Error -func (p *NodeFetchResult) GetErr() *Error { +func (p *NodeWriteResult) GetErr() *Error { if !p.IsSetErr() { - return NodeFetchResult_Err_DEFAULT + return NodeWriteResult_Err_DEFAULT } return p.Err } -func (p *NodeFetchResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NodeFetchResult) IsSetErr() bool { +func (p *NodeWriteResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchResult) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -17981,10 +19370,6 @@ func (p *NodeFetchResult) Read(iprot thrift.TProtocol) error { 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 @@ -17995,24 +19380,16 @@ func (p *NodeFetchResult) Read(iprot thrift.TProtocol) error { } } 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 *NodeFetchResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchResult_{} - if err := p.Success.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + return err + } + } + if err := iprot.ReadStructEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } -func (p *NodeFetchResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeWriteResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -18022,14 +19399,11 @@ func (p *NodeFetchResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetch_result"); err != nil { +func (p *NodeWriteResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("write_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField0(oprot); err != nil { - return err - } if err := p.writeField1(oprot); err != nil { return err } @@ -18043,22 +19417,7 @@ func (p *NodeFetchResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchResult) 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 *NodeFetchResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteResult) 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) @@ -18073,36 +19432,36 @@ func (p *NodeFetchResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeFetchResult) String() string { +func (p *NodeWriteResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchResult(%+v)", *p) + return fmt.Sprintf("NodeWriteResult(%+v)", *p) } // Attributes: // - Req -type NodeFetchTaggedArgs struct { - Req *FetchTaggedRequest `thrift:"req,1" db:"req" json:"req"` +type NodeWriteTaggedArgs struct { + Req *WriteTaggedRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchTaggedArgs() *NodeFetchTaggedArgs { - return &NodeFetchTaggedArgs{} +func NewNodeWriteTaggedArgs() *NodeWriteTaggedArgs { + return &NodeWriteTaggedArgs{} } -var NodeFetchTaggedArgs_Req_DEFAULT *FetchTaggedRequest +var NodeWriteTaggedArgs_Req_DEFAULT *WriteTaggedRequest -func (p *NodeFetchTaggedArgs) GetReq() *FetchTaggedRequest { +func (p *NodeWriteTaggedArgs) GetReq() *WriteTaggedRequest { if !p.IsSetReq() { - return NodeFetchTaggedArgs_Req_DEFAULT + return NodeWriteTaggedArgs_Req_DEFAULT } return p.Req } -func (p *NodeFetchTaggedArgs) IsSetReq() bool { +func (p *NodeWriteTaggedArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchTaggedArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18135,18 +19494,16 @@ func (p *NodeFetchTaggedArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchTaggedArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchTaggedRequest{ - RangeTimeType: 0, - } +func (p *NodeWriteTaggedArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteTaggedRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchTaggedArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchTagged_args"); err != nil { +func (p *NodeWriteTaggedArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTagged_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -18163,7 +19520,7 @@ func (p *NodeFetchTaggedArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchTaggedArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedArgs) 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) } @@ -18176,51 +19533,36 @@ func (p *NodeFetchTaggedArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeFetchTaggedArgs) String() string { +func (p *NodeWriteTaggedArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchTaggedArgs(%+v)", *p) + return fmt.Sprintf("NodeWriteTaggedArgs(%+v)", *p) } // Attributes: -// - Success // - Err -type NodeFetchTaggedResult struct { - Success *FetchTaggedResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` -} - -func NewNodeFetchTaggedResult() *NodeFetchTaggedResult { - return &NodeFetchTaggedResult{} +type NodeWriteTaggedResult struct { + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -var NodeFetchTaggedResult_Success_DEFAULT *FetchTaggedResult_ - -func (p *NodeFetchTaggedResult) GetSuccess() *FetchTaggedResult_ { - if !p.IsSetSuccess() { - return NodeFetchTaggedResult_Success_DEFAULT - } - return p.Success +func NewNodeWriteTaggedResult() *NodeWriteTaggedResult { + return &NodeWriteTaggedResult{} } -var NodeFetchTaggedResult_Err_DEFAULT *Error +var NodeWriteTaggedResult_Err_DEFAULT *Error -func (p *NodeFetchTaggedResult) GetErr() *Error { +func (p *NodeWriteTaggedResult) GetErr() *Error { if !p.IsSetErr() { - return NodeFetchTaggedResult_Err_DEFAULT + return NodeWriteTaggedResult_Err_DEFAULT } return p.Err } -func (p *NodeFetchTaggedResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NodeFetchTaggedResult) IsSetErr() bool { +func (p *NodeWriteTaggedResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchTaggedResult) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18234,10 +19576,6 @@ func (p *NodeFetchTaggedResult) Read(iprot thrift.TProtocol) error { 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 @@ -18257,15 +19595,7 @@ func (p *NodeFetchTaggedResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchTaggedResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchTaggedResult_{} - if err := p.Success.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) - } - return nil -} - -func (p *NodeFetchTaggedResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -18275,14 +19605,11 @@ func (p *NodeFetchTaggedResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchTaggedResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchTagged_result"); err != nil { +func (p *NodeWriteTaggedResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTagged_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField0(oprot); err != nil { - return err - } if err := p.writeField1(oprot); err != nil { return err } @@ -18296,22 +19623,7 @@ func (p *NodeFetchTaggedResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchTaggedResult) 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 *NodeFetchTaggedResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedResult) 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) @@ -18326,36 +19638,36 @@ func (p *NodeFetchTaggedResult) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeFetchTaggedResult) String() string { +func (p *NodeWriteTaggedResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchTaggedResult(%+v)", *p) + return fmt.Sprintf("NodeWriteTaggedResult(%+v)", *p) } // Attributes: // - Req -type NodeWriteArgs struct { - Req *WriteRequest `thrift:"req,1" db:"req" json:"req"` +type NodeFetchBatchRawArgs struct { + Req *FetchBatchRawRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeWriteArgs() *NodeWriteArgs { - return &NodeWriteArgs{} +func NewNodeFetchBatchRawArgs() *NodeFetchBatchRawArgs { + return &NodeFetchBatchRawArgs{} } -var NodeWriteArgs_Req_DEFAULT *WriteRequest +var NodeFetchBatchRawArgs_Req_DEFAULT *FetchBatchRawRequest -func (p *NodeWriteArgs) GetReq() *WriteRequest { +func (p *NodeFetchBatchRawArgs) GetReq() *FetchBatchRawRequest { if !p.IsSetReq() { - return NodeWriteArgs_Req_DEFAULT + return NodeFetchBatchRawArgs_Req_DEFAULT } return p.Req } -func (p *NodeWriteArgs) IsSetReq() bool { +func (p *NodeFetchBatchRawArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeWriteArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18388,16 +19700,18 @@ func (p *NodeWriteArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteRequest{} +func (p *NodeFetchBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchBatchRawRequest{ + RangeTimeType: 0, + } if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeWriteArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("write_args"); err != nil { +func (p *NodeFetchBatchRawArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBatchRaw_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -18414,7 +19728,7 @@ func (p *NodeWriteArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBatchRawArgs) 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) } @@ -18427,36 +19741,51 @@ func (p *NodeWriteArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeWriteArgs) String() string { +func (p *NodeFetchBatchRawArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteArgs(%+v)", *p) + return fmt.Sprintf("NodeFetchBatchRawArgs(%+v)", *p) } // Attributes: +// - Success // - Err -type NodeWriteResult struct { - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchBatchRawResult struct { + Success *FetchBatchRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteResult() *NodeWriteResult { - return &NodeWriteResult{} +func NewNodeFetchBatchRawResult() *NodeFetchBatchRawResult { + return &NodeFetchBatchRawResult{} } -var NodeWriteResult_Err_DEFAULT *Error +var NodeFetchBatchRawResult_Success_DEFAULT *FetchBatchRawResult_ -func (p *NodeWriteResult) GetErr() *Error { +func (p *NodeFetchBatchRawResult) GetSuccess() *FetchBatchRawResult_ { + if !p.IsSetSuccess() { + return NodeFetchBatchRawResult_Success_DEFAULT + } + return p.Success +} + +var NodeFetchBatchRawResult_Err_DEFAULT *Error + +func (p *NodeFetchBatchRawResult) GetErr() *Error { if !p.IsSetErr() { - return NodeWriteResult_Err_DEFAULT + return NodeFetchBatchRawResult_Err_DEFAULT } return p.Err } -func (p *NodeWriteResult) IsSetErr() bool { +func (p *NodeFetchBatchRawResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeFetchBatchRawResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteResult) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18470,6 +19799,10 @@ func (p *NodeWriteResult) Read(iprot thrift.TProtocol) error { 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 @@ -18489,7 +19822,15 @@ func (p *NodeWriteResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchBatchRawResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil +} + +func (p *NodeFetchBatchRawResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -18499,11 +19840,14 @@ func (p *NodeWriteResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("write_result"); err != nil { +func (p *NodeFetchBatchRawResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBatchRaw_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField0(oprot); err != nil { + return err + } if err := p.writeField1(oprot); err != nil { return err } @@ -18517,7 +19861,22 @@ func (p *NodeWriteResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBatchRawResult) 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 *NodeFetchBatchRawResult) 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) @@ -18532,36 +19891,36 @@ func (p *NodeWriteResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeWriteResult) String() string { +func (p *NodeFetchBatchRawResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteResult(%+v)", *p) + return fmt.Sprintf("NodeFetchBatchRawResult(%+v)", *p) } // Attributes: // - Req -type NodeWriteTaggedArgs struct { - Req *WriteTaggedRequest `thrift:"req,1" db:"req" json:"req"` +type NodeFetchBatchRawV2Args struct { + Req *FetchBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` } -func NewNodeWriteTaggedArgs() *NodeWriteTaggedArgs { - return &NodeWriteTaggedArgs{} +func NewNodeFetchBatchRawV2Args() *NodeFetchBatchRawV2Args { + return &NodeFetchBatchRawV2Args{} } -var NodeWriteTaggedArgs_Req_DEFAULT *WriteTaggedRequest +var NodeFetchBatchRawV2Args_Req_DEFAULT *FetchBatchRawV2Request -func (p *NodeWriteTaggedArgs) GetReq() *WriteTaggedRequest { +func (p *NodeFetchBatchRawV2Args) GetReq() *FetchBatchRawV2Request { if !p.IsSetReq() { - return NodeWriteTaggedArgs_Req_DEFAULT + return NodeFetchBatchRawV2Args_Req_DEFAULT } return p.Req } -func (p *NodeWriteTaggedArgs) IsSetReq() bool { +func (p *NodeFetchBatchRawV2Args) IsSetReq() bool { return p.Req != nil } -func (p *NodeWriteTaggedArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawV2Args) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18594,16 +19953,16 @@ func (p *NodeWriteTaggedArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteTaggedRequest{} +func (p *NodeFetchBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchBatchRawV2Request{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeWriteTaggedArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTagged_args"); err != nil { +func (p *NodeFetchBatchRawV2Args) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBatchRawV2_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -18620,7 +19979,7 @@ func (p *NodeWriteTaggedArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBatchRawV2Args) 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) } @@ -18633,36 +19992,51 @@ func (p *NodeWriteTaggedArgs) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeWriteTaggedArgs) String() string { +func (p *NodeFetchBatchRawV2Args) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedArgs(%+v)", *p) + return fmt.Sprintf("NodeFetchBatchRawV2Args(%+v)", *p) } // Attributes: +// - Success // - Err -type NodeWriteTaggedResult struct { - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchBatchRawV2Result struct { + Success *FetchBatchRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteTaggedResult() *NodeWriteTaggedResult { - return &NodeWriteTaggedResult{} +func NewNodeFetchBatchRawV2Result() *NodeFetchBatchRawV2Result { + return &NodeFetchBatchRawV2Result{} } -var NodeWriteTaggedResult_Err_DEFAULT *Error +var NodeFetchBatchRawV2Result_Success_DEFAULT *FetchBatchRawResult_ -func (p *NodeWriteTaggedResult) GetErr() *Error { +func (p *NodeFetchBatchRawV2Result) GetSuccess() *FetchBatchRawResult_ { + if !p.IsSetSuccess() { + return NodeFetchBatchRawV2Result_Success_DEFAULT + } + return p.Success +} + +var NodeFetchBatchRawV2Result_Err_DEFAULT *Error + +func (p *NodeFetchBatchRawV2Result) GetErr() *Error { if !p.IsSetErr() { - return NodeWriteTaggedResult_Err_DEFAULT + return NodeFetchBatchRawV2Result_Err_DEFAULT } return p.Err } -func (p *NodeWriteTaggedResult) IsSetErr() bool { +func (p *NodeFetchBatchRawV2Result) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeFetchBatchRawV2Result) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteTaggedResult) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawV2Result) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18676,6 +20050,10 @@ func (p *NodeWriteTaggedResult) Read(iprot thrift.TProtocol) error { 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 @@ -18695,7 +20073,15 @@ func (p *NodeWriteTaggedResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchBatchRawV2Result) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchBatchRawResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil +} + +func (p *NodeFetchBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -18705,11 +20091,14 @@ func (p *NodeWriteTaggedResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTagged_result"); err != nil { +func (p *NodeFetchBatchRawV2Result) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBatchRawV2_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField0(oprot); err != nil { + return err + } if err := p.writeField1(oprot); err != nil { return err } @@ -18723,7 +20112,22 @@ func (p *NodeWriteTaggedResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBatchRawV2Result) 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 *NodeFetchBatchRawV2Result) 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) @@ -18738,36 +20142,36 @@ func (p *NodeWriteTaggedResult) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeWriteTaggedResult) String() string { +func (p *NodeFetchBatchRawV2Result) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedResult(%+v)", *p) + return fmt.Sprintf("NodeFetchBatchRawV2Result(%+v)", *p) } // Attributes: // - Req -type NodeFetchBatchRawArgs struct { - Req *FetchBatchRawRequest `thrift:"req,1" db:"req" json:"req"` +type NodeFetchBlocksRawArgs struct { + Req *FetchBlocksRawRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchBatchRawArgs() *NodeFetchBatchRawArgs { - return &NodeFetchBatchRawArgs{} +func NewNodeFetchBlocksRawArgs() *NodeFetchBlocksRawArgs { + return &NodeFetchBlocksRawArgs{} } -var NodeFetchBatchRawArgs_Req_DEFAULT *FetchBatchRawRequest +var NodeFetchBlocksRawArgs_Req_DEFAULT *FetchBlocksRawRequest -func (p *NodeFetchBatchRawArgs) GetReq() *FetchBatchRawRequest { +func (p *NodeFetchBlocksRawArgs) GetReq() *FetchBlocksRawRequest { if !p.IsSetReq() { - return NodeFetchBatchRawArgs_Req_DEFAULT + return NodeFetchBlocksRawArgs_Req_DEFAULT } return p.Req } -func (p *NodeFetchBatchRawArgs) IsSetReq() bool { +func (p *NodeFetchBlocksRawArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchBatchRawArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksRawArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18800,18 +20204,16 @@ func (p *NodeFetchBatchRawArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchBatchRawRequest{ - RangeTimeType: 0, - } +func (p *NodeFetchBlocksRawArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchBlocksRawRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchBatchRawArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBatchRaw_args"); err != nil { +func (p *NodeFetchBlocksRawArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBlocksRaw_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -18828,7 +20230,7 @@ func (p *NodeFetchBatchRawArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksRawArgs) 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) } @@ -18841,51 +20243,51 @@ func (p *NodeFetchBatchRawArgs) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeFetchBatchRawArgs) String() string { +func (p *NodeFetchBlocksRawArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBatchRawArgs(%+v)", *p) + return fmt.Sprintf("NodeFetchBlocksRawArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeFetchBatchRawResult struct { - Success *FetchBatchRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchBlocksRawResult struct { + Success *FetchBlocksRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeFetchBatchRawResult() *NodeFetchBatchRawResult { - return &NodeFetchBatchRawResult{} +func NewNodeFetchBlocksRawResult() *NodeFetchBlocksRawResult { + return &NodeFetchBlocksRawResult{} } -var NodeFetchBatchRawResult_Success_DEFAULT *FetchBatchRawResult_ +var NodeFetchBlocksRawResult_Success_DEFAULT *FetchBlocksRawResult_ -func (p *NodeFetchBatchRawResult) GetSuccess() *FetchBatchRawResult_ { +func (p *NodeFetchBlocksRawResult) GetSuccess() *FetchBlocksRawResult_ { if !p.IsSetSuccess() { - return NodeFetchBatchRawResult_Success_DEFAULT + return NodeFetchBlocksRawResult_Success_DEFAULT } return p.Success } -var NodeFetchBatchRawResult_Err_DEFAULT *Error +var NodeFetchBlocksRawResult_Err_DEFAULT *Error -func (p *NodeFetchBatchRawResult) GetErr() *Error { +func (p *NodeFetchBlocksRawResult) GetErr() *Error { if !p.IsSetErr() { - return NodeFetchBatchRawResult_Err_DEFAULT + return NodeFetchBlocksRawResult_Err_DEFAULT } return p.Err } -func (p *NodeFetchBatchRawResult) IsSetSuccess() bool { +func (p *NodeFetchBlocksRawResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeFetchBatchRawResult) IsSetErr() bool { +func (p *NodeFetchBlocksRawResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchBatchRawResult) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksRawResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -18922,15 +20324,15 @@ func (p *NodeFetchBatchRawResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchBatchRawResult_{} +func (p *NodeFetchBlocksRawResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchBlocksRawResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeFetchBatchRawResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksRawResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -18940,8 +20342,8 @@ func (p *NodeFetchBatchRawResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBatchRaw_result"); err != nil { +func (p *NodeFetchBlocksRawResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBlocksRaw_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -18961,7 +20363,7 @@ func (p *NodeFetchBatchRawResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksRawResult) 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) @@ -18976,7 +20378,7 @@ func (p *NodeFetchBatchRawResult) writeField0(oprot thrift.TProtocol) (err error return err } -func (p *NodeFetchBatchRawResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksRawResult) 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) @@ -18991,36 +20393,36 @@ func (p *NodeFetchBatchRawResult) writeField1(oprot thrift.TProtocol) (err error return err } -func (p *NodeFetchBatchRawResult) String() string { +func (p *NodeFetchBlocksRawResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBatchRawResult(%+v)", *p) + return fmt.Sprintf("NodeFetchBlocksRawResult(%+v)", *p) } // Attributes: // - Req -type NodeFetchBatchRawV2Args struct { - Req *FetchBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` +type NodeFetchBlocksMetadataRawV2Args struct { + Req *FetchBlocksMetadataRawV2Request `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchBatchRawV2Args() *NodeFetchBatchRawV2Args { - return &NodeFetchBatchRawV2Args{} +func NewNodeFetchBlocksMetadataRawV2Args() *NodeFetchBlocksMetadataRawV2Args { + return &NodeFetchBlocksMetadataRawV2Args{} } -var NodeFetchBatchRawV2Args_Req_DEFAULT *FetchBatchRawV2Request +var NodeFetchBlocksMetadataRawV2Args_Req_DEFAULT *FetchBlocksMetadataRawV2Request -func (p *NodeFetchBatchRawV2Args) GetReq() *FetchBatchRawV2Request { +func (p *NodeFetchBlocksMetadataRawV2Args) GetReq() *FetchBlocksMetadataRawV2Request { if !p.IsSetReq() { - return NodeFetchBatchRawV2Args_Req_DEFAULT + return NodeFetchBlocksMetadataRawV2Args_Req_DEFAULT } return p.Req } -func (p *NodeFetchBatchRawV2Args) IsSetReq() bool { +func (p *NodeFetchBlocksMetadataRawV2Args) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchBatchRawV2Args) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksMetadataRawV2Args) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19053,16 +20455,16 @@ func (p *NodeFetchBatchRawV2Args) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchBatchRawV2Request{} +func (p *NodeFetchBlocksMetadataRawV2Args) ReadField1(iprot thrift.TProtocol) error { + p.Req = &FetchBlocksMetadataRawV2Request{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchBatchRawV2Args) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBatchRawV2_args"); err != nil { +func (p *NodeFetchBlocksMetadataRawV2Args) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBlocksMetadataRawV2_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19079,7 +20481,7 @@ func (p *NodeFetchBatchRawV2Args) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksMetadataRawV2Args) 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) } @@ -19092,51 +20494,51 @@ func (p *NodeFetchBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err error return err } -func (p *NodeFetchBatchRawV2Args) String() string { +func (p *NodeFetchBlocksMetadataRawV2Args) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBatchRawV2Args(%+v)", *p) + return fmt.Sprintf("NodeFetchBlocksMetadataRawV2Args(%+v)", *p) } // Attributes: // - Success // - Err -type NodeFetchBatchRawV2Result struct { - Success *FetchBatchRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeFetchBlocksMetadataRawV2Result struct { + Success *FetchBlocksMetadataRawV2Result_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeFetchBatchRawV2Result() *NodeFetchBatchRawV2Result { - return &NodeFetchBatchRawV2Result{} +func NewNodeFetchBlocksMetadataRawV2Result() *NodeFetchBlocksMetadataRawV2Result { + return &NodeFetchBlocksMetadataRawV2Result{} } -var NodeFetchBatchRawV2Result_Success_DEFAULT *FetchBatchRawResult_ +var NodeFetchBlocksMetadataRawV2Result_Success_DEFAULT *FetchBlocksMetadataRawV2Result_ -func (p *NodeFetchBatchRawV2Result) GetSuccess() *FetchBatchRawResult_ { +func (p *NodeFetchBlocksMetadataRawV2Result) GetSuccess() *FetchBlocksMetadataRawV2Result_ { if !p.IsSetSuccess() { - return NodeFetchBatchRawV2Result_Success_DEFAULT + return NodeFetchBlocksMetadataRawV2Result_Success_DEFAULT } return p.Success } -var NodeFetchBatchRawV2Result_Err_DEFAULT *Error +var NodeFetchBlocksMetadataRawV2Result_Err_DEFAULT *Error -func (p *NodeFetchBatchRawV2Result) GetErr() *Error { +func (p *NodeFetchBlocksMetadataRawV2Result) GetErr() *Error { if !p.IsSetErr() { - return NodeFetchBatchRawV2Result_Err_DEFAULT + return NodeFetchBlocksMetadataRawV2Result_Err_DEFAULT } return p.Err } -func (p *NodeFetchBatchRawV2Result) IsSetSuccess() bool { +func (p *NodeFetchBlocksMetadataRawV2Result) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeFetchBatchRawV2Result) IsSetErr() bool { +func (p *NodeFetchBlocksMetadataRawV2Result) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchBatchRawV2Result) Read(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksMetadataRawV2Result) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19173,15 +20575,15 @@ func (p *NodeFetchBatchRawV2Result) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawV2Result) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchBatchRawResult_{} +func (p *NodeFetchBlocksMetadataRawV2Result) ReadField0(iprot thrift.TProtocol) error { + p.Success = &FetchBlocksMetadataRawV2Result_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeFetchBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeFetchBlocksMetadataRawV2Result) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -19191,8 +20593,8 @@ func (p *NodeFetchBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawV2Result) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBatchRawV2_result"); err != nil { +func (p *NodeFetchBlocksMetadataRawV2Result) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("fetchBlocksMetadataRawV2_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19212,7 +20614,7 @@ func (p *NodeFetchBatchRawV2Result) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBatchRawV2Result) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksMetadataRawV2Result) 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) @@ -19227,7 +20629,7 @@ func (p *NodeFetchBatchRawV2Result) writeField0(oprot thrift.TProtocol) (err err return err } -func (p *NodeFetchBatchRawV2Result) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeFetchBlocksMetadataRawV2Result) 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) @@ -19242,36 +20644,36 @@ func (p *NodeFetchBatchRawV2Result) writeField1(oprot thrift.TProtocol) (err err return err } -func (p *NodeFetchBatchRawV2Result) String() string { +func (p *NodeFetchBlocksMetadataRawV2Result) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBatchRawV2Result(%+v)", *p) + return fmt.Sprintf("NodeFetchBlocksMetadataRawV2Result(%+v)", *p) } // Attributes: // - Req -type NodeFetchBlocksRawArgs struct { - Req *FetchBlocksRawRequest `thrift:"req,1" db:"req" json:"req"` +type NodeWriteBatchRawArgs struct { + Req *WriteBatchRawRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchBlocksRawArgs() *NodeFetchBlocksRawArgs { - return &NodeFetchBlocksRawArgs{} +func NewNodeWriteBatchRawArgs() *NodeWriteBatchRawArgs { + return &NodeWriteBatchRawArgs{} } -var NodeFetchBlocksRawArgs_Req_DEFAULT *FetchBlocksRawRequest +var NodeWriteBatchRawArgs_Req_DEFAULT *WriteBatchRawRequest -func (p *NodeFetchBlocksRawArgs) GetReq() *FetchBlocksRawRequest { +func (p *NodeWriteBatchRawArgs) GetReq() *WriteBatchRawRequest { if !p.IsSetReq() { - return NodeFetchBlocksRawArgs_Req_DEFAULT + return NodeWriteBatchRawArgs_Req_DEFAULT } return p.Req } -func (p *NodeFetchBlocksRawArgs) IsSetReq() bool { +func (p *NodeWriteBatchRawArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchBlocksRawArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteBatchRawArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19304,16 +20706,16 @@ func (p *NodeFetchBlocksRawArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksRawArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchBlocksRawRequest{} +func (p *NodeWriteBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteBatchRawRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchBlocksRawArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBlocksRaw_args"); err != nil { +func (p *NodeWriteBatchRawArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeBatchRaw_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19330,7 +20732,7 @@ func (p *NodeFetchBlocksRawArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksRawArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteBatchRawArgs) 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) } @@ -19343,51 +20745,36 @@ func (p *NodeFetchBlocksRawArgs) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeFetchBlocksRawArgs) String() string { +func (p *NodeWriteBatchRawArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBlocksRawArgs(%+v)", *p) + return fmt.Sprintf("NodeWriteBatchRawArgs(%+v)", *p) } // Attributes: -// - Success // - Err -type NodeFetchBlocksRawResult struct { - Success *FetchBlocksRawResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` -} - -func NewNodeFetchBlocksRawResult() *NodeFetchBlocksRawResult { - return &NodeFetchBlocksRawResult{} +type NodeWriteBatchRawResult struct { + Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` } -var NodeFetchBlocksRawResult_Success_DEFAULT *FetchBlocksRawResult_ - -func (p *NodeFetchBlocksRawResult) GetSuccess() *FetchBlocksRawResult_ { - if !p.IsSetSuccess() { - return NodeFetchBlocksRawResult_Success_DEFAULT - } - return p.Success +func NewNodeWriteBatchRawResult() *NodeWriteBatchRawResult { + return &NodeWriteBatchRawResult{} } -var NodeFetchBlocksRawResult_Err_DEFAULT *Error +var NodeWriteBatchRawResult_Err_DEFAULT *WriteBatchRawErrors -func (p *NodeFetchBlocksRawResult) GetErr() *Error { +func (p *NodeWriteBatchRawResult) GetErr() *WriteBatchRawErrors { if !p.IsSetErr() { - return NodeFetchBlocksRawResult_Err_DEFAULT + return NodeWriteBatchRawResult_Err_DEFAULT } return p.Err } -func (p *NodeFetchBlocksRawResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NodeFetchBlocksRawResult) IsSetErr() bool { +func (p *NodeWriteBatchRawResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchBlocksRawResult) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteBatchRawResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19401,10 +20788,6 @@ func (p *NodeFetchBlocksRawResult) Read(iprot thrift.TProtocol) error { 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 @@ -19424,32 +20807,19 @@ func (p *NodeFetchBlocksRawResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksRawResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchBlocksRawResult_{} - if err := p.Success.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) - } - return nil -} - -func (p *NodeFetchBlocksRawResult) ReadField1(iprot thrift.TProtocol) error { - p.Err = &Error{ - Type: 0, - } +func (p *NodeWriteBatchRawResult) ReadField1(iprot thrift.TProtocol) error { + p.Err = &WriteBatchRawErrors{} if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) } return nil } -func (p *NodeFetchBlocksRawResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBlocksRaw_result"); err != nil { +func (p *NodeWriteBatchRawResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeBatchRaw_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField0(oprot); err != nil { - return err - } if err := p.writeField1(oprot); err != nil { return err } @@ -19463,22 +20833,7 @@ func (p *NodeFetchBlocksRawResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksRawResult) 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 *NodeFetchBlocksRawResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteBatchRawResult) 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) @@ -19493,36 +20848,36 @@ func (p *NodeFetchBlocksRawResult) writeField1(oprot thrift.TProtocol) (err erro return err } -func (p *NodeFetchBlocksRawResult) String() string { +func (p *NodeWriteBatchRawResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBlocksRawResult(%+v)", *p) + return fmt.Sprintf("NodeWriteBatchRawResult(%+v)", *p) } // Attributes: // - Req -type NodeFetchBlocksMetadataRawV2Args struct { - Req *FetchBlocksMetadataRawV2Request `thrift:"req,1" db:"req" json:"req"` +type NodeWriteBatchRawV2Args struct { + Req *WriteBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` } -func NewNodeFetchBlocksMetadataRawV2Args() *NodeFetchBlocksMetadataRawV2Args { - return &NodeFetchBlocksMetadataRawV2Args{} +func NewNodeWriteBatchRawV2Args() *NodeWriteBatchRawV2Args { + return &NodeWriteBatchRawV2Args{} } -var NodeFetchBlocksMetadataRawV2Args_Req_DEFAULT *FetchBlocksMetadataRawV2Request +var NodeWriteBatchRawV2Args_Req_DEFAULT *WriteBatchRawV2Request -func (p *NodeFetchBlocksMetadataRawV2Args) GetReq() *FetchBlocksMetadataRawV2Request { +func (p *NodeWriteBatchRawV2Args) GetReq() *WriteBatchRawV2Request { if !p.IsSetReq() { - return NodeFetchBlocksMetadataRawV2Args_Req_DEFAULT + return NodeWriteBatchRawV2Args_Req_DEFAULT } return p.Req } -func (p *NodeFetchBlocksMetadataRawV2Args) IsSetReq() bool { +func (p *NodeWriteBatchRawV2Args) IsSetReq() bool { return p.Req != nil } -func (p *NodeFetchBlocksMetadataRawV2Args) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteBatchRawV2Args) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19555,16 +20910,16 @@ func (p *NodeFetchBlocksMetadataRawV2Args) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksMetadataRawV2Args) ReadField1(iprot thrift.TProtocol) error { - p.Req = &FetchBlocksMetadataRawV2Request{} +func (p *NodeWriteBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteBatchRawV2Request{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeFetchBlocksMetadataRawV2Args) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBlocksMetadataRawV2_args"); err != nil { +func (p *NodeWriteBatchRawV2Args) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeBatchRawV2_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19581,7 +20936,7 @@ func (p *NodeFetchBlocksMetadataRawV2Args) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeFetchBlocksMetadataRawV2Args) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteBatchRawV2Args) 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) } @@ -19594,51 +20949,36 @@ func (p *NodeFetchBlocksMetadataRawV2Args) writeField1(oprot thrift.TProtocol) ( return err } -func (p *NodeFetchBlocksMetadataRawV2Args) String() string { +func (p *NodeWriteBatchRawV2Args) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBlocksMetadataRawV2Args(%+v)", *p) + return fmt.Sprintf("NodeWriteBatchRawV2Args(%+v)", *p) } // Attributes: -// - Success // - Err -type NodeFetchBlocksMetadataRawV2Result struct { - Success *FetchBlocksMetadataRawV2Result_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` -} - -func NewNodeFetchBlocksMetadataRawV2Result() *NodeFetchBlocksMetadataRawV2Result { - return &NodeFetchBlocksMetadataRawV2Result{} +type NodeWriteBatchRawV2Result struct { + Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` } -var NodeFetchBlocksMetadataRawV2Result_Success_DEFAULT *FetchBlocksMetadataRawV2Result_ - -func (p *NodeFetchBlocksMetadataRawV2Result) GetSuccess() *FetchBlocksMetadataRawV2Result_ { - if !p.IsSetSuccess() { - return NodeFetchBlocksMetadataRawV2Result_Success_DEFAULT - } - return p.Success +func NewNodeWriteBatchRawV2Result() *NodeWriteBatchRawV2Result { + return &NodeWriteBatchRawV2Result{} } -var NodeFetchBlocksMetadataRawV2Result_Err_DEFAULT *Error +var NodeWriteBatchRawV2Result_Err_DEFAULT *WriteBatchRawErrors -func (p *NodeFetchBlocksMetadataRawV2Result) GetErr() *Error { +func (p *NodeWriteBatchRawV2Result) GetErr() *WriteBatchRawErrors { if !p.IsSetErr() { - return NodeFetchBlocksMetadataRawV2Result_Err_DEFAULT + return NodeWriteBatchRawV2Result_Err_DEFAULT } return p.Err } -func (p *NodeFetchBlocksMetadataRawV2Result) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NodeFetchBlocksMetadataRawV2Result) IsSetErr() bool { +func (p *NodeWriteBatchRawV2Result) IsSetErr() bool { return p.Err != nil } -func (p *NodeFetchBlocksMetadataRawV2Result) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteBatchRawV2Result) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19652,10 +20992,6 @@ func (p *NodeFetchBlocksMetadataRawV2Result) Read(iprot thrift.TProtocol) error 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 @@ -19675,32 +21011,19 @@ func (p *NodeFetchBlocksMetadataRawV2Result) Read(iprot thrift.TProtocol) error return nil } -func (p *NodeFetchBlocksMetadataRawV2Result) ReadField0(iprot thrift.TProtocol) error { - p.Success = &FetchBlocksMetadataRawV2Result_{} - if err := p.Success.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) - } - return nil -} - -func (p *NodeFetchBlocksMetadataRawV2Result) ReadField1(iprot thrift.TProtocol) error { - p.Err = &Error{ - Type: 0, - } +func (p *NodeWriteBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { + p.Err = &WriteBatchRawErrors{} if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) } return nil } -func (p *NodeFetchBlocksMetadataRawV2Result) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("fetchBlocksMetadataRawV2_result"); err != nil { +func (p *NodeWriteBatchRawV2Result) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeBatchRawV2_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField0(oprot); err != nil { - return err - } if err := p.writeField1(oprot); err != nil { return err } @@ -19714,22 +21037,7 @@ func (p *NodeFetchBlocksMetadataRawV2Result) Write(oprot thrift.TProtocol) error return nil } -func (p *NodeFetchBlocksMetadataRawV2Result) 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 *NodeFetchBlocksMetadataRawV2Result) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteBatchRawV2Result) 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) @@ -19744,36 +21052,36 @@ func (p *NodeFetchBlocksMetadataRawV2Result) writeField1(oprot thrift.TProtocol) return err } -func (p *NodeFetchBlocksMetadataRawV2Result) String() string { +func (p *NodeWriteBatchRawV2Result) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeFetchBlocksMetadataRawV2Result(%+v)", *p) + return fmt.Sprintf("NodeWriteBatchRawV2Result(%+v)", *p) } // Attributes: // - Req -type NodeWriteBatchRawArgs struct { - Req *WriteBatchRawRequest `thrift:"req,1" db:"req" json:"req"` +type NodeWriteTaggedBatchRawArgs struct { + Req *WriteTaggedBatchRawRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeWriteBatchRawArgs() *NodeWriteBatchRawArgs { - return &NodeWriteBatchRawArgs{} +func NewNodeWriteTaggedBatchRawArgs() *NodeWriteTaggedBatchRawArgs { + return &NodeWriteTaggedBatchRawArgs{} } -var NodeWriteBatchRawArgs_Req_DEFAULT *WriteBatchRawRequest +var NodeWriteTaggedBatchRawArgs_Req_DEFAULT *WriteTaggedBatchRawRequest -func (p *NodeWriteBatchRawArgs) GetReq() *WriteBatchRawRequest { +func (p *NodeWriteTaggedBatchRawArgs) GetReq() *WriteTaggedBatchRawRequest { if !p.IsSetReq() { - return NodeWriteBatchRawArgs_Req_DEFAULT + return NodeWriteTaggedBatchRawArgs_Req_DEFAULT } return p.Req } -func (p *NodeWriteBatchRawArgs) IsSetReq() bool { +func (p *NodeWriteTaggedBatchRawArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeWriteBatchRawArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19806,16 +21114,16 @@ func (p *NodeWriteBatchRawArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteBatchRawRequest{} +func (p *NodeWriteTaggedBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteTaggedBatchRawRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeWriteBatchRawArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeBatchRaw_args"); err != nil { +func (p *NodeWriteTaggedBatchRawArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTaggedBatchRaw_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19832,7 +21140,7 @@ func (p *NodeWriteBatchRawArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedBatchRawArgs) 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) } @@ -19845,36 +21153,36 @@ func (p *NodeWriteBatchRawArgs) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeWriteBatchRawArgs) String() string { +func (p *NodeWriteTaggedBatchRawArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteBatchRawArgs(%+v)", *p) + return fmt.Sprintf("NodeWriteTaggedBatchRawArgs(%+v)", *p) } // Attributes: // - Err -type NodeWriteBatchRawResult struct { +type NodeWriteTaggedBatchRawResult struct { Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteBatchRawResult() *NodeWriteBatchRawResult { - return &NodeWriteBatchRawResult{} +func NewNodeWriteTaggedBatchRawResult() *NodeWriteTaggedBatchRawResult { + return &NodeWriteTaggedBatchRawResult{} } -var NodeWriteBatchRawResult_Err_DEFAULT *WriteBatchRawErrors +var NodeWriteTaggedBatchRawResult_Err_DEFAULT *WriteBatchRawErrors -func (p *NodeWriteBatchRawResult) GetErr() *WriteBatchRawErrors { +func (p *NodeWriteTaggedBatchRawResult) GetErr() *WriteBatchRawErrors { if !p.IsSetErr() { - return NodeWriteBatchRawResult_Err_DEFAULT + return NodeWriteTaggedBatchRawResult_Err_DEFAULT } return p.Err } -func (p *NodeWriteBatchRawResult) IsSetErr() bool { +func (p *NodeWriteTaggedBatchRawResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteBatchRawResult) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -19907,7 +21215,7 @@ func (p *NodeWriteBatchRawResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &WriteBatchRawErrors{} if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) @@ -19915,8 +21223,8 @@ func (p *NodeWriteBatchRawResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeBatchRaw_result"); err != nil { +func (p *NodeWriteTaggedBatchRawResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTaggedBatchRaw_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -19933,7 +21241,7 @@ func (p *NodeWriteBatchRawResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedBatchRawResult) 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) @@ -19948,36 +21256,36 @@ func (p *NodeWriteBatchRawResult) writeField1(oprot thrift.TProtocol) (err error return err } -func (p *NodeWriteBatchRawResult) String() string { +func (p *NodeWriteTaggedBatchRawResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteBatchRawResult(%+v)", *p) + return fmt.Sprintf("NodeWriteTaggedBatchRawResult(%+v)", *p) } // Attributes: // - Req -type NodeWriteBatchRawV2Args struct { - Req *WriteBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` +type NodeWriteTaggedBatchRawV2Args struct { + Req *WriteTaggedBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` } -func NewNodeWriteBatchRawV2Args() *NodeWriteBatchRawV2Args { - return &NodeWriteBatchRawV2Args{} +func NewNodeWriteTaggedBatchRawV2Args() *NodeWriteTaggedBatchRawV2Args { + return &NodeWriteTaggedBatchRawV2Args{} } -var NodeWriteBatchRawV2Args_Req_DEFAULT *WriteBatchRawV2Request +var NodeWriteTaggedBatchRawV2Args_Req_DEFAULT *WriteTaggedBatchRawV2Request -func (p *NodeWriteBatchRawV2Args) GetReq() *WriteBatchRawV2Request { +func (p *NodeWriteTaggedBatchRawV2Args) GetReq() *WriteTaggedBatchRawV2Request { if !p.IsSetReq() { - return NodeWriteBatchRawV2Args_Req_DEFAULT + return NodeWriteTaggedBatchRawV2Args_Req_DEFAULT } return p.Req } -func (p *NodeWriteBatchRawV2Args) IsSetReq() bool { +func (p *NodeWriteTaggedBatchRawV2Args) IsSetReq() bool { return p.Req != nil } -func (p *NodeWriteBatchRawV2Args) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawV2Args) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20010,16 +21318,16 @@ func (p *NodeWriteBatchRawV2Args) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteBatchRawV2Request{} +func (p *NodeWriteTaggedBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { + p.Req = &WriteTaggedBatchRawV2Request{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeWriteBatchRawV2Args) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeBatchRawV2_args"); err != nil { +func (p *NodeWriteTaggedBatchRawV2Args) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTaggedBatchRawV2_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20036,7 +21344,7 @@ func (p *NodeWriteBatchRawV2Args) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedBatchRawV2Args) 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) } @@ -20049,36 +21357,36 @@ func (p *NodeWriteBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err error return err } -func (p *NodeWriteBatchRawV2Args) String() string { +func (p *NodeWriteTaggedBatchRawV2Args) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteBatchRawV2Args(%+v)", *p) + return fmt.Sprintf("NodeWriteTaggedBatchRawV2Args(%+v)", *p) } // Attributes: // - Err -type NodeWriteBatchRawV2Result struct { +type NodeWriteTaggedBatchRawV2Result struct { Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteBatchRawV2Result() *NodeWriteBatchRawV2Result { - return &NodeWriteBatchRawV2Result{} +func NewNodeWriteTaggedBatchRawV2Result() *NodeWriteTaggedBatchRawV2Result { + return &NodeWriteTaggedBatchRawV2Result{} } -var NodeWriteBatchRawV2Result_Err_DEFAULT *WriteBatchRawErrors +var NodeWriteTaggedBatchRawV2Result_Err_DEFAULT *WriteBatchRawErrors -func (p *NodeWriteBatchRawV2Result) GetErr() *WriteBatchRawErrors { +func (p *NodeWriteTaggedBatchRawV2Result) GetErr() *WriteBatchRawErrors { if !p.IsSetErr() { - return NodeWriteBatchRawV2Result_Err_DEFAULT + return NodeWriteTaggedBatchRawV2Result_Err_DEFAULT } return p.Err } -func (p *NodeWriteBatchRawV2Result) IsSetErr() bool { +func (p *NodeWriteTaggedBatchRawV2Result) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteBatchRawV2Result) Read(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawV2Result) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20111,7 +21419,7 @@ func (p *NodeWriteBatchRawV2Result) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeWriteTaggedBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { p.Err = &WriteBatchRawErrors{} if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) @@ -20119,8 +21427,8 @@ func (p *NodeWriteBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawV2Result) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeBatchRawV2_result"); err != nil { +func (p *NodeWriteTaggedBatchRawV2Result) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("writeTaggedBatchRawV2_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20137,7 +21445,7 @@ func (p *NodeWriteBatchRawV2Result) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteBatchRawV2Result) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeWriteTaggedBatchRawV2Result) 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) @@ -20152,36 +21460,21 @@ func (p *NodeWriteBatchRawV2Result) writeField1(oprot thrift.TProtocol) (err err return err } -func (p *NodeWriteBatchRawV2Result) String() string { +func (p *NodeWriteTaggedBatchRawV2Result) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteBatchRawV2Result(%+v)", *p) -} - -// Attributes: -// - Req -type NodeWriteTaggedBatchRawArgs struct { - Req *WriteTaggedBatchRawRequest `thrift:"req,1" db:"req" json:"req"` + return fmt.Sprintf("NodeWriteTaggedBatchRawV2Result(%+v)", *p) } -func NewNodeWriteTaggedBatchRawArgs() *NodeWriteTaggedBatchRawArgs { - return &NodeWriteTaggedBatchRawArgs{} +type NodeRepairArgs struct { } -var NodeWriteTaggedBatchRawArgs_Req_DEFAULT *WriteTaggedBatchRawRequest - -func (p *NodeWriteTaggedBatchRawArgs) GetReq() *WriteTaggedBatchRawRequest { - if !p.IsSetReq() { - return NodeWriteTaggedBatchRawArgs_Req_DEFAULT - } - return p.Req -} -func (p *NodeWriteTaggedBatchRawArgs) IsSetReq() bool { - return p.Req != nil +func NewNodeRepairArgs() *NodeRepairArgs { + return &NodeRepairArgs{} } -func (p *NodeWriteTaggedBatchRawArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeRepairArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20194,15 +21487,8 @@ func (p *NodeWriteTaggedBatchRawArgs) Read(iprot thrift.TProtocol) error { 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.Skip(fieldTypeId); err != nil { + return err } if err := iprot.ReadFieldEnd(); err != nil { return err @@ -20214,22 +21500,11 @@ func (p *NodeWriteTaggedBatchRawArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteTaggedBatchRawRequest{} - if err := p.Req.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) - } - return nil -} - -func (p *NodeWriteTaggedBatchRawArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTaggedBatchRaw_args"); err != nil { +func (p *NodeRepairArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("repair_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField1(oprot); err != nil { - return err - } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) @@ -20240,49 +21515,36 @@ func (p *NodeWriteTaggedBatchRawArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawArgs) 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 *NodeWriteTaggedBatchRawArgs) String() string { +func (p *NodeRepairArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedBatchRawArgs(%+v)", *p) + return fmt.Sprintf("NodeRepairArgs(%+v)", *p) } // Attributes: // - Err -type NodeWriteTaggedBatchRawResult struct { - Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeRepairResult struct { + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteTaggedBatchRawResult() *NodeWriteTaggedBatchRawResult { - return &NodeWriteTaggedBatchRawResult{} +func NewNodeRepairResult() *NodeRepairResult { + return &NodeRepairResult{} } -var NodeWriteTaggedBatchRawResult_Err_DEFAULT *WriteBatchRawErrors +var NodeRepairResult_Err_DEFAULT *Error -func (p *NodeWriteTaggedBatchRawResult) GetErr() *WriteBatchRawErrors { +func (p *NodeRepairResult) GetErr() *Error { if !p.IsSetErr() { - return NodeWriteTaggedBatchRawResult_Err_DEFAULT + return NodeRepairResult_Err_DEFAULT } return p.Err } -func (p *NodeWriteTaggedBatchRawResult) IsSetErr() bool { +func (p *NodeRepairResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteTaggedBatchRawResult) Read(iprot thrift.TProtocol) error { +func (p *NodeRepairResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20315,16 +21577,18 @@ func (p *NodeWriteTaggedBatchRawResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawResult) ReadField1(iprot thrift.TProtocol) error { - p.Err = &WriteBatchRawErrors{} +func (p *NodeRepairResult) ReadField1(iprot thrift.TProtocol) error { + p.Err = &Error{ + Type: 0, + } if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) } return nil } -func (p *NodeWriteTaggedBatchRawResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTaggedBatchRaw_result"); err != nil { +func (p *NodeRepairResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("repair_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20341,7 +21605,7 @@ func (p *NodeWriteTaggedBatchRawResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeRepairResult) 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) @@ -20356,36 +21620,36 @@ func (p *NodeWriteTaggedBatchRawResult) writeField1(oprot thrift.TProtocol) (err return err } -func (p *NodeWriteTaggedBatchRawResult) String() string { +func (p *NodeRepairResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedBatchRawResult(%+v)", *p) + return fmt.Sprintf("NodeRepairResult(%+v)", *p) } // Attributes: // - Req -type NodeWriteTaggedBatchRawV2Args struct { - Req *WriteTaggedBatchRawV2Request `thrift:"req,1" db:"req" json:"req"` +type NodeTruncateArgs struct { + Req *TruncateRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeWriteTaggedBatchRawV2Args() *NodeWriteTaggedBatchRawV2Args { - return &NodeWriteTaggedBatchRawV2Args{} +func NewNodeTruncateArgs() *NodeTruncateArgs { + return &NodeTruncateArgs{} } -var NodeWriteTaggedBatchRawV2Args_Req_DEFAULT *WriteTaggedBatchRawV2Request +var NodeTruncateArgs_Req_DEFAULT *TruncateRequest -func (p *NodeWriteTaggedBatchRawV2Args) GetReq() *WriteTaggedBatchRawV2Request { +func (p *NodeTruncateArgs) GetReq() *TruncateRequest { if !p.IsSetReq() { - return NodeWriteTaggedBatchRawV2Args_Req_DEFAULT + return NodeTruncateArgs_Req_DEFAULT } return p.Req } -func (p *NodeWriteTaggedBatchRawV2Args) IsSetReq() bool { +func (p *NodeTruncateArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeWriteTaggedBatchRawV2Args) Read(iprot thrift.TProtocol) error { +func (p *NodeTruncateArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20418,16 +21682,16 @@ func (p *NodeWriteTaggedBatchRawV2Args) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawV2Args) ReadField1(iprot thrift.TProtocol) error { - p.Req = &WriteTaggedBatchRawV2Request{} +func (p *NodeTruncateArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &TruncateRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeWriteTaggedBatchRawV2Args) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTaggedBatchRawV2_args"); err != nil { +func (p *NodeTruncateArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("truncate_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20444,7 +21708,7 @@ func (p *NodeWriteTaggedBatchRawV2Args) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeTruncateArgs) 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) } @@ -20457,36 +21721,51 @@ func (p *NodeWriteTaggedBatchRawV2Args) writeField1(oprot thrift.TProtocol) (err return err } -func (p *NodeWriteTaggedBatchRawV2Args) String() string { +func (p *NodeTruncateArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedBatchRawV2Args(%+v)", *p) + return fmt.Sprintf("NodeTruncateArgs(%+v)", *p) } // Attributes: +// - Success // - Err -type NodeWriteTaggedBatchRawV2Result struct { - Err *WriteBatchRawErrors `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeTruncateResult struct { + Success *TruncateResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeWriteTaggedBatchRawV2Result() *NodeWriteTaggedBatchRawV2Result { - return &NodeWriteTaggedBatchRawV2Result{} +func NewNodeTruncateResult() *NodeTruncateResult { + return &NodeTruncateResult{} } -var NodeWriteTaggedBatchRawV2Result_Err_DEFAULT *WriteBatchRawErrors +var NodeTruncateResult_Success_DEFAULT *TruncateResult_ -func (p *NodeWriteTaggedBatchRawV2Result) GetErr() *WriteBatchRawErrors { +func (p *NodeTruncateResult) GetSuccess() *TruncateResult_ { + if !p.IsSetSuccess() { + return NodeTruncateResult_Success_DEFAULT + } + return p.Success +} + +var NodeTruncateResult_Err_DEFAULT *Error + +func (p *NodeTruncateResult) GetErr() *Error { if !p.IsSetErr() { - return NodeWriteTaggedBatchRawV2Result_Err_DEFAULT + return NodeTruncateResult_Err_DEFAULT } return p.Err } -func (p *NodeWriteTaggedBatchRawV2Result) IsSetErr() bool { +func (p *NodeTruncateResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeTruncateResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeWriteTaggedBatchRawV2Result) Read(iprot thrift.TProtocol) error { +func (p *NodeTruncateResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20500,6 +21779,10 @@ func (p *NodeWriteTaggedBatchRawV2Result) Read(iprot thrift.TProtocol) error { 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 @@ -20519,19 +21802,32 @@ func (p *NodeWriteTaggedBatchRawV2Result) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawV2Result) ReadField1(iprot thrift.TProtocol) error { - p.Err = &WriteBatchRawErrors{} +func (p *NodeTruncateResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &TruncateResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil +} + +func (p *NodeTruncateResult) ReadField1(iprot thrift.TProtocol) error { + p.Err = &Error{ + Type: 0, + } if err := p.Err.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err) } return nil } -func (p *NodeWriteTaggedBatchRawV2Result) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("writeTaggedBatchRawV2_result"); err != nil { +func (p *NodeTruncateResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("truncate_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField0(oprot); err != nil { + return err + } if err := p.writeField1(oprot); err != nil { return err } @@ -20545,7 +21841,22 @@ func (p *NodeWriteTaggedBatchRawV2Result) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeWriteTaggedBatchRawV2Result) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeTruncateResult) 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 *NodeTruncateResult) 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) @@ -20560,21 +21871,21 @@ func (p *NodeWriteTaggedBatchRawV2Result) writeField1(oprot thrift.TProtocol) (e return err } -func (p *NodeWriteTaggedBatchRawV2Result) String() string { +func (p *NodeTruncateResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeWriteTaggedBatchRawV2Result(%+v)", *p) + return fmt.Sprintf("NodeTruncateResult(%+v)", *p) } -type NodeRepairArgs struct { +type NodeHealthArgs struct { } -func NewNodeRepairArgs() *NodeRepairArgs { - return &NodeRepairArgs{} +func NewNodeHealthArgs() *NodeHealthArgs { + return &NodeHealthArgs{} } -func (p *NodeRepairArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeHealthArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20600,8 +21911,8 @@ func (p *NodeRepairArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeRepairArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("repair_args"); err != nil { +func (p *NodeHealthArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("health_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20615,36 +21926,51 @@ func (p *NodeRepairArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeRepairArgs) String() string { +func (p *NodeHealthArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeRepairArgs(%+v)", *p) + return fmt.Sprintf("NodeHealthArgs(%+v)", *p) } // Attributes: +// - Success // - Err -type NodeRepairResult struct { - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeHealthResult struct { + Success *NodeHealthResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeRepairResult() *NodeRepairResult { - return &NodeRepairResult{} +func NewNodeHealthResult() *NodeHealthResult { + return &NodeHealthResult{} } -var NodeRepairResult_Err_DEFAULT *Error +var NodeHealthResult_Success_DEFAULT *NodeHealthResult_ -func (p *NodeRepairResult) GetErr() *Error { +func (p *NodeHealthResult) GetSuccess() *NodeHealthResult_ { + if !p.IsSetSuccess() { + return NodeHealthResult_Success_DEFAULT + } + return p.Success +} + +var NodeHealthResult_Err_DEFAULT *Error + +func (p *NodeHealthResult) GetErr() *Error { if !p.IsSetErr() { - return NodeRepairResult_Err_DEFAULT + return NodeHealthResult_Err_DEFAULT } return p.Err } -func (p *NodeRepairResult) IsSetErr() bool { +func (p *NodeHealthResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *NodeHealthResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeRepairResult) Read(iprot thrift.TProtocol) error { +func (p *NodeHealthResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20658,6 +21984,10 @@ func (p *NodeRepairResult) Read(iprot thrift.TProtocol) error { 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 @@ -20677,7 +22007,15 @@ func (p *NodeRepairResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeRepairResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeHealthResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeHealthResult_{} + if err := p.Success.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) + } + return nil +} + +func (p *NodeHealthResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -20687,11 +22025,14 @@ func (p *NodeRepairResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeRepairResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("repair_result"); err != nil { +func (p *NodeHealthResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("health_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField0(oprot); err != nil { + return err + } if err := p.writeField1(oprot); err != nil { return err } @@ -20705,7 +22046,22 @@ func (p *NodeRepairResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeRepairResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeHealthResult) 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 *NodeHealthResult) 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) @@ -20720,36 +22076,21 @@ func (p *NodeRepairResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeRepairResult) String() string { +func (p *NodeHealthResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeRepairResult(%+v)", *p) -} - -// Attributes: -// - Req -type NodeTruncateArgs struct { - Req *TruncateRequest `thrift:"req,1" db:"req" json:"req"` + return fmt.Sprintf("NodeHealthResult(%+v)", *p) } -func NewNodeTruncateArgs() *NodeTruncateArgs { - return &NodeTruncateArgs{} +type NodeBootstrappedArgs struct { } -var NodeTruncateArgs_Req_DEFAULT *TruncateRequest - -func (p *NodeTruncateArgs) GetReq() *TruncateRequest { - if !p.IsSetReq() { - return NodeTruncateArgs_Req_DEFAULT - } - return p.Req -} -func (p *NodeTruncateArgs) IsSetReq() bool { - return p.Req != nil +func NewNodeBootstrappedArgs() *NodeBootstrappedArgs { + return &NodeBootstrappedArgs{} } -func (p *NodeTruncateArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20762,15 +22103,8 @@ func (p *NodeTruncateArgs) Read(iprot thrift.TProtocol) error { 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.Skip(fieldTypeId); err != nil { + return err } if err := iprot.ReadFieldEnd(); err != nil { return err @@ -20782,22 +22116,11 @@ func (p *NodeTruncateArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeTruncateArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &TruncateRequest{} - if err := p.Req.Read(iprot); err != nil { - return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) - } - return nil -} - -func (p *NodeTruncateArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("truncate_args"); err != nil { +func (p *NodeBootstrappedArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("bootstrapped_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { - if err := p.writeField1(oprot); err != nil { - return err - } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) @@ -20808,64 +22131,51 @@ func (p *NodeTruncateArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeTruncateArgs) 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 *NodeTruncateArgs) String() string { +func (p *NodeBootstrappedArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeTruncateArgs(%+v)", *p) + return fmt.Sprintf("NodeBootstrappedArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeTruncateResult struct { - Success *TruncateResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeBootstrappedResult struct { + Success *NodeBootstrappedResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeTruncateResult() *NodeTruncateResult { - return &NodeTruncateResult{} +func NewNodeBootstrappedResult() *NodeBootstrappedResult { + return &NodeBootstrappedResult{} } -var NodeTruncateResult_Success_DEFAULT *TruncateResult_ +var NodeBootstrappedResult_Success_DEFAULT *NodeBootstrappedResult_ -func (p *NodeTruncateResult) GetSuccess() *TruncateResult_ { +func (p *NodeBootstrappedResult) GetSuccess() *NodeBootstrappedResult_ { if !p.IsSetSuccess() { - return NodeTruncateResult_Success_DEFAULT + return NodeBootstrappedResult_Success_DEFAULT } return p.Success } -var NodeTruncateResult_Err_DEFAULT *Error +var NodeBootstrappedResult_Err_DEFAULT *Error -func (p *NodeTruncateResult) GetErr() *Error { +func (p *NodeBootstrappedResult) GetErr() *Error { if !p.IsSetErr() { - return NodeTruncateResult_Err_DEFAULT + return NodeBootstrappedResult_Err_DEFAULT } return p.Err } -func (p *NodeTruncateResult) IsSetSuccess() bool { +func (p *NodeBootstrappedResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeTruncateResult) IsSetErr() bool { +func (p *NodeBootstrappedResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeTruncateResult) Read(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -20902,15 +22212,15 @@ func (p *NodeTruncateResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeTruncateResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &TruncateResult_{} +func (p *NodeBootstrappedResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeBootstrappedResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeTruncateResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -20920,8 +22230,8 @@ func (p *NodeTruncateResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeTruncateResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("truncate_result"); err != nil { +func (p *NodeBootstrappedResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("bootstrapped_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -20941,7 +22251,7 @@ func (p *NodeTruncateResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeTruncateResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeBootstrappedResult) 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) @@ -20956,7 +22266,7 @@ func (p *NodeTruncateResult) writeField0(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeTruncateResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeBootstrappedResult) 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) @@ -20971,21 +22281,21 @@ func (p *NodeTruncateResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeTruncateResult) String() string { +func (p *NodeBootstrappedResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeTruncateResult(%+v)", *p) + return fmt.Sprintf("NodeBootstrappedResult(%+v)", *p) } -type NodeHealthArgs struct { +type NodeBootstrappedInPlacementOrNoPlacementArgs struct { } -func NewNodeHealthArgs() *NodeHealthArgs { - return &NodeHealthArgs{} +func NewNodeBootstrappedInPlacementOrNoPlacementArgs() *NodeBootstrappedInPlacementOrNoPlacementArgs { + return &NodeBootstrappedInPlacementOrNoPlacementArgs{} } -func (p *NodeHealthArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21011,8 +22321,8 @@ func (p *NodeHealthArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeHealthArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("health_args"); err != nil { +func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("bootstrappedInPlacementOrNoPlacement_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21026,51 +22336,51 @@ func (p *NodeHealthArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeHealthArgs) String() string { +func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeHealthArgs(%+v)", *p) + return fmt.Sprintf("NodeBootstrappedInPlacementOrNoPlacementArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeHealthResult struct { - Success *NodeHealthResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeBootstrappedInPlacementOrNoPlacementResult struct { + Success *NodeBootstrappedInPlacementOrNoPlacementResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeHealthResult() *NodeHealthResult { - return &NodeHealthResult{} +func NewNodeBootstrappedInPlacementOrNoPlacementResult() *NodeBootstrappedInPlacementOrNoPlacementResult { + return &NodeBootstrappedInPlacementOrNoPlacementResult{} } -var NodeHealthResult_Success_DEFAULT *NodeHealthResult_ +var NodeBootstrappedInPlacementOrNoPlacementResult_Success_DEFAULT *NodeBootstrappedInPlacementOrNoPlacementResult_ -func (p *NodeHealthResult) GetSuccess() *NodeHealthResult_ { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) GetSuccess() *NodeBootstrappedInPlacementOrNoPlacementResult_ { if !p.IsSetSuccess() { - return NodeHealthResult_Success_DEFAULT + return NodeBootstrappedInPlacementOrNoPlacementResult_Success_DEFAULT } return p.Success } -var NodeHealthResult_Err_DEFAULT *Error +var NodeBootstrappedInPlacementOrNoPlacementResult_Err_DEFAULT *Error -func (p *NodeHealthResult) GetErr() *Error { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) GetErr() *Error { if !p.IsSetErr() { - return NodeHealthResult_Err_DEFAULT + return NodeBootstrappedInPlacementOrNoPlacementResult_Err_DEFAULT } return p.Err } -func (p *NodeHealthResult) IsSetSuccess() bool { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeHealthResult) IsSetErr() bool { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeHealthResult) Read(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21107,15 +22417,15 @@ func (p *NodeHealthResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeHealthResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeHealthResult_{} +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeBootstrappedInPlacementOrNoPlacementResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeHealthResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -21125,8 +22435,8 @@ func (p *NodeHealthResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeHealthResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("health_result"); err != nil { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("bootstrappedInPlacementOrNoPlacement_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21146,7 +22456,7 @@ func (p *NodeHealthResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeHealthResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) 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) @@ -21161,7 +22471,7 @@ func (p *NodeHealthResult) writeField0(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeHealthResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) 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) @@ -21176,21 +22486,21 @@ func (p *NodeHealthResult) writeField1(oprot thrift.TProtocol) (err error) { return err } -func (p *NodeHealthResult) String() string { +func (p *NodeBootstrappedInPlacementOrNoPlacementResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeHealthResult(%+v)", *p) + return fmt.Sprintf("NodeBootstrappedInPlacementOrNoPlacementResult(%+v)", *p) } -type NodeBootstrappedArgs struct { +type NodeGetPersistRateLimitArgs struct { } -func NewNodeBootstrappedArgs() *NodeBootstrappedArgs { - return &NodeBootstrappedArgs{} +func NewNodeGetPersistRateLimitArgs() *NodeGetPersistRateLimitArgs { + return &NodeGetPersistRateLimitArgs{} } -func (p *NodeBootstrappedArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeGetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21216,8 +22526,8 @@ func (p *NodeBootstrappedArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeBootstrappedArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("bootstrapped_args"); err != nil { +func (p *NodeGetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getPersistRateLimit_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21231,51 +22541,51 @@ func (p *NodeBootstrappedArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeBootstrappedArgs) String() string { +func (p *NodeGetPersistRateLimitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeBootstrappedArgs(%+v)", *p) + return fmt.Sprintf("NodeGetPersistRateLimitArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeBootstrappedResult struct { - Success *NodeBootstrappedResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeGetPersistRateLimitResult struct { + Success *NodePersistRateLimitResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeBootstrappedResult() *NodeBootstrappedResult { - return &NodeBootstrappedResult{} +func NewNodeGetPersistRateLimitResult() *NodeGetPersistRateLimitResult { + return &NodeGetPersistRateLimitResult{} } -var NodeBootstrappedResult_Success_DEFAULT *NodeBootstrappedResult_ +var NodeGetPersistRateLimitResult_Success_DEFAULT *NodePersistRateLimitResult_ -func (p *NodeBootstrappedResult) GetSuccess() *NodeBootstrappedResult_ { +func (p *NodeGetPersistRateLimitResult) GetSuccess() *NodePersistRateLimitResult_ { if !p.IsSetSuccess() { - return NodeBootstrappedResult_Success_DEFAULT + return NodeGetPersistRateLimitResult_Success_DEFAULT } return p.Success } -var NodeBootstrappedResult_Err_DEFAULT *Error +var NodeGetPersistRateLimitResult_Err_DEFAULT *Error -func (p *NodeBootstrappedResult) GetErr() *Error { +func (p *NodeGetPersistRateLimitResult) GetErr() *Error { if !p.IsSetErr() { - return NodeBootstrappedResult_Err_DEFAULT + return NodeGetPersistRateLimitResult_Err_DEFAULT } return p.Err } -func (p *NodeBootstrappedResult) IsSetSuccess() bool { +func (p *NodeGetPersistRateLimitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeBootstrappedResult) IsSetErr() bool { +func (p *NodeGetPersistRateLimitResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeBootstrappedResult) Read(iprot thrift.TProtocol) error { +func (p *NodeGetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21312,15 +22622,15 @@ func (p *NodeBootstrappedResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeBootstrappedResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeBootstrappedResult_{} +func (p *NodeGetPersistRateLimitResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodePersistRateLimitResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeBootstrappedResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeGetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -21330,8 +22640,8 @@ func (p *NodeBootstrappedResult) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *NodeBootstrappedResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("bootstrapped_result"); err != nil { +func (p *NodeGetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getPersistRateLimit_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21351,7 +22661,7 @@ func (p *NodeBootstrappedResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeBootstrappedResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeGetPersistRateLimitResult) 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) @@ -21366,7 +22676,7 @@ func (p *NodeBootstrappedResult) writeField0(oprot thrift.TProtocol) (err error) return err } -func (p *NodeBootstrappedResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeGetPersistRateLimitResult) 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) @@ -21381,21 +22691,36 @@ func (p *NodeBootstrappedResult) writeField1(oprot thrift.TProtocol) (err error) return err } -func (p *NodeBootstrappedResult) String() string { +func (p *NodeGetPersistRateLimitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeBootstrappedResult(%+v)", *p) + return fmt.Sprintf("NodeGetPersistRateLimitResult(%+v)", *p) } -type NodeBootstrappedInPlacementOrNoPlacementArgs struct { +// Attributes: +// - Req +type NodeSetPersistRateLimitArgs struct { + Req *NodeSetPersistRateLimitRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeBootstrappedInPlacementOrNoPlacementArgs() *NodeBootstrappedInPlacementOrNoPlacementArgs { - return &NodeBootstrappedInPlacementOrNoPlacementArgs{} +func NewNodeSetPersistRateLimitArgs() *NodeSetPersistRateLimitArgs { + return &NodeSetPersistRateLimitArgs{} } -func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Read(iprot thrift.TProtocol) error { +var NodeSetPersistRateLimitArgs_Req_DEFAULT *NodeSetPersistRateLimitRequest + +func (p *NodeSetPersistRateLimitArgs) GetReq() *NodeSetPersistRateLimitRequest { + if !p.IsSetReq() { + return NodeSetPersistRateLimitArgs_Req_DEFAULT + } + return p.Req +} +func (p *NodeSetPersistRateLimitArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *NodeSetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21408,8 +22733,15 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Read(iprot thrift.TProtoc if fieldTypeId == thrift.STOP { break } - if err := iprot.Skip(fieldTypeId); err != nil { - return err + 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 @@ -21421,11 +22753,22 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Read(iprot thrift.TProtoc return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("bootstrappedInPlacementOrNoPlacement_args"); err != nil { +func (p *NodeSetPersistRateLimitArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &NodeSetPersistRateLimitRequest{} + if err := p.Req.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) + } + return nil +} + +func (p *NodeSetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setPersistRateLimit_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField1(oprot); err != nil { + return err + } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) @@ -21436,51 +22779,64 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) Write(oprot thrift.TProto return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementArgs) String() string { +func (p *NodeSetPersistRateLimitArgs) 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 *NodeSetPersistRateLimitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeBootstrappedInPlacementOrNoPlacementArgs(%+v)", *p) + return fmt.Sprintf("NodeSetPersistRateLimitArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeBootstrappedInPlacementOrNoPlacementResult struct { - Success *NodeBootstrappedInPlacementOrNoPlacementResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeSetPersistRateLimitResult struct { + Success *NodePersistRateLimitResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeBootstrappedInPlacementOrNoPlacementResult() *NodeBootstrappedInPlacementOrNoPlacementResult { - return &NodeBootstrappedInPlacementOrNoPlacementResult{} +func NewNodeSetPersistRateLimitResult() *NodeSetPersistRateLimitResult { + return &NodeSetPersistRateLimitResult{} } -var NodeBootstrappedInPlacementOrNoPlacementResult_Success_DEFAULT *NodeBootstrappedInPlacementOrNoPlacementResult_ +var NodeSetPersistRateLimitResult_Success_DEFAULT *NodePersistRateLimitResult_ -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) GetSuccess() *NodeBootstrappedInPlacementOrNoPlacementResult_ { +func (p *NodeSetPersistRateLimitResult) GetSuccess() *NodePersistRateLimitResult_ { if !p.IsSetSuccess() { - return NodeBootstrappedInPlacementOrNoPlacementResult_Success_DEFAULT + return NodeSetPersistRateLimitResult_Success_DEFAULT } return p.Success } -var NodeBootstrappedInPlacementOrNoPlacementResult_Err_DEFAULT *Error +var NodeSetPersistRateLimitResult_Err_DEFAULT *Error -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) GetErr() *Error { +func (p *NodeSetPersistRateLimitResult) GetErr() *Error { if !p.IsSetErr() { - return NodeBootstrappedInPlacementOrNoPlacementResult_Err_DEFAULT + return NodeSetPersistRateLimitResult_Err_DEFAULT } return p.Err } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) IsSetSuccess() bool { +func (p *NodeSetPersistRateLimitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) IsSetErr() bool { +func (p *NodeSetPersistRateLimitResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Read(iprot thrift.TProtocol) error { +func (p *NodeSetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21517,15 +22873,15 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Read(iprot thrift.TProt return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeBootstrappedInPlacementOrNoPlacementResult_{} +func (p *NodeSetPersistRateLimitResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodePersistRateLimitResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeSetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -21535,8 +22891,8 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementResult) ReadField1(iprot thrift return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("bootstrappedInPlacementOrNoPlacement_result"); err != nil { +func (p *NodeSetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setPersistRateLimit_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21556,7 +22912,7 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementResult) Write(oprot thrift.TPro return nil } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeSetPersistRateLimitResult) 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) @@ -21571,7 +22927,7 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementResult) writeField0(oprot thrif return err } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetPersistRateLimitResult) 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) @@ -21586,21 +22942,21 @@ func (p *NodeBootstrappedInPlacementOrNoPlacementResult) writeField1(oprot thrif return err } -func (p *NodeBootstrappedInPlacementOrNoPlacementResult) String() string { +func (p *NodeSetPersistRateLimitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeBootstrappedInPlacementOrNoPlacementResult(%+v)", *p) + return fmt.Sprintf("NodeSetPersistRateLimitResult(%+v)", *p) } -type NodeGetPersistRateLimitArgs struct { +type NodeGetWriteNewSeriesAsyncArgs struct { } -func NewNodeGetPersistRateLimitArgs() *NodeGetPersistRateLimitArgs { - return &NodeGetPersistRateLimitArgs{} +func NewNodeGetWriteNewSeriesAsyncArgs() *NodeGetWriteNewSeriesAsyncArgs { + return &NodeGetWriteNewSeriesAsyncArgs{} } -func (p *NodeGetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21626,8 +22982,8 @@ func (p *NodeGetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeGetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getPersistRateLimit_args"); err != nil { +func (p *NodeGetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesAsync_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21641,51 +22997,51 @@ func (p *NodeGetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeGetPersistRateLimitArgs) String() string { +func (p *NodeGetWriteNewSeriesAsyncArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetPersistRateLimitArgs(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesAsyncArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeGetPersistRateLimitResult struct { - Success *NodePersistRateLimitResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeGetWriteNewSeriesAsyncResult struct { + Success *NodeWriteNewSeriesAsyncResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeGetPersistRateLimitResult() *NodeGetPersistRateLimitResult { - return &NodeGetPersistRateLimitResult{} +func NewNodeGetWriteNewSeriesAsyncResult() *NodeGetWriteNewSeriesAsyncResult { + return &NodeGetWriteNewSeriesAsyncResult{} } -var NodeGetPersistRateLimitResult_Success_DEFAULT *NodePersistRateLimitResult_ +var NodeGetWriteNewSeriesAsyncResult_Success_DEFAULT *NodeWriteNewSeriesAsyncResult_ -func (p *NodeGetPersistRateLimitResult) GetSuccess() *NodePersistRateLimitResult_ { +func (p *NodeGetWriteNewSeriesAsyncResult) GetSuccess() *NodeWriteNewSeriesAsyncResult_ { if !p.IsSetSuccess() { - return NodeGetPersistRateLimitResult_Success_DEFAULT + return NodeGetWriteNewSeriesAsyncResult_Success_DEFAULT } return p.Success } -var NodeGetPersistRateLimitResult_Err_DEFAULT *Error +var NodeGetWriteNewSeriesAsyncResult_Err_DEFAULT *Error -func (p *NodeGetPersistRateLimitResult) GetErr() *Error { +func (p *NodeGetWriteNewSeriesAsyncResult) GetErr() *Error { if !p.IsSetErr() { - return NodeGetPersistRateLimitResult_Err_DEFAULT + return NodeGetWriteNewSeriesAsyncResult_Err_DEFAULT } return p.Err } -func (p *NodeGetPersistRateLimitResult) IsSetSuccess() bool { +func (p *NodeGetWriteNewSeriesAsyncResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeGetPersistRateLimitResult) IsSetErr() bool { +func (p *NodeGetWriteNewSeriesAsyncResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeGetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21722,15 +23078,15 @@ func (p *NodeGetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeGetPersistRateLimitResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodePersistRateLimitResult_{} +func (p *NodeGetWriteNewSeriesAsyncResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesAsyncResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeGetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -21740,8 +23096,8 @@ func (p *NodeGetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *NodeGetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getPersistRateLimit_result"); err != nil { +func (p *NodeGetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesAsync_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21761,7 +23117,7 @@ func (p *NodeGetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeGetPersistRateLimitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesAsyncResult) 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) @@ -21776,7 +23132,7 @@ func (p *NodeGetPersistRateLimitResult) writeField0(oprot thrift.TProtocol) (err return err } -func (p *NodeGetPersistRateLimitResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesAsyncResult) 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) @@ -21791,36 +23147,36 @@ func (p *NodeGetPersistRateLimitResult) writeField1(oprot thrift.TProtocol) (err return err } -func (p *NodeGetPersistRateLimitResult) String() string { +func (p *NodeGetWriteNewSeriesAsyncResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetPersistRateLimitResult(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesAsyncResult(%+v)", *p) } // Attributes: // - Req -type NodeSetPersistRateLimitArgs struct { - Req *NodeSetPersistRateLimitRequest `thrift:"req,1" db:"req" json:"req"` +type NodeSetWriteNewSeriesAsyncArgs struct { + Req *NodeSetWriteNewSeriesAsyncRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeSetPersistRateLimitArgs() *NodeSetPersistRateLimitArgs { - return &NodeSetPersistRateLimitArgs{} +func NewNodeSetWriteNewSeriesAsyncArgs() *NodeSetWriteNewSeriesAsyncArgs { + return &NodeSetWriteNewSeriesAsyncArgs{} } -var NodeSetPersistRateLimitArgs_Req_DEFAULT *NodeSetPersistRateLimitRequest +var NodeSetWriteNewSeriesAsyncArgs_Req_DEFAULT *NodeSetWriteNewSeriesAsyncRequest -func (p *NodeSetPersistRateLimitArgs) GetReq() *NodeSetPersistRateLimitRequest { +func (p *NodeSetWriteNewSeriesAsyncArgs) GetReq() *NodeSetWriteNewSeriesAsyncRequest { if !p.IsSetReq() { - return NodeSetPersistRateLimitArgs_Req_DEFAULT + return NodeSetWriteNewSeriesAsyncArgs_Req_DEFAULT } return p.Req } -func (p *NodeSetPersistRateLimitArgs) IsSetReq() bool { +func (p *NodeSetWriteNewSeriesAsyncArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeSetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21853,16 +23209,16 @@ func (p *NodeSetPersistRateLimitArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeSetPersistRateLimitArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &NodeSetPersistRateLimitRequest{} +func (p *NodeSetWriteNewSeriesAsyncArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &NodeSetWriteNewSeriesAsyncRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeSetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setPersistRateLimit_args"); err != nil { +func (p *NodeSetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesAsync_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -21879,7 +23235,7 @@ func (p *NodeSetPersistRateLimitArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeSetPersistRateLimitArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesAsyncArgs) 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) } @@ -21892,51 +23248,51 @@ func (p *NodeSetPersistRateLimitArgs) writeField1(oprot thrift.TProtocol) (err e return err } -func (p *NodeSetPersistRateLimitArgs) String() string { +func (p *NodeSetWriteNewSeriesAsyncArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetPersistRateLimitArgs(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesAsyncArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeSetPersistRateLimitResult struct { - Success *NodePersistRateLimitResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeSetWriteNewSeriesAsyncResult struct { + Success *NodeWriteNewSeriesAsyncResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeSetPersistRateLimitResult() *NodeSetPersistRateLimitResult { - return &NodeSetPersistRateLimitResult{} +func NewNodeSetWriteNewSeriesAsyncResult() *NodeSetWriteNewSeriesAsyncResult { + return &NodeSetWriteNewSeriesAsyncResult{} } -var NodeSetPersistRateLimitResult_Success_DEFAULT *NodePersistRateLimitResult_ +var NodeSetWriteNewSeriesAsyncResult_Success_DEFAULT *NodeWriteNewSeriesAsyncResult_ -func (p *NodeSetPersistRateLimitResult) GetSuccess() *NodePersistRateLimitResult_ { +func (p *NodeSetWriteNewSeriesAsyncResult) GetSuccess() *NodeWriteNewSeriesAsyncResult_ { if !p.IsSetSuccess() { - return NodeSetPersistRateLimitResult_Success_DEFAULT + return NodeSetWriteNewSeriesAsyncResult_Success_DEFAULT } return p.Success } -var NodeSetPersistRateLimitResult_Err_DEFAULT *Error +var NodeSetWriteNewSeriesAsyncResult_Err_DEFAULT *Error -func (p *NodeSetPersistRateLimitResult) GetErr() *Error { +func (p *NodeSetWriteNewSeriesAsyncResult) GetErr() *Error { if !p.IsSetErr() { - return NodeSetPersistRateLimitResult_Err_DEFAULT + return NodeSetWriteNewSeriesAsyncResult_Err_DEFAULT } return p.Err } -func (p *NodeSetPersistRateLimitResult) IsSetSuccess() bool { +func (p *NodeSetWriteNewSeriesAsyncResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeSetPersistRateLimitResult) IsSetErr() bool { +func (p *NodeSetWriteNewSeriesAsyncResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeSetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -21973,15 +23329,15 @@ func (p *NodeSetPersistRateLimitResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeSetPersistRateLimitResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodePersistRateLimitResult_{} +func (p *NodeSetWriteNewSeriesAsyncResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesAsyncResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeSetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -21991,8 +23347,8 @@ func (p *NodeSetPersistRateLimitResult) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *NodeSetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setPersistRateLimit_result"); err != nil { +func (p *NodeSetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesAsync_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22012,7 +23368,7 @@ func (p *NodeSetPersistRateLimitResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeSetPersistRateLimitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesAsyncResult) 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) @@ -22027,7 +23383,7 @@ func (p *NodeSetPersistRateLimitResult) writeField0(oprot thrift.TProtocol) (err return err } -func (p *NodeSetPersistRateLimitResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesAsyncResult) 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) @@ -22042,21 +23398,21 @@ func (p *NodeSetPersistRateLimitResult) writeField1(oprot thrift.TProtocol) (err return err } -func (p *NodeSetPersistRateLimitResult) String() string { +func (p *NodeSetWriteNewSeriesAsyncResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetPersistRateLimitResult(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesAsyncResult(%+v)", *p) } -type NodeGetWriteNewSeriesAsyncArgs struct { +type NodeGetWriteNewSeriesBackoffDurationArgs struct { } -func NewNodeGetWriteNewSeriesAsyncArgs() *NodeGetWriteNewSeriesAsyncArgs { - return &NodeGetWriteNewSeriesAsyncArgs{} +func NewNodeGetWriteNewSeriesBackoffDurationArgs() *NodeGetWriteNewSeriesBackoffDurationArgs { + return &NodeGetWriteNewSeriesBackoffDurationArgs{} } -func (p *NodeGetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22082,8 +23438,8 @@ func (p *NodeGetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeGetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesAsync_args"); err != nil { +func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesBackoffDuration_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22097,51 +23453,51 @@ func (p *NodeGetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeGetWriteNewSeriesAsyncArgs) String() string { +func (p *NodeGetWriteNewSeriesBackoffDurationArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesAsyncArgs(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesBackoffDurationArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeGetWriteNewSeriesAsyncResult struct { - Success *NodeWriteNewSeriesAsyncResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeGetWriteNewSeriesBackoffDurationResult struct { + Success *NodeWriteNewSeriesBackoffDurationResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeGetWriteNewSeriesAsyncResult() *NodeGetWriteNewSeriesAsyncResult { - return &NodeGetWriteNewSeriesAsyncResult{} +func NewNodeGetWriteNewSeriesBackoffDurationResult() *NodeGetWriteNewSeriesBackoffDurationResult { + return &NodeGetWriteNewSeriesBackoffDurationResult{} } -var NodeGetWriteNewSeriesAsyncResult_Success_DEFAULT *NodeWriteNewSeriesAsyncResult_ +var NodeGetWriteNewSeriesBackoffDurationResult_Success_DEFAULT *NodeWriteNewSeriesBackoffDurationResult_ -func (p *NodeGetWriteNewSeriesAsyncResult) GetSuccess() *NodeWriteNewSeriesAsyncResult_ { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) GetSuccess() *NodeWriteNewSeriesBackoffDurationResult_ { if !p.IsSetSuccess() { - return NodeGetWriteNewSeriesAsyncResult_Success_DEFAULT + return NodeGetWriteNewSeriesBackoffDurationResult_Success_DEFAULT } return p.Success } -var NodeGetWriteNewSeriesAsyncResult_Err_DEFAULT *Error +var NodeGetWriteNewSeriesBackoffDurationResult_Err_DEFAULT *Error -func (p *NodeGetWriteNewSeriesAsyncResult) GetErr() *Error { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) GetErr() *Error { if !p.IsSetErr() { - return NodeGetWriteNewSeriesAsyncResult_Err_DEFAULT + return NodeGetWriteNewSeriesBackoffDurationResult_Err_DEFAULT } return p.Err } -func (p *NodeGetWriteNewSeriesAsyncResult) IsSetSuccess() bool { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeGetWriteNewSeriesAsyncResult) IsSetErr() bool { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeGetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22178,15 +23534,15 @@ func (p *NodeGetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeGetWriteNewSeriesAsyncResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesAsyncResult_{} +func (p *NodeGetWriteNewSeriesBackoffDurationResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesBackoffDurationResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeGetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -22196,8 +23552,8 @@ func (p *NodeGetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) er return nil } -func (p *NodeGetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesAsync_result"); err != nil { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesBackoffDuration_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22217,7 +23573,7 @@ func (p *NodeGetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeGetWriteNewSeriesAsyncResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) 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) @@ -22232,7 +23588,7 @@ func (p *NodeGetWriteNewSeriesAsyncResult) writeField0(oprot thrift.TProtocol) ( return err } -func (p *NodeGetWriteNewSeriesAsyncResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) 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) @@ -22247,36 +23603,36 @@ func (p *NodeGetWriteNewSeriesAsyncResult) writeField1(oprot thrift.TProtocol) ( return err } -func (p *NodeGetWriteNewSeriesAsyncResult) String() string { +func (p *NodeGetWriteNewSeriesBackoffDurationResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesAsyncResult(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesBackoffDurationResult(%+v)", *p) } // Attributes: // - Req -type NodeSetWriteNewSeriesAsyncArgs struct { - Req *NodeSetWriteNewSeriesAsyncRequest `thrift:"req,1" db:"req" json:"req"` +type NodeSetWriteNewSeriesBackoffDurationArgs struct { + Req *NodeSetWriteNewSeriesBackoffDurationRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeSetWriteNewSeriesAsyncArgs() *NodeSetWriteNewSeriesAsyncArgs { - return &NodeSetWriteNewSeriesAsyncArgs{} +func NewNodeSetWriteNewSeriesBackoffDurationArgs() *NodeSetWriteNewSeriesBackoffDurationArgs { + return &NodeSetWriteNewSeriesBackoffDurationArgs{} } -var NodeSetWriteNewSeriesAsyncArgs_Req_DEFAULT *NodeSetWriteNewSeriesAsyncRequest +var NodeSetWriteNewSeriesBackoffDurationArgs_Req_DEFAULT *NodeSetWriteNewSeriesBackoffDurationRequest -func (p *NodeSetWriteNewSeriesAsyncArgs) GetReq() *NodeSetWriteNewSeriesAsyncRequest { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) GetReq() *NodeSetWriteNewSeriesBackoffDurationRequest { if !p.IsSetReq() { - return NodeSetWriteNewSeriesAsyncArgs_Req_DEFAULT + return NodeSetWriteNewSeriesBackoffDurationArgs_Req_DEFAULT } return p.Req } -func (p *NodeSetWriteNewSeriesAsyncArgs) IsSetReq() bool { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeSetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22309,16 +23665,18 @@ func (p *NodeSetWriteNewSeriesAsyncArgs) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeSetWriteNewSeriesAsyncArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &NodeSetWriteNewSeriesAsyncRequest{} +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &NodeSetWriteNewSeriesBackoffDurationRequest{ + DurationType: 2, + } if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeSetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesAsync_args"); err != nil { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesBackoffDuration_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22335,7 +23693,7 @@ func (p *NodeSetWriteNewSeriesAsyncArgs) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeSetWriteNewSeriesAsyncArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) 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) } @@ -22348,51 +23706,51 @@ func (p *NodeSetWriteNewSeriesAsyncArgs) writeField1(oprot thrift.TProtocol) (er return err } -func (p *NodeSetWriteNewSeriesAsyncArgs) String() string { +func (p *NodeSetWriteNewSeriesBackoffDurationArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesAsyncArgs(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesBackoffDurationArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeSetWriteNewSeriesAsyncResult struct { - Success *NodeWriteNewSeriesAsyncResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeSetWriteNewSeriesBackoffDurationResult struct { + Success *NodeWriteNewSeriesBackoffDurationResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeSetWriteNewSeriesAsyncResult() *NodeSetWriteNewSeriesAsyncResult { - return &NodeSetWriteNewSeriesAsyncResult{} +func NewNodeSetWriteNewSeriesBackoffDurationResult() *NodeSetWriteNewSeriesBackoffDurationResult { + return &NodeSetWriteNewSeriesBackoffDurationResult{} } -var NodeSetWriteNewSeriesAsyncResult_Success_DEFAULT *NodeWriteNewSeriesAsyncResult_ +var NodeSetWriteNewSeriesBackoffDurationResult_Success_DEFAULT *NodeWriteNewSeriesBackoffDurationResult_ -func (p *NodeSetWriteNewSeriesAsyncResult) GetSuccess() *NodeWriteNewSeriesAsyncResult_ { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) GetSuccess() *NodeWriteNewSeriesBackoffDurationResult_ { if !p.IsSetSuccess() { - return NodeSetWriteNewSeriesAsyncResult_Success_DEFAULT + return NodeSetWriteNewSeriesBackoffDurationResult_Success_DEFAULT } return p.Success } -var NodeSetWriteNewSeriesAsyncResult_Err_DEFAULT *Error +var NodeSetWriteNewSeriesBackoffDurationResult_Err_DEFAULT *Error -func (p *NodeSetWriteNewSeriesAsyncResult) GetErr() *Error { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) GetErr() *Error { if !p.IsSetErr() { - return NodeSetWriteNewSeriesAsyncResult_Err_DEFAULT + return NodeSetWriteNewSeriesBackoffDurationResult_Err_DEFAULT } return p.Err } -func (p *NodeSetWriteNewSeriesAsyncResult) IsSetSuccess() bool { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeSetWriteNewSeriesAsyncResult) IsSetErr() bool { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeSetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22429,15 +23787,15 @@ func (p *NodeSetWriteNewSeriesAsyncResult) Read(iprot thrift.TProtocol) error { return nil } -func (p *NodeSetWriteNewSeriesAsyncResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesAsyncResult_{} +func (p *NodeSetWriteNewSeriesBackoffDurationResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesBackoffDurationResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeSetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -22447,8 +23805,8 @@ func (p *NodeSetWriteNewSeriesAsyncResult) ReadField1(iprot thrift.TProtocol) er return nil } -func (p *NodeSetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesAsync_result"); err != nil { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesBackoffDuration_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22468,7 +23826,7 @@ func (p *NodeSetWriteNewSeriesAsyncResult) Write(oprot thrift.TProtocol) error { return nil } -func (p *NodeSetWriteNewSeriesAsyncResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) 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) @@ -22483,7 +23841,7 @@ func (p *NodeSetWriteNewSeriesAsyncResult) writeField0(oprot thrift.TProtocol) ( return err } -func (p *NodeSetWriteNewSeriesAsyncResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) 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) @@ -22498,21 +23856,21 @@ func (p *NodeSetWriteNewSeriesAsyncResult) writeField1(oprot thrift.TProtocol) ( return err } -func (p *NodeSetWriteNewSeriesAsyncResult) String() string { +func (p *NodeSetWriteNewSeriesBackoffDurationResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesAsyncResult(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesBackoffDurationResult(%+v)", *p) } -type NodeGetWriteNewSeriesBackoffDurationArgs struct { +type NodeGetWriteNewSeriesLimitPerShardPerSecondArgs struct { } -func NewNodeGetWriteNewSeriesBackoffDurationArgs() *NodeGetWriteNewSeriesBackoffDurationArgs { - return &NodeGetWriteNewSeriesBackoffDurationArgs{} +func NewNodeGetWriteNewSeriesLimitPerShardPerSecondArgs() *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs { + return &NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} } -func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22538,8 +23896,8 @@ func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesBackoffDuration_args"); err != nil { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesLimitPerShardPerSecond_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22553,51 +23911,51 @@ func (p *NodeGetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationArgs) String() string { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesBackoffDurationArgs(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesLimitPerShardPerSecondArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeGetWriteNewSeriesBackoffDurationResult struct { - Success *NodeWriteNewSeriesBackoffDurationResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeGetWriteNewSeriesLimitPerShardPerSecondResult struct { + Success *NodeWriteNewSeriesLimitPerShardPerSecondResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeGetWriteNewSeriesBackoffDurationResult() *NodeGetWriteNewSeriesBackoffDurationResult { - return &NodeGetWriteNewSeriesBackoffDurationResult{} +func NewNodeGetWriteNewSeriesLimitPerShardPerSecondResult() *NodeGetWriteNewSeriesLimitPerShardPerSecondResult { + return &NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} } -var NodeGetWriteNewSeriesBackoffDurationResult_Success_DEFAULT *NodeWriteNewSeriesBackoffDurationResult_ +var NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT *NodeWriteNewSeriesLimitPerShardPerSecondResult_ -func (p *NodeGetWriteNewSeriesBackoffDurationResult) GetSuccess() *NodeWriteNewSeriesBackoffDurationResult_ { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) GetSuccess() *NodeWriteNewSeriesLimitPerShardPerSecondResult_ { if !p.IsSetSuccess() { - return NodeGetWriteNewSeriesBackoffDurationResult_Success_DEFAULT + return NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT } return p.Success } -var NodeGetWriteNewSeriesBackoffDurationResult_Err_DEFAULT *Error +var NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT *Error -func (p *NodeGetWriteNewSeriesBackoffDurationResult) GetErr() *Error { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) GetErr() *Error { if !p.IsSetErr() { - return NodeGetWriteNewSeriesBackoffDurationResult_Err_DEFAULT + return NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT } return p.Err } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) IsSetSuccess() bool { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) IsSetErr() bool { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22634,15 +23992,15 @@ func (p *NodeGetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesBackoffDurationResult_{} +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesLimitPerShardPerSecondResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -22652,8 +24010,8 @@ func (p *NodeGetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TPr return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesBackoffDuration_result"); err != nil { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("getWriteNewSeriesLimitPerShardPerSecond_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22673,7 +24031,7 @@ func (p *NodeGetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtoco return nil } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) 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) @@ -22688,7 +24046,7 @@ func (p *NodeGetWriteNewSeriesBackoffDurationResult) writeField0(oprot thrift.TP return err } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) 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) @@ -22703,36 +24061,36 @@ func (p *NodeGetWriteNewSeriesBackoffDurationResult) writeField1(oprot thrift.TP return err } -func (p *NodeGetWriteNewSeriesBackoffDurationResult) String() string { +func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesBackoffDurationResult(%+v)", *p) + return fmt.Sprintf("NodeGetWriteNewSeriesLimitPerShardPerSecondResult(%+v)", *p) } // Attributes: // - Req -type NodeSetWriteNewSeriesBackoffDurationArgs struct { - Req *NodeSetWriteNewSeriesBackoffDurationRequest `thrift:"req,1" db:"req" json:"req"` +type NodeSetWriteNewSeriesLimitPerShardPerSecondArgs struct { + Req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeSetWriteNewSeriesBackoffDurationArgs() *NodeSetWriteNewSeriesBackoffDurationArgs { - return &NodeSetWriteNewSeriesBackoffDurationArgs{} +func NewNodeSetWriteNewSeriesLimitPerShardPerSecondArgs() *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs { + return &NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{} } -var NodeSetWriteNewSeriesBackoffDurationArgs_Req_DEFAULT *NodeSetWriteNewSeriesBackoffDurationRequest +var NodeSetWriteNewSeriesLimitPerShardPerSecondArgs_Req_DEFAULT *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) GetReq() *NodeSetWriteNewSeriesBackoffDurationRequest { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) GetReq() *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest { if !p.IsSetReq() { - return NodeSetWriteNewSeriesBackoffDurationArgs_Req_DEFAULT + return NodeSetWriteNewSeriesLimitPerShardPerSecondArgs_Req_DEFAULT } return p.Req } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) IsSetReq() bool { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22765,18 +24123,16 @@ func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Read(iprot thrift.TProtocol) return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &NodeSetWriteNewSeriesBackoffDurationRequest{ - DurationType: 2, - } +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &NodeSetWriteNewSeriesLimitPerShardPerSecondRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesBackoffDuration_args"); err != nil { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesLimitPerShardPerSecond_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22793,7 +24149,7 @@ func (p *NodeSetWriteNewSeriesBackoffDurationArgs) Write(oprot thrift.TProtocol) return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) 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) } @@ -22806,51 +24162,51 @@ func (p *NodeSetWriteNewSeriesBackoffDurationArgs) writeField1(oprot thrift.TPro return err } -func (p *NodeSetWriteNewSeriesBackoffDurationArgs) String() string { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesBackoffDurationArgs(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesLimitPerShardPerSecondArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeSetWriteNewSeriesBackoffDurationResult struct { - Success *NodeWriteNewSeriesBackoffDurationResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeSetWriteNewSeriesLimitPerShardPerSecondResult struct { + Success *NodeWriteNewSeriesLimitPerShardPerSecondResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeSetWriteNewSeriesBackoffDurationResult() *NodeSetWriteNewSeriesBackoffDurationResult { - return &NodeSetWriteNewSeriesBackoffDurationResult{} +func NewNodeSetWriteNewSeriesLimitPerShardPerSecondResult() *NodeSetWriteNewSeriesLimitPerShardPerSecondResult { + return &NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} } -var NodeSetWriteNewSeriesBackoffDurationResult_Success_DEFAULT *NodeWriteNewSeriesBackoffDurationResult_ +var NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT *NodeWriteNewSeriesLimitPerShardPerSecondResult_ -func (p *NodeSetWriteNewSeriesBackoffDurationResult) GetSuccess() *NodeWriteNewSeriesBackoffDurationResult_ { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) GetSuccess() *NodeWriteNewSeriesLimitPerShardPerSecondResult_ { if !p.IsSetSuccess() { - return NodeSetWriteNewSeriesBackoffDurationResult_Success_DEFAULT + return NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT } return p.Success } -var NodeSetWriteNewSeriesBackoffDurationResult_Err_DEFAULT *Error +var NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT *Error -func (p *NodeSetWriteNewSeriesBackoffDurationResult) GetErr() *Error { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) GetErr() *Error { if !p.IsSetErr() { - return NodeSetWriteNewSeriesBackoffDurationResult_Err_DEFAULT + return NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT } return p.Err } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) IsSetSuccess() bool { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) IsSetErr() bool { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22887,15 +24243,15 @@ func (p *NodeSetWriteNewSeriesBackoffDurationResult) Read(iprot thrift.TProtocol return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesBackoffDurationResult_{} +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &NodeWriteNewSeriesLimitPerShardPerSecondResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -22905,8 +24261,8 @@ func (p *NodeSetWriteNewSeriesBackoffDurationResult) ReadField1(iprot thrift.TPr return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesBackoffDuration_result"); err != nil { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("setWriteNewSeriesLimitPerShardPerSecond_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -22926,7 +24282,7 @@ func (p *NodeSetWriteNewSeriesBackoffDurationResult) Write(oprot thrift.TProtoco return nil } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) 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) @@ -22941,7 +24297,7 @@ func (p *NodeSetWriteNewSeriesBackoffDurationResult) writeField0(oprot thrift.TP return err } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) 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) @@ -22956,21 +24312,36 @@ func (p *NodeSetWriteNewSeriesBackoffDurationResult) writeField1(oprot thrift.TP return err } -func (p *NodeSetWriteNewSeriesBackoffDurationResult) String() string { +func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesBackoffDurationResult(%+v)", *p) + return fmt.Sprintf("NodeSetWriteNewSeriesLimitPerShardPerSecondResult(%+v)", *p) } -type NodeGetWriteNewSeriesLimitPerShardPerSecondArgs struct { +// Attributes: +// - Req +type NodeDebugProfileStartArgs struct { + Req *DebugProfileStartRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeGetWriteNewSeriesLimitPerShardPerSecondArgs() *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs { - return &NodeGetWriteNewSeriesLimitPerShardPerSecondArgs{} +func NewNodeDebugProfileStartArgs() *NodeDebugProfileStartArgs { + return &NodeDebugProfileStartArgs{} } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TProtocol) error { +var NodeDebugProfileStartArgs_Req_DEFAULT *DebugProfileStartRequest + +func (p *NodeDebugProfileStartArgs) GetReq() *DebugProfileStartRequest { + if !p.IsSetReq() { + return NodeDebugProfileStartArgs_Req_DEFAULT + } + return p.Req +} +func (p *NodeDebugProfileStartArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *NodeDebugProfileStartArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -22983,8 +24354,15 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TPro if fieldTypeId == thrift.STOP { break } - if err := iprot.Skip(fieldTypeId); err != nil { - return err + 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 @@ -22996,11 +24374,22 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TPro return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesLimitPerShardPerSecond_args"); err != nil { +func (p *NodeDebugProfileStartArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &DebugProfileStartRequest{} + if err := p.Req.Read(iprot); err != nil { + return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) + } + return nil +} + +func (p *NodeDebugProfileStartArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("debugProfileStart_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { + if err := p.writeField1(oprot); err != nil { + return err + } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) @@ -23011,51 +24400,64 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TPr return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondArgs) String() string { +func (p *NodeDebugProfileStartArgs) 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 *NodeDebugProfileStartArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesLimitPerShardPerSecondArgs(%+v)", *p) + return fmt.Sprintf("NodeDebugProfileStartArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeGetWriteNewSeriesLimitPerShardPerSecondResult struct { - Success *NodeWriteNewSeriesLimitPerShardPerSecondResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeDebugProfileStartResult struct { + Success *DebugProfileStartResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeGetWriteNewSeriesLimitPerShardPerSecondResult() *NodeGetWriteNewSeriesLimitPerShardPerSecondResult { - return &NodeGetWriteNewSeriesLimitPerShardPerSecondResult{} +func NewNodeDebugProfileStartResult() *NodeDebugProfileStartResult { + return &NodeDebugProfileStartResult{} } -var NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT *NodeWriteNewSeriesLimitPerShardPerSecondResult_ +var NodeDebugProfileStartResult_Success_DEFAULT *DebugProfileStartResult_ -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) GetSuccess() *NodeWriteNewSeriesLimitPerShardPerSecondResult_ { +func (p *NodeDebugProfileStartResult) GetSuccess() *DebugProfileStartResult_ { if !p.IsSetSuccess() { - return NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT + return NodeDebugProfileStartResult_Success_DEFAULT } return p.Success } -var NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT *Error +var NodeDebugProfileStartResult_Err_DEFAULT *Error -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) GetErr() *Error { +func (p *NodeDebugProfileStartResult) GetErr() *Error { if !p.IsSetErr() { - return NodeGetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT + return NodeDebugProfileStartResult_Err_DEFAULT } return p.Err } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) IsSetSuccess() bool { +func (p *NodeDebugProfileStartResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) IsSetErr() bool { +func (p *NodeDebugProfileStartResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TProtocol) error { +func (p *NodeDebugProfileStartResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -23092,15 +24494,15 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TP return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesLimitPerShardPerSecondResult_{} +func (p *NodeDebugProfileStartResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &DebugProfileStartResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeDebugProfileStartResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -23110,8 +24512,8 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thr return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("getWriteNewSeriesLimitPerShardPerSecond_result"); err != nil { +func (p *NodeDebugProfileStartResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("debugProfileStart_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -23131,7 +24533,7 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.T return nil } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeDebugProfileStartResult) 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) @@ -23146,7 +24548,7 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) writeField0(oprot th return err } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeDebugProfileStartResult) 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) @@ -23161,36 +24563,36 @@ func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) writeField1(oprot th return err } -func (p *NodeGetWriteNewSeriesLimitPerShardPerSecondResult) String() string { +func (p *NodeDebugProfileStartResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeGetWriteNewSeriesLimitPerShardPerSecondResult(%+v)", *p) + return fmt.Sprintf("NodeDebugProfileStartResult(%+v)", *p) } // Attributes: // - Req -type NodeSetWriteNewSeriesLimitPerShardPerSecondArgs struct { - Req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest `thrift:"req,1" db:"req" json:"req"` +type NodeDebugProfileStopArgs struct { + Req *DebugProfileStopRequest `thrift:"req,1" db:"req" json:"req"` } -func NewNodeSetWriteNewSeriesLimitPerShardPerSecondArgs() *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs { - return &NodeSetWriteNewSeriesLimitPerShardPerSecondArgs{} +func NewNodeDebugProfileStopArgs() *NodeDebugProfileStopArgs { + return &NodeDebugProfileStopArgs{} } -var NodeSetWriteNewSeriesLimitPerShardPerSecondArgs_Req_DEFAULT *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest +var NodeDebugProfileStopArgs_Req_DEFAULT *DebugProfileStopRequest -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) GetReq() *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest { +func (p *NodeDebugProfileStopArgs) GetReq() *DebugProfileStopRequest { if !p.IsSetReq() { - return NodeSetWriteNewSeriesLimitPerShardPerSecondArgs_Req_DEFAULT + return NodeDebugProfileStopArgs_Req_DEFAULT } return p.Req } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) IsSetReq() bool { +func (p *NodeDebugProfileStopArgs) IsSetReq() bool { return p.Req != nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TProtocol) error { +func (p *NodeDebugProfileStopArgs) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -23223,16 +24625,16 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Read(iprot thrift.TPro return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = &NodeSetWriteNewSeriesLimitPerShardPerSecondRequest{} +func (p *NodeDebugProfileStopArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = &DebugProfileStopRequest{} if err := p.Req.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Req), err) } return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesLimitPerShardPerSecond_args"); err != nil { +func (p *NodeDebugProfileStopArgs) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("debugProfileStop_args"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -23249,7 +24651,7 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) Write(oprot thrift.TPr return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeDebugProfileStopArgs) 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) } @@ -23262,51 +24664,51 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) writeField1(oprot thri return err } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondArgs) String() string { +func (p *NodeDebugProfileStopArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesLimitPerShardPerSecondArgs(%+v)", *p) + return fmt.Sprintf("NodeDebugProfileStopArgs(%+v)", *p) } // Attributes: // - Success // - Err -type NodeSetWriteNewSeriesLimitPerShardPerSecondResult struct { - Success *NodeWriteNewSeriesLimitPerShardPerSecondResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` - Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` +type NodeDebugProfileStopResult struct { + Success *DebugProfileStopResult_ `thrift:"success,0" db:"success" json:"success,omitempty"` + Err *Error `thrift:"err,1" db:"err" json:"err,omitempty"` } -func NewNodeSetWriteNewSeriesLimitPerShardPerSecondResult() *NodeSetWriteNewSeriesLimitPerShardPerSecondResult { - return &NodeSetWriteNewSeriesLimitPerShardPerSecondResult{} +func NewNodeDebugProfileStopResult() *NodeDebugProfileStopResult { + return &NodeDebugProfileStopResult{} } -var NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT *NodeWriteNewSeriesLimitPerShardPerSecondResult_ +var NodeDebugProfileStopResult_Success_DEFAULT *DebugProfileStopResult_ -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) GetSuccess() *NodeWriteNewSeriesLimitPerShardPerSecondResult_ { +func (p *NodeDebugProfileStopResult) GetSuccess() *DebugProfileStopResult_ { if !p.IsSetSuccess() { - return NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Success_DEFAULT + return NodeDebugProfileStopResult_Success_DEFAULT } return p.Success } -var NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT *Error +var NodeDebugProfileStopResult_Err_DEFAULT *Error -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) GetErr() *Error { +func (p *NodeDebugProfileStopResult) GetErr() *Error { if !p.IsSetErr() { - return NodeSetWriteNewSeriesLimitPerShardPerSecondResult_Err_DEFAULT + return NodeDebugProfileStopResult_Err_DEFAULT } return p.Err } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) IsSetSuccess() bool { +func (p *NodeDebugProfileStopResult) IsSetSuccess() bool { return p.Success != nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) IsSetErr() bool { +func (p *NodeDebugProfileStopResult) IsSetErr() bool { return p.Err != nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TProtocol) error { +func (p *NodeDebugProfileStopResult) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } @@ -23343,15 +24745,15 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Read(iprot thrift.TP return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = &NodeWriteNewSeriesLimitPerShardPerSecondResult_{} +func (p *NodeDebugProfileStopResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = &DebugProfileStopResult_{} if err := p.Success.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err) } return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thrift.TProtocol) error { +func (p *NodeDebugProfileStopResult) ReadField1(iprot thrift.TProtocol) error { p.Err = &Error{ Type: 0, } @@ -23361,8 +24763,8 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) ReadField1(iprot thr return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.TProtocol) error { - if err := oprot.WriteStructBegin("setWriteNewSeriesLimitPerShardPerSecond_result"); err != nil { +func (p *NodeDebugProfileStopResult) Write(oprot thrift.TProtocol) error { + if err := oprot.WriteStructBegin("debugProfileStop_result"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p != nil { @@ -23382,7 +24784,7 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) Write(oprot thrift.T return nil } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *NodeDebugProfileStopResult) 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) @@ -23397,7 +24799,7 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) writeField0(oprot th return err } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) writeField1(oprot thrift.TProtocol) (err error) { +func (p *NodeDebugProfileStopResult) 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) @@ -23412,11 +24814,11 @@ func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) writeField1(oprot th return err } -func (p *NodeSetWriteNewSeriesLimitPerShardPerSecondResult) String() string { +func (p *NodeDebugProfileStopResult) String() string { if p == nil { return "" } - return fmt.Sprintf("NodeSetWriteNewSeriesLimitPerShardPerSecondResult(%+v)", *p) + return fmt.Sprintf("NodeDebugProfileStopResult(%+v)", *p) } // Attributes: @@ -23764,16 +25166,16 @@ func (p *ClusterClient) recvHealth() (value *HealthResult_, err error) { return } if mTypeId == thrift.EXCEPTION { - error221 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error222 error - error222, err = error221.Read(iprot) + error237 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error238 error + error238, err = error237.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error222 + err = error238 return } if mTypeId != thrift.REPLY { @@ -23845,16 +25247,16 @@ func (p *ClusterClient) recvWrite() (err error) { return } if mTypeId == thrift.EXCEPTION { - error223 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error224 error - error224, err = error223.Read(iprot) + error239 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error240 error + error240, err = error239.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error224 + err = error240 return } if mTypeId != thrift.REPLY { @@ -23925,16 +25327,16 @@ func (p *ClusterClient) recvWriteTagged() (err error) { return } if mTypeId == thrift.EXCEPTION { - error225 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error226 error - error226, err = error225.Read(iprot) + error241 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error242 error + error242, err = error241.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error226 + err = error242 return } if mTypeId != thrift.REPLY { @@ -24005,16 +25407,16 @@ func (p *ClusterClient) recvQuery() (value *QueryResult_, err error) { return } if mTypeId == thrift.EXCEPTION { - error227 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error228 error - error228, err = error227.Read(iprot) + error243 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error244 error + error244, err = error243.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error228 + err = error244 return } if mTypeId != thrift.REPLY { @@ -24086,16 +25488,16 @@ func (p *ClusterClient) recvAggregate() (value *AggregateQueryResult_, err error return } if mTypeId == thrift.EXCEPTION { - error229 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error230 error - error230, err = error229.Read(iprot) + error245 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error246 error + error246, err = error245.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error230 + err = error246 return } if mTypeId != thrift.REPLY { @@ -24167,16 +25569,16 @@ func (p *ClusterClient) recvFetch() (value *FetchResult_, err error) { return } if mTypeId == thrift.EXCEPTION { - error231 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error232 error - error232, err = error231.Read(iprot) + error247 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error248 error + error248, err = error247.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error232 + err = error248 return } if mTypeId != thrift.REPLY { @@ -24248,16 +25650,16 @@ func (p *ClusterClient) recvTruncate() (value *TruncateResult_, err error) { return } if mTypeId == thrift.EXCEPTION { - error233 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") - var error234 error - error234, err = error233.Read(iprot) + error249 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception") + var error250 error + error250, err = error249.Read(iprot) if err != nil { return } if err = iprot.ReadMessageEnd(); err != nil { return } - err = error234 + err = error250 return } if mTypeId != thrift.REPLY { @@ -24299,15 +25701,15 @@ func (p *ClusterProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { func NewClusterProcessor(handler Cluster) *ClusterProcessor { - self235 := &ClusterProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} - self235.processorMap["health"] = &clusterProcessorHealth{handler: handler} - self235.processorMap["write"] = &clusterProcessorWrite{handler: handler} - self235.processorMap["writeTagged"] = &clusterProcessorWriteTagged{handler: handler} - self235.processorMap["query"] = &clusterProcessorQuery{handler: handler} - self235.processorMap["aggregate"] = &clusterProcessorAggregate{handler: handler} - self235.processorMap["fetch"] = &clusterProcessorFetch{handler: handler} - self235.processorMap["truncate"] = &clusterProcessorTruncate{handler: handler} - return self235 + self251 := &ClusterProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} + self251.processorMap["health"] = &clusterProcessorHealth{handler: handler} + self251.processorMap["write"] = &clusterProcessorWrite{handler: handler} + self251.processorMap["writeTagged"] = &clusterProcessorWriteTagged{handler: handler} + self251.processorMap["query"] = &clusterProcessorQuery{handler: handler} + self251.processorMap["aggregate"] = &clusterProcessorAggregate{handler: handler} + self251.processorMap["fetch"] = &clusterProcessorFetch{handler: handler} + self251.processorMap["truncate"] = &clusterProcessorTruncate{handler: handler} + return self251 } func (p *ClusterProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { @@ -24320,12 +25722,12 @@ func (p *ClusterProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, } iprot.Skip(thrift.STRUCT) iprot.ReadMessageEnd() - x236 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) + x252 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) - x236.Write(oprot) + x252.Write(oprot) oprot.WriteMessageEnd() oprot.Flush() - return false, x236 + return false, x252 } diff --git a/src/dbnode/generated/thrift/rpc/rpc_mock.go b/src/dbnode/generated/thrift/rpc/rpc_mock.go index ea85aa466a..647e08992b 100644 --- a/src/dbnode/generated/thrift/rpc/rpc_mock.go +++ b/src/dbnode/generated/thrift/rpc/rpc_mock.go @@ -255,6 +255,36 @@ func (mr *MockTChanNodeMockRecorder) DebugIndexMemorySegments(ctx, req interface return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugIndexMemorySegments", reflect.TypeOf((*MockTChanNode)(nil).DebugIndexMemorySegments), ctx, req) } +// DebugProfileStart mocks base method +func (m *MockTChanNode) DebugProfileStart(ctx thrift.Context, req *DebugProfileStartRequest) (*DebugProfileStartResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugProfileStart", ctx, req) + ret0, _ := ret[0].(*DebugProfileStartResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DebugProfileStart indicates an expected call of DebugProfileStart +func (mr *MockTChanNodeMockRecorder) DebugProfileStart(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugProfileStart", reflect.TypeOf((*MockTChanNode)(nil).DebugProfileStart), ctx, req) +} + +// DebugProfileStop mocks base method +func (m *MockTChanNode) DebugProfileStop(ctx thrift.Context, req *DebugProfileStopRequest) (*DebugProfileStopResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugProfileStop", ctx, req) + ret0, _ := ret[0].(*DebugProfileStopResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DebugProfileStop indicates an expected call of DebugProfileStop +func (mr *MockTChanNodeMockRecorder) DebugProfileStop(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugProfileStop", reflect.TypeOf((*MockTChanNode)(nil).DebugProfileStop), ctx, req) +} + // Fetch mocks base method func (m *MockTChanNode) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { m.ctrl.T.Helper() diff --git a/src/dbnode/generated/thrift/rpc/tchan-rpc.go b/src/dbnode/generated/thrift/rpc/tchan-rpc.go index 27306369d6..3d32c85d9e 100644 --- a/src/dbnode/generated/thrift/rpc/tchan-rpc.go +++ b/src/dbnode/generated/thrift/rpc/tchan-rpc.go @@ -50,6 +50,8 @@ type TChanNode interface { Bootstrapped(ctx thrift.Context) (*NodeBootstrappedResult_, error) BootstrappedInPlacementOrNoPlacement(ctx thrift.Context) (*NodeBootstrappedInPlacementOrNoPlacementResult_, error) DebugIndexMemorySegments(ctx thrift.Context, req *DebugIndexMemorySegmentsRequest) (*DebugIndexMemorySegmentsResult_, error) + DebugProfileStart(ctx thrift.Context, req *DebugProfileStartRequest) (*DebugProfileStartResult_, error) + DebugProfileStop(ctx thrift.Context, req *DebugProfileStopRequest) (*DebugProfileStopResult_, error) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) FetchBatchRaw(ctx thrift.Context, req *FetchBatchRawRequest) (*FetchBatchRawResult_, error) FetchBatchRawV2(ctx thrift.Context, req *FetchBatchRawV2Request) (*FetchBatchRawResult_, error) @@ -566,6 +568,42 @@ func (c *tchanNodeClient) DebugIndexMemorySegments(ctx thrift.Context, req *Debu return resp.GetSuccess(), err } +func (c *tchanNodeClient) DebugProfileStart(ctx thrift.Context, req *DebugProfileStartRequest) (*DebugProfileStartResult_, error) { + var resp NodeDebugProfileStartResult + args := NodeDebugProfileStartArgs{ + Req: req, + } + success, err := c.client.Call(ctx, c.thriftService, "debugProfileStart", &args, &resp) + if err == nil && !success { + switch { + case resp.Err != nil: + err = resp.Err + default: + err = fmt.Errorf("received no result or unknown exception for debugProfileStart") + } + } + + return resp.GetSuccess(), err +} + +func (c *tchanNodeClient) DebugProfileStop(ctx thrift.Context, req *DebugProfileStopRequest) (*DebugProfileStopResult_, error) { + var resp NodeDebugProfileStopResult + args := NodeDebugProfileStopArgs{ + Req: req, + } + success, err := c.client.Call(ctx, c.thriftService, "debugProfileStop", &args, &resp) + if err == nil && !success { + switch { + case resp.Err != nil: + err = resp.Err + default: + err = fmt.Errorf("received no result or unknown exception for debugProfileStop") + } + } + + return resp.GetSuccess(), err +} + func (c *tchanNodeClient) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { var resp NodeFetchResult args := NodeFetchArgs{ @@ -1009,6 +1047,8 @@ func (s *tchanNodeServer) Methods() []string { "bootstrapped", "bootstrappedInPlacementOrNoPlacement", "debugIndexMemorySegments", + "debugProfileStart", + "debugProfileStop", "fetch", "fetchBatchRaw", "fetchBatchRawV2", @@ -1048,6 +1088,10 @@ func (s *tchanNodeServer) Handle(ctx thrift.Context, methodName string, protocol return s.handleBootstrappedInPlacementOrNoPlacement(ctx, protocol) case "debugIndexMemorySegments": return s.handleDebugIndexMemorySegments(ctx, protocol) + case "debugProfileStart": + return s.handleDebugProfileStart(ctx, protocol) + case "debugProfileStop": + return s.handleDebugProfileStop(ctx, protocol) case "fetch": return s.handleFetch(ctx, protocol) case "fetchBatchRaw": @@ -1242,6 +1286,62 @@ func (s *tchanNodeServer) handleDebugIndexMemorySegments(ctx thrift.Context, pro return err == nil, &res, nil } +func (s *tchanNodeServer) handleDebugProfileStart(ctx thrift.Context, protocol athrift.TProtocol) (bool, athrift.TStruct, error) { + var req NodeDebugProfileStartArgs + var res NodeDebugProfileStartResult + + if err := req.Read(protocol); err != nil { + return false, nil, err + } + + r, err := + s.handler.DebugProfileStart(ctx, req.Req) + + if err != nil { + switch v := err.(type) { + case *Error: + if v == nil { + return false, nil, fmt.Errorf("Handler for err returned non-nil error type *Error but nil value") + } + res.Err = v + default: + return false, nil, err + } + } else { + res.Success = r + } + + return err == nil, &res, nil +} + +func (s *tchanNodeServer) handleDebugProfileStop(ctx thrift.Context, protocol athrift.TProtocol) (bool, athrift.TStruct, error) { + var req NodeDebugProfileStopArgs + var res NodeDebugProfileStopResult + + if err := req.Read(protocol); err != nil { + return false, nil, err + } + + r, err := + s.handler.DebugProfileStop(ctx, req.Req) + + if err != nil { + switch v := err.(type) { + case *Error: + if v == nil { + return false, nil, fmt.Errorf("Handler for err returned non-nil error type *Error but nil value") + } + res.Err = v + default: + return false, nil, err + } + } else { + res.Success = r + } + + return err == nil, &res, nil +} + func (s *tchanNodeServer) handleFetch(ctx thrift.Context, protocol athrift.TProtocol) (bool, athrift.TStruct, error) { var req NodeFetchArgs var res NodeFetchResult diff --git a/src/dbnode/network/server/tchannelthrift/node/service.go b/src/dbnode/network/server/tchannelthrift/node/service.go index bf992d58a9..652b47c409 100644 --- a/src/dbnode/network/server/tchannelthrift/node/service.go +++ b/src/dbnode/network/server/tchannelthrift/node/service.go @@ -23,6 +23,7 @@ package node import ( "errors" "fmt" + "runtime" "sort" "sync" "time" @@ -42,6 +43,7 @@ import ( "github.com/m3db/m3/src/dbnode/x/xpool" "github.com/m3db/m3/src/x/checked" "github.com/m3db/m3/src/x/context" + xdebug "github.com/m3db/m3/src/x/debug" xerrors "github.com/m3db/m3/src/x/errors" "github.com/m3db/m3/src/x/ident" "github.com/m3db/m3/src/x/instrument" @@ -161,6 +163,8 @@ type serviceState struct { numOutstandingReadRPCs int maxOutstandingReadRPCs int + + profiles map[string]*xdebug.ContinuousFileProfile } func (s *serviceState) DB() (storage.Database, bool) { @@ -303,6 +307,7 @@ func NewService(db storage.Database, opts tchannelthrift.Options) Service { }, maxOutstandingWriteRPCs: opts.MaxOutstandingWriteRequests(), maxOutstandingReadRPCs: opts.MaxOutstandingReadRequests(), + profiles: make(map[string]*xdebug.ContinuousFileProfile), }, logger: iopts.Logger(), opts: opts, @@ -1977,6 +1982,106 @@ func (s *service) SetWriteNewSeriesLimitPerShardPerSecond( return s.GetWriteNewSeriesLimitPerShardPerSecond(ctx) } +func (s *service) DebugProfileStart( + ctx thrift.Context, + req *rpc.DebugProfileStartRequest, +) (*rpc.DebugProfileStartResult_, error) { + s.state.Lock() + defer s.state.Unlock() + + _, ok := s.state.profiles[req.Name] + if ok { + err := fmt.Errorf("profile already exists: %s", req.Name) + return nil, tterrors.NewBadRequestError(err) + } + + var ( + interval time.Duration + duration time.Duration + debug int + err error + ) + if v := req.Interval; v != nil { + interval, err = time.ParseDuration(*v) + if err != nil { + return nil, tterrors.NewBadRequestError(err) + } + } + if v := req.Duration; v != nil { + duration, err = time.ParseDuration(*v) + if err != nil { + return nil, tterrors.NewBadRequestError(err) + } + } + if v := req.Debug; v != nil { + debug = int(*v) + } + + conditional := func() bool { + if v := req.ConditionalNumGoroutinesGreaterThan; v != nil { + if runtime.NumGoroutine() <= int(*v) { + return false + } + } + if v := req.ConditionalNumGoroutinesLessThan; v != nil { + if runtime.NumGoroutine() >= int(*v) { + return false + } + } + if v := req.ConditionalIsOverloaded; v != nil { + overloaded := s.state.db != nil && s.state.db.IsOverloaded() + if *v != overloaded { + return false + } + } + + return true + } + + p, err := xdebug.NewContinuousFileProfile(xdebug.ContinuousFileProfileOptions{ + FilePathTemplate: req.FilePathTemplate, + ProfileName: req.Name, + ProfileDuration: duration, + ProfileDebug: debug, + Conditional: conditional, + Interval: interval, + InstrumentOptions: s.opts.InstrumentOptions(), + }) + if err != nil { + return nil, tterrors.NewBadRequestError(err) + } + + if err := p.Start(); err != nil { + return nil, err + } + + s.state.profiles[req.Name] = p + + return &rpc.DebugProfileStartResult_{}, nil +} + +func (s *service) DebugProfileStop( + ctx thrift.Context, + req *rpc.DebugProfileStopRequest, +) (*rpc.DebugProfileStopResult_, error) { + s.state.Lock() + defer s.state.Unlock() + + existing, ok := s.state.profiles[req.Name] + if !ok { + err := fmt.Errorf("profile does not exist: %s", req.Name) + return nil, tterrors.NewBadRequestError(err) + } + + if err := existing.Stop(); err != nil { + return nil, err + } + + delete(s.state.profiles, req.Name) + + return &rpc.DebugProfileStopResult_{}, nil +} + func (s *service) DebugIndexMemorySegments( ctx thrift.Context, req *rpc.DebugIndexMemorySegmentsRequest, diff --git a/src/dbnode/storage/namespace.go b/src/dbnode/storage/namespace.go index d2c9048e39..e03c9cc6d5 100644 --- a/src/dbnode/storage/namespace.go +++ b/src/dbnode/storage/namespace.go @@ -303,13 +303,14 @@ func newDatabaseNamespace( iops := opts.InstrumentOptions() logger := iops.Logger().With(zap.String("namespace", id.String())) - iops = iops.SetLogger(logger) + iops = iops. + SetLogger(logger). + SetMetricsScope(iops.MetricsScope().Tagged(map[string]string{ + "namespace": id.String(), + })) opts = opts.SetInstrumentOptions(iops) - scope := iops.MetricsScope().SubScope("database"). - Tagged(map[string]string{ - "namespace": id.String(), - }) + scope := iops.MetricsScope().SubScope("database") tickWorkersConcurrency := int(math.Max(1, float64(runtime.NumCPU())/8)) tickWorkers := xsync.NewWorkerPool(tickWorkersConcurrency) diff --git a/src/x/debug/triggering_profile.go b/src/x/debug/triggering_profile.go new file mode 100644 index 0000000000..473e8b6756 --- /dev/null +++ b/src/x/debug/triggering_profile.go @@ -0,0 +1,212 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package debug + +import ( + "bytes" + "errors" + "fmt" + "os" + "runtime/pprof" + "text/template" + "time" + + "github.com/m3db/m3/src/x/instrument" + + "go.uber.org/zap" +) + +const ( + // ContinuousCPUProfileName is the name of continuous CPU profile. + ContinuousCPUProfileName = "cpu" +) + +var ( + defaultConditional = func() bool { return true } + defaultInterval = time.Second + errNoFilePathTemplate = errors.New("no file path template") + errNoProfileName = errors.New("no profile name") + errNoInstrumentOptions = errors.New("no instrument options") + errAlreadyOpen = errors.New("already open") + errNotOpen = errors.New("not open") +) + +// ContinuousFileProfile is a profile that runs continously +// to a file using a template for a file name. +type ContinuousFileProfile struct { + filePathTemplate *template.Template + profileName string + profileDuration time.Duration + profileDebug int + conditional func() bool + interval time.Duration + + logger *zap.Logger + + closeCh chan struct{} +} + +// ContinuousFileProfileOptions is a set of continuous file profile options. +type ContinuousFileProfileOptions struct { + FilePathTemplate string + ProfileName string + ProfileDuration time.Duration + ProfileDebug int + Conditional func() bool + Interval time.Duration + InstrumentOptions instrument.Options +} + +// ContinuousFileProfilePathParams is the params used to construct +// a file path. +type ContinuousFileProfilePathParams struct { + ProfileName string + UnixTime int64 +} + +// NewContinuousFileProfile returns a new continuous file profile. +func NewContinuousFileProfile( + opts ContinuousFileProfileOptions, +) (*ContinuousFileProfile, error) { + if opts.FilePathTemplate == "" { + return nil, errNoFilePathTemplate + } + if opts.ProfileName == "" { + return nil, errNoProfileName + } + if opts.Conditional == nil { + opts.Conditional = defaultConditional + } + if opts.Interval == 0 { + opts.Interval = defaultInterval + } + if opts.InstrumentOptions == nil { + return nil, errNoInstrumentOptions + } + + tmpl, err := template.New("fileName").Parse(opts.FilePathTemplate) + if err != nil { + return nil, err + } + + return &ContinuousFileProfile{ + filePathTemplate: tmpl, + profileName: opts.ProfileName, + profileDuration: opts.ProfileDuration, + profileDebug: opts.ProfileDebug, + conditional: opts.Conditional, + interval: opts.Interval, + logger: opts.InstrumentOptions.Logger(), + }, nil +} + +// Start will start the continuous file profile. +func (c *ContinuousFileProfile) Start() error { + if c.closeCh != nil { + return errAlreadyOpen + } + + c.closeCh = make(chan struct{}) + go c.run() + return nil +} + +// Stop will stop the continuous file profile. +func (c *ContinuousFileProfile) Stop() error { + if c.closeCh == nil { + return errNotOpen + } + + close(c.closeCh) + c.closeCh = nil + + return nil +} + +func (c *ContinuousFileProfile) run() { + closeCh := c.closeCh + ticker := time.NewTicker(c.interval) + defer ticker.Stop() + + for { + select { + case <-closeCh: + return + case <-ticker.C: + if !c.conditional() { + continue + } + + err := c.profile() + if err != nil { + c.logger.Error("continuous profile error", + zap.String("name", c.profileName), + zap.Int("debug", c.profileDebug), + zap.Duration("interval", c.interval), + zap.Error(err)) + } + } + } +} + +func (c *ContinuousFileProfile) profile() error { + filePathBuffer := bytes.NewBuffer(nil) + filePathParams := ContinuousFileProfilePathParams{ + ProfileName: c.profileName, + UnixTime: time.Now().Unix(), + } + err := c.filePathTemplate.Execute(filePathBuffer, filePathParams) + if err != nil { + return err + } + + w, err := os.Create(filePathBuffer.String()) + if err != nil { + return err + } + + success := false + defer func() { + if !success { + _ = w.Close() + } + }() + + switch c.profileName { + case ContinuousCPUProfileName: + if err := pprof.StartCPUProfile(w); err != nil { + return err + } + time.Sleep(c.profileDuration) + pprof.StopCPUProfile() + default: + p := pprof.Lookup(c.profileName) + if p == nil { + return fmt.Errorf("unknown profile: %s", c.profileName) + } + if err := p.WriteTo(w, c.profileDebug); err != nil { + return err + } + } + + success = true + return w.Close() +} diff --git a/src/x/debug/triggering_profile_test.go b/src/x/debug/triggering_profile_test.go new file mode 100644 index 0000000000..b769b1cd1e --- /dev/null +++ b/src/x/debug/triggering_profile_test.go @@ -0,0 +1,123 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package debug + +import ( + "fmt" + "io/ioutil" + "os" + "path" + "regexp" + "strings" + "testing" + "time" + + "github.com/m3db/m3/src/x/instrument" + + "github.com/stretchr/testify/require" + "go.uber.org/atomic" +) + +func TestContinuousFileProfile(t *testing.T) { + for _, test := range []struct { + name string + duration time.Duration + debug int + }{ + { + name: ContinuousCPUProfileName, + duration: time.Second, + }, + { + name: "goroutine", + debug: 2, + }, + } { + test := test + name := fmt.Sprintf("%s_%s_%d", test.name, test.duration, test.debug) + t.Run(name, func(t *testing.T) { + dir, err := ioutil.TempDir("", "") + require.NoError(t, err) + + defer os.RemoveAll(dir) + + ext := ".profile" + + cond := atomic.NewBool(false) + opts := ContinuousFileProfileOptions{ + FilePathTemplate: path.Join(dir, "{{.ProfileName}}-{{.UnixTime}}"+ext), + ProfileName: test.name, + ProfileDuration: test.duration, + ProfileDebug: test.debug, + Interval: 20 * time.Millisecond, + Conditional: cond.Load, + InstrumentOptions: instrument.NewTestOptions(t), + } + + profile, err := NewContinuousFileProfile(opts) + require.NoError(t, err) + + require.NoError(t, profile.Start()) + + for i := 0; i < 10; i++ { + // Make sure doesn't create files until conditional returns true + time.Sleep(opts.Interval) + + files, err := ioutil.ReadDir(dir) + require.NoError(t, err) + + for _, f := range files { + if strings.HasSuffix(f.Name(), ext) { + require.FailNow(t, "conditional false, profile generated") + } + } + } + + // Trigger profile. + cond.Store(true) + + for start := time.Now(); time.Since(start) < 10*time.Second; { + files, err := ioutil.ReadDir(dir) + require.NoError(t, err) + + profiles := 0 + for _, f := range files { + if strings.HasSuffix(f.Name(), ext) { + pattern := test.name + `-[0-9]+\` + ext + re := regexp.MustCompile(pattern) + require.True(t, re.MatchString(f.Name()), + fmt.Sprintf( + "file should match pattern: pattern=%s, actual=%s", + pattern, f.Name())) + profiles++ + } + } + + if profiles >= 2 { + // Successfully continuously emitting. + return + } + } + + require.FailNow(t, "did not generate profiles") + }) + } +}