From 7e3ab5e2c7e82c3e1173d82dd5406f94c0380641 Mon Sep 17 00:00:00 2001 From: Rob Skillington Date: Tue, 16 Jun 2020 23:46:24 -0400 Subject: [PATCH 1/5] [dbnode] Add continuous file profile with RPC endpoint --- src/dbnode/generated/thrift/generate.sh | 1 + src/dbnode/generated/thrift/rpc.thrift | 23 + src/dbnode/generated/thrift/rpc/rpc.go | 6842 ++++++++++------- src/dbnode/generated/thrift/rpc/rpc_mock.go | 609 -- src/dbnode/generated/thrift/rpc/tchan-rpc.go | 100 + .../server/tchannelthrift/node/service.go | 98 + src/x/debug/triggering_profile.go | 212 + src/x/debug/triggering_profile_test.go | 123 + 8 files changed, 4679 insertions(+), 3329 deletions(-) delete mode 100644 src/dbnode/generated/thrift/rpc/rpc_mock.go create mode 100644 src/x/debug/triggering_profile.go create mode 100644 src/x/debug/triggering_profile_test.go 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 709309d689..775d19e319 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) } @@ -488,6 +490,27 @@ struct Query { 7: optional FieldQuery field } +struct DebugProfileStartRequest { + 1: required string name + 2: required string filePathTemplate + 3: optional i64 intervalNanos + 4: optional i64 durationNanos + 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 da282734f3..28276e591d 100644 --- a/src/dbnode/generated/thrift/rpc/rpc.go +++ b/src/dbnode/generated/thrift/rpc/rpc.go @@ -12861,24 +12861,121 @@ func (p *Query) String() string { } // Attributes: -// - Directory -type DebugIndexMemorySegmentsRequest struct { - Directory string `thrift:"directory,1,required" db:"directory" json:"directory"` +// - Name +// - FilePathTemplate +// - IntervalNanos +// - DurationNanos +// - 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"` + IntervalNanos *int64 `thrift:"intervalNanos,3" db:"intervalNanos" json:"intervalNanos,omitempty"` + DurationNanos *int64 `thrift:"durationNanos,4" db:"durationNanos" json:"durationNanos,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_IntervalNanos_DEFAULT int64 + +func (p *DebugProfileStartRequest) GetIntervalNanos() int64 { + if !p.IsSetIntervalNanos() { + return DebugProfileStartRequest_IntervalNanos_DEFAULT + } + return *p.IntervalNanos } -func (p *DebugIndexMemorySegmentsRequest) Read(iprot thrift.TProtocol) error { + +var DebugProfileStartRequest_DurationNanos_DEFAULT int64 + +func (p *DebugProfileStartRequest) GetDurationNanos() int64 { + if !p.IsSetDurationNanos() { + return DebugProfileStartRequest_DurationNanos_DEFAULT + } + return *p.DurationNanos +} + +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) IsSetIntervalNanos() bool { + return p.IntervalNanos != nil +} + +func (p *DebugProfileStartRequest) IsSetDurationNanos() bool { + return p.DurationNanos != 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() @@ -12893,7 +12990,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 @@ -12906,29 +13032,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.ReadI64(); err != nil { + return thrift.PrependError("error reading field 3: ", err) + } else { + p.IntervalNanos = &v + } + return nil +} + +func (p *DebugProfileStartRequest) ReadField4(iprot thrift.TProtocol) error { + if v, err := iprot.ReadI64(); err != nil { + return thrift.PrependError("error reading field 4: ", err) + } else { + p.DurationNanos = &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) @@ -12939,34 +13152,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.IsSetIntervalNanos() { + if err := oprot.WriteFieldBegin("intervalNanos", thrift.I64, 3); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:intervalNanos: ", p), err) + } + if err := oprot.WriteI64(int64(*p.IntervalNanos)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.intervalNanos (3) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 3:intervalNanos: ", p), err) + } + } + return err +} + +func (p *DebugProfileStartRequest) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetDurationNanos() { + if err := oprot.WriteFieldBegin("durationNanos", thrift.I64, 4); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:durationNanos: ", p), err) + } + if err := oprot.WriteI64(int64(*p.DurationNanos)); err != nil { + return thrift.PrependError(fmt.Sprintf("%T.durationNanos (4) field write error: ", p), err) + } + if err := oprot.WriteFieldEnd(); err != nil { + return thrift.PrependError(fmt.Sprintf("%T write field end error 4:durationNanos: ", 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) } @@ -12992,8 +13308,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 { @@ -13007,457 +13323,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 { @@ -13469,7 +13775,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) @@ -13479,32 +13785,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 } @@ -13521,24 +13827,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 { @@ -13550,7 +13856,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) @@ -13560,32 +13866,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 } @@ -13596,29 +13902,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 { @@ -13630,7 +13937,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) @@ -13640,32 +13947,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 } @@ -13676,29 +13983,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 { @@ -13710,7 +14018,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) @@ -13720,32 +14028,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 } @@ -13762,24 +14070,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 { @@ -13791,7 +14099,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) @@ -13801,32 +14109,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 } @@ -13843,24 +14151,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 { @@ -13872,7 +14180,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) @@ -13882,32 +14190,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 } @@ -13918,30 +14226,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 { @@ -13953,7 +14260,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) @@ -13963,32 +14270,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 } @@ -13999,30 +14306,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 { @@ -14034,7 +14340,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) @@ -14044,32 +14350,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 } @@ -14080,29 +14386,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 { @@ -14114,7 +14421,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) @@ -14124,32 +14431,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 } @@ -14160,29 +14467,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 { @@ -14194,7 +14502,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) @@ -14204,32 +14512,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 } @@ -14240,29 +14548,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 { @@ -14274,7 +14583,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) @@ -14284,32 +14593,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 } @@ -14320,27 +14629,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 } @@ -14350,7 +14664,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) @@ -14360,32 +14674,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 } @@ -14401,24 +14715,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 { @@ -14430,7 +14744,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) @@ -14440,32 +14754,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 } @@ -14476,28 +14790,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 } @@ -14507,7 +14824,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) @@ -14517,32 +14834,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 } @@ -14553,28 +14870,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 } @@ -14584,7 +14904,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) @@ -14594,32 +14914,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 } @@ -14630,28 +14950,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 } @@ -14661,7 +14980,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) @@ -14671,32 +14990,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 } @@ -14707,28 +15026,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 } @@ -14738,7 +15060,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) @@ -14748,32 +15070,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 } @@ -14788,28 +15110,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 } @@ -14819,7 +15137,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) @@ -14829,32 +15147,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 } @@ -14869,24 +15187,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 } @@ -14896,7 +15214,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) @@ -14906,32 +15224,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 } @@ -14946,28 +15264,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 } @@ -14977,7 +15291,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) @@ -14987,32 +15301,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 } @@ -15027,24 +15341,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 } @@ -15054,7 +15368,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) @@ -15064,32 +15378,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 } @@ -15106,24 +15420,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 { @@ -15135,7 +15449,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) @@ -15145,32 +15459,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 } @@ -15185,24 +15499,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 } @@ -15212,7 +15526,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) @@ -15222,32 +15536,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 } @@ -15264,24 +15578,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 { @@ -15293,7 +15607,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) @@ -15303,32 +15617,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 } @@ -15343,28 +15657,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 } @@ -15374,7 +15684,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) @@ -15384,32 +15694,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 } @@ -15424,453 +15734,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() @@ -15878,16 +16307,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() @@ -15896,7 +16325,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 { @@ -15914,16 +16343,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() @@ -15931,16 +16360,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() @@ -15949,7 +16378,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 { @@ -15967,16 +16396,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() @@ -15984,16 +16413,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() @@ -16002,7 +16431,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 { @@ -16020,16 +16449,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() @@ -16037,16 +16466,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() @@ -16055,7 +16484,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 { @@ -16073,16 +16502,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() @@ -16090,22 +16519,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 { @@ -16123,16 +16555,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() @@ -16140,22 +16572,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 { @@ -16173,16 +16605,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() @@ -16190,22 +16622,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 { @@ -16223,16 +16655,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() @@ -16240,22 +16672,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 { @@ -16273,16 +16708,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() @@ -16290,22 +16725,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 { @@ -16323,16 +16761,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() @@ -16340,16 +16778,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() @@ -16358,7 +16796,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 { @@ -16376,16 +16814,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() @@ -16393,16 +16831,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() @@ -16411,7 +16849,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 { @@ -16429,16 +16867,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() @@ -16446,25 +16884,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 { @@ -16482,16 +16917,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() @@ -16499,25 +16934,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 { @@ -16535,16 +16967,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() @@ -16552,25 +16984,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 { @@ -16588,16 +17017,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() @@ -16605,25 +17034,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 { @@ -16641,16 +17067,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() @@ -16658,25 +17084,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 { @@ -16694,16 +17117,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() @@ -16711,16 +17134,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() @@ -16729,7 +17152,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 { @@ -16747,16 +17170,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() @@ -16764,16 +17187,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() @@ -16782,7 +17205,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 { @@ -16800,16 +17223,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() @@ -16817,16 +17240,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() @@ -16835,7 +17258,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 { @@ -16853,16 +17276,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() @@ -16870,16 +17293,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() @@ -16888,7 +17311,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 { @@ -16906,137 +17488,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) } @@ -17069,11 +18479,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) @@ -17081,8 +18491,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 { @@ -17099,7 +18509,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) } @@ -17112,51 +18522,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) } @@ -17193,15 +18603,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, } @@ -17211,8 +18621,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 { @@ -17232,7 +18642,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) @@ -17247,7 +18657,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) @@ -17262,36 +18672,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) } @@ -17324,11 +18734,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) @@ -17336,8 +18746,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 { @@ -17354,7 +18764,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) } @@ -17367,51 +18777,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) } @@ -17448,15 +18858,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, } @@ -17466,8 +18876,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 { @@ -17487,7 +18897,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) @@ -17502,7 +18912,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) @@ -17517,36 +18927,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) } @@ -17579,11 +18989,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) @@ -17591,8 +18999,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 { @@ -17609,7 +19017,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) } @@ -17622,51 +19030,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) } @@ -17703,15 +19111,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, } @@ -17721,8 +19129,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 { @@ -17742,7 +19150,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) @@ -17757,7 +19165,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) @@ -17772,36 +19180,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) } @@ -17834,20 +19242,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 { @@ -17864,7 +19268,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) } @@ -17877,51 +19281,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) } @@ -17935,10 +19324,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 @@ -17949,24 +19334,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, } @@ -17976,14 +19353,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 } @@ -17997,22 +19371,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) @@ -18027,36 +19386,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) } @@ -18089,18 +19448,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 { @@ -18117,7 +19474,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) } @@ -18130,51 +19487,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) } @@ -18188,10 +19530,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 @@ -18211,15 +19549,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, } @@ -18229,14 +19559,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 } @@ -18250,22 +19577,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) @@ -18280,36 +19592,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) } @@ -18342,16 +19654,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 { @@ -18368,7 +19682,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) } @@ -18381,36 +19695,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) } @@ -18424,6 +19753,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 @@ -18443,7 +19776,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, } @@ -18453,11 +19794,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 } @@ -18471,7 +19815,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) @@ -18486,36 +19845,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) } @@ -18548,16 +19907,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 { @@ -18574,7 +19933,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) } @@ -18587,36 +19946,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) } @@ -18630,6 +20004,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 @@ -18649,7 +20027,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, } @@ -18659,11 +20045,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 } @@ -18677,7 +20066,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) @@ -18692,36 +20096,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) } @@ -18754,18 +20158,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 { @@ -18782,7 +20184,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) } @@ -18795,51 +20197,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) } @@ -18876,15 +20278,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, } @@ -18894,8 +20296,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 { @@ -18915,7 +20317,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) @@ -18930,7 +20332,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) @@ -18945,36 +20347,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) } @@ -19007,16 +20409,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 { @@ -19033,7 +20435,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) } @@ -19046,51 +20448,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) } @@ -19127,15 +20529,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, } @@ -19145,8 +20547,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 { @@ -19166,7 +20568,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) @@ -19181,7 +20583,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) @@ -19196,36 +20598,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) } @@ -19258,16 +20660,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 { @@ -19284,7 +20686,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) } @@ -19297,51 +20699,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) } @@ -19355,10 +20742,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 @@ -19378,32 +20761,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 } @@ -19417,22 +20787,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) @@ -19447,36 +20802,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) } @@ -19509,16 +20864,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 { @@ -19535,7 +20890,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) } @@ -19548,51 +20903,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) } @@ -19606,10 +20946,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 @@ -19629,32 +20965,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 } @@ -19668,22 +20991,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) @@ -19698,36 +21006,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) } @@ -19760,16 +21068,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 { @@ -19786,7 +21094,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) } @@ -19799,36 +21107,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) } @@ -19861,7 +21169,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) @@ -19869,8 +21177,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 { @@ -19887,7 +21195,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) @@ -19902,36 +21210,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) } @@ -19964,16 +21272,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 { @@ -19990,7 +21298,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) } @@ -20003,36 +21311,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) } @@ -20065,7 +21373,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) @@ -20073,8 +21381,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 { @@ -20091,7 +21399,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) @@ -20106,36 +21414,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) } @@ -20148,15 +21441,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 @@ -20168,22 +21454,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) @@ -20194,49 +21469,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) } @@ -20269,16 +21531,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 { @@ -20295,7 +21559,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) @@ -20310,36 +21574,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) } @@ -20372,16 +21636,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 { @@ -20398,7 +21662,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) } @@ -20411,36 +21675,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) } @@ -20454,6 +21733,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 @@ -20473,19 +21756,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 } @@ -20499,7 +21795,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) @@ -20514,21 +21825,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) } @@ -20554,8 +21865,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 { @@ -20569,36 +21880,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) } @@ -20612,6 +21938,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 @@ -20631,7 +21961,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, } @@ -20641,11 +21979,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 } @@ -20659,7 +22000,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) @@ -20674,36 +22030,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) } @@ -20716,15 +22057,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 @@ -20736,22 +22070,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) @@ -20762,64 +22085,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) } @@ -20856,15 +22166,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, } @@ -20874,8 +22184,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 { @@ -20895,7 +22205,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) @@ -20910,7 +22220,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) @@ -20925,21 +22235,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) } @@ -20965,8 +22275,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 { @@ -20980,51 +22290,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) } @@ -21061,15 +22371,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, } @@ -21079,8 +22389,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 { @@ -21100,7 +22410,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) @@ -21115,7 +22425,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) @@ -21130,21 +22440,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) } @@ -21170,8 +22480,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 { @@ -21185,51 +22495,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) } @@ -21266,15 +22576,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, } @@ -21284,8 +22594,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 { @@ -21305,7 +22615,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) @@ -21320,7 +22630,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) @@ -21335,21 +22645,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) } @@ -21362,8 +22687,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 @@ -21375,11 +22707,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) @@ -21390,51 +22733,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) } @@ -21471,15 +22827,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, } @@ -21489,8 +22845,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 { @@ -21510,7 +22866,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) @@ -21525,7 +22881,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) @@ -21540,21 +22896,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) } @@ -21580,8 +22936,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 { @@ -21595,51 +22951,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) } @@ -21676,15 +23032,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, } @@ -21694,8 +23050,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 { @@ -21715,7 +23071,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) @@ -21730,7 +23086,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) @@ -21745,36 +23101,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) } @@ -21807,16 +23163,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 { @@ -21833,7 +23189,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) } @@ -21846,51 +23202,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) } @@ -21927,15 +23283,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, } @@ -21945,8 +23301,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 { @@ -21966,7 +23322,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) @@ -21981,7 +23337,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) @@ -21996,21 +23352,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) } @@ -22036,8 +23392,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 { @@ -22051,51 +23407,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) } @@ -22132,15 +23488,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, } @@ -22150,8 +23506,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 { @@ -22171,7 +23527,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) @@ -22186,7 +23542,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) @@ -22201,36 +23557,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) } @@ -22263,16 +23619,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 { @@ -22289,7 +23647,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) } @@ -22302,51 +23660,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) } @@ -22383,15 +23741,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, } @@ -22401,8 +23759,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 { @@ -22422,7 +23780,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) @@ -22437,7 +23795,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) @@ -22452,21 +23810,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) } @@ -22492,8 +23850,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 { @@ -22507,51 +23865,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) } @@ -22588,15 +23946,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, } @@ -22606,8 +23964,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 { @@ -22627,7 +23985,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) @@ -22642,7 +24000,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) @@ -22657,36 +24015,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) } @@ -22719,18 +24077,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 { @@ -22747,7 +24103,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) } @@ -22760,51 +24116,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) } @@ -22841,15 +24197,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, } @@ -22859,8 +24215,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 { @@ -22880,7 +24236,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) @@ -22895,7 +24251,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) @@ -22910,21 +24266,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) } @@ -22937,8 +24308,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 @@ -22950,11 +24328,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) @@ -22965,51 +24354,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) } @@ -23046,15 +24448,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, } @@ -23064,8 +24466,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 { @@ -23085,7 +24487,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) @@ -23100,7 +24502,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) @@ -23115,36 +24517,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) } @@ -23177,16 +24579,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 { @@ -23203,7 +24605,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) } @@ -23216,51 +24618,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) } @@ -23297,15 +24699,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, } @@ -23315,8 +24717,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 { @@ -23336,7 +24738,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) @@ -23351,7 +24753,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) @@ -23366,11 +24768,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: @@ -23718,16 +25120,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 { @@ -23799,16 +25201,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 { @@ -23879,16 +25281,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 { @@ -23959,16 +25361,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 { @@ -24040,16 +25442,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 { @@ -24121,16 +25523,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 { @@ -24202,16 +25604,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 { @@ -24253,15 +25655,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) { @@ -24274,12 +25676,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 deleted file mode 100644 index ea85aa466a..0000000000 --- a/src/dbnode/generated/thrift/rpc/rpc_mock.go +++ /dev/null @@ -1,609 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/m3db/m3/src/dbnode/generated/thrift/rpc/tchan-go - -// 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 rpc is a generated GoMock package. -package rpc - -import ( - "reflect" - - "github.com/golang/mock/gomock" - "github.com/uber/tchannel-go/thrift" -) - -// MockTChanCluster is a mock of TChanCluster interface -type MockTChanCluster struct { - ctrl *gomock.Controller - recorder *MockTChanClusterMockRecorder -} - -// MockTChanClusterMockRecorder is the mock recorder for MockTChanCluster -type MockTChanClusterMockRecorder struct { - mock *MockTChanCluster -} - -// NewMockTChanCluster creates a new mock instance -func NewMockTChanCluster(ctrl *gomock.Controller) *MockTChanCluster { - mock := &MockTChanCluster{ctrl: ctrl} - mock.recorder = &MockTChanClusterMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTChanCluster) EXPECT() *MockTChanClusterMockRecorder { - return m.recorder -} - -// Aggregate mocks base method -func (m *MockTChanCluster) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Aggregate", ctx, req) - ret0, _ := ret[0].(*AggregateQueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Aggregate indicates an expected call of Aggregate -func (mr *MockTChanClusterMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanCluster)(nil).Aggregate), ctx, req) -} - -// Fetch mocks base method -func (m *MockTChanCluster) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Fetch", ctx, req) - ret0, _ := ret[0].(*FetchResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Fetch indicates an expected call of Fetch -func (mr *MockTChanClusterMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanCluster)(nil).Fetch), ctx, req) -} - -// Health mocks base method -func (m *MockTChanCluster) Health(ctx thrift.Context) (*HealthResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Health", ctx) - ret0, _ := ret[0].(*HealthResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Health indicates an expected call of Health -func (mr *MockTChanClusterMockRecorder) Health(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanCluster)(nil).Health), ctx) -} - -// Query mocks base method -func (m *MockTChanCluster) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Query", ctx, req) - ret0, _ := ret[0].(*QueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Query indicates an expected call of Query -func (mr *MockTChanClusterMockRecorder) Query(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanCluster)(nil).Query), ctx, req) -} - -// Truncate mocks base method -func (m *MockTChanCluster) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Truncate", ctx, req) - ret0, _ := ret[0].(*TruncateResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Truncate indicates an expected call of Truncate -func (mr *MockTChanClusterMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanCluster)(nil).Truncate), ctx, req) -} - -// Write mocks base method -func (m *MockTChanCluster) Write(ctx thrift.Context, req *WriteRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Write", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// Write indicates an expected call of Write -func (mr *MockTChanClusterMockRecorder) Write(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanCluster)(nil).Write), ctx, req) -} - -// WriteTagged mocks base method -func (m *MockTChanCluster) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTagged", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTagged indicates an expected call of WriteTagged -func (mr *MockTChanClusterMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanCluster)(nil).WriteTagged), ctx, req) -} - -// MockTChanNode is a mock of TChanNode interface -type MockTChanNode struct { - ctrl *gomock.Controller - recorder *MockTChanNodeMockRecorder -} - -// MockTChanNodeMockRecorder is the mock recorder for MockTChanNode -type MockTChanNodeMockRecorder struct { - mock *MockTChanNode -} - -// NewMockTChanNode creates a new mock instance -func NewMockTChanNode(ctrl *gomock.Controller) *MockTChanNode { - mock := &MockTChanNode{ctrl: ctrl} - mock.recorder = &MockTChanNodeMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTChanNode) EXPECT() *MockTChanNodeMockRecorder { - return m.recorder -} - -// Aggregate mocks base method -func (m *MockTChanNode) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Aggregate", ctx, req) - ret0, _ := ret[0].(*AggregateQueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Aggregate indicates an expected call of Aggregate -func (mr *MockTChanNodeMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanNode)(nil).Aggregate), ctx, req) -} - -// AggregateRaw mocks base method -func (m *MockTChanNode) AggregateRaw(ctx thrift.Context, req *AggregateQueryRawRequest) (*AggregateQueryRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AggregateRaw", ctx, req) - ret0, _ := ret[0].(*AggregateQueryRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AggregateRaw indicates an expected call of AggregateRaw -func (mr *MockTChanNodeMockRecorder) AggregateRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateRaw", reflect.TypeOf((*MockTChanNode)(nil).AggregateRaw), ctx, req) -} - -// Bootstrapped mocks base method -func (m *MockTChanNode) Bootstrapped(ctx thrift.Context) (*NodeBootstrappedResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Bootstrapped", ctx) - ret0, _ := ret[0].(*NodeBootstrappedResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Bootstrapped indicates an expected call of Bootstrapped -func (mr *MockTChanNodeMockRecorder) Bootstrapped(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrapped", reflect.TypeOf((*MockTChanNode)(nil).Bootstrapped), ctx) -} - -// BootstrappedInPlacementOrNoPlacement mocks base method -func (m *MockTChanNode) BootstrappedInPlacementOrNoPlacement(ctx thrift.Context) (*NodeBootstrappedInPlacementOrNoPlacementResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BootstrappedInPlacementOrNoPlacement", ctx) - ret0, _ := ret[0].(*NodeBootstrappedInPlacementOrNoPlacementResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BootstrappedInPlacementOrNoPlacement indicates an expected call of BootstrappedInPlacementOrNoPlacement -func (mr *MockTChanNodeMockRecorder) BootstrappedInPlacementOrNoPlacement(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootstrappedInPlacementOrNoPlacement", reflect.TypeOf((*MockTChanNode)(nil).BootstrappedInPlacementOrNoPlacement), ctx) -} - -// DebugIndexMemorySegments mocks base method -func (m *MockTChanNode) DebugIndexMemorySegments(ctx thrift.Context, req *DebugIndexMemorySegmentsRequest) (*DebugIndexMemorySegmentsResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DebugIndexMemorySegments", ctx, req) - ret0, _ := ret[0].(*DebugIndexMemorySegmentsResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DebugIndexMemorySegments indicates an expected call of DebugIndexMemorySegments -func (mr *MockTChanNodeMockRecorder) DebugIndexMemorySegments(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugIndexMemorySegments", reflect.TypeOf((*MockTChanNode)(nil).DebugIndexMemorySegments), ctx, req) -} - -// Fetch mocks base method -func (m *MockTChanNode) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Fetch", ctx, req) - ret0, _ := ret[0].(*FetchResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Fetch indicates an expected call of Fetch -func (mr *MockTChanNodeMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanNode)(nil).Fetch), ctx, req) -} - -// FetchBatchRaw mocks base method -func (m *MockTChanNode) FetchBatchRaw(ctx thrift.Context, req *FetchBatchRawRequest) (*FetchBatchRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBatchRaw", ctx, req) - ret0, _ := ret[0].(*FetchBatchRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBatchRaw indicates an expected call of FetchBatchRaw -func (mr *MockTChanNodeMockRecorder) FetchBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRaw), ctx, req) -} - -// FetchBatchRawV2 mocks base method -func (m *MockTChanNode) FetchBatchRawV2(ctx thrift.Context, req *FetchBatchRawV2Request) (*FetchBatchRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBatchRawV2", ctx, req) - ret0, _ := ret[0].(*FetchBatchRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBatchRawV2 indicates an expected call of FetchBatchRawV2 -func (mr *MockTChanNodeMockRecorder) FetchBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRawV2), ctx, req) -} - -// FetchBlocksMetadataRawV2 mocks base method -func (m *MockTChanNode) FetchBlocksMetadataRawV2(ctx thrift.Context, req *FetchBlocksMetadataRawV2Request) (*FetchBlocksMetadataRawV2Result_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBlocksMetadataRawV2", ctx, req) - ret0, _ := ret[0].(*FetchBlocksMetadataRawV2Result_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBlocksMetadataRawV2 indicates an expected call of FetchBlocksMetadataRawV2 -func (mr *MockTChanNodeMockRecorder) FetchBlocksMetadataRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksMetadataRawV2), ctx, req) -} - -// FetchBlocksRaw mocks base method -func (m *MockTChanNode) FetchBlocksRaw(ctx thrift.Context, req *FetchBlocksRawRequest) (*FetchBlocksRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBlocksRaw", ctx, req) - ret0, _ := ret[0].(*FetchBlocksRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBlocksRaw indicates an expected call of FetchBlocksRaw -func (mr *MockTChanNodeMockRecorder) FetchBlocksRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksRaw), ctx, req) -} - -// FetchTagged mocks base method -func (m *MockTChanNode) FetchTagged(ctx thrift.Context, req *FetchTaggedRequest) (*FetchTaggedResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchTagged", ctx, req) - ret0, _ := ret[0].(*FetchTaggedResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchTagged indicates an expected call of FetchTagged -func (mr *MockTChanNodeMockRecorder) FetchTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockTChanNode)(nil).FetchTagged), ctx, req) -} - -// GetPersistRateLimit mocks base method -func (m *MockTChanNode) GetPersistRateLimit(ctx thrift.Context) (*NodePersistRateLimitResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPersistRateLimit", ctx) - ret0, _ := ret[0].(*NodePersistRateLimitResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPersistRateLimit indicates an expected call of GetPersistRateLimit -func (mr *MockTChanNodeMockRecorder) GetPersistRateLimit(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).GetPersistRateLimit), ctx) -} - -// GetWriteNewSeriesAsync mocks base method -func (m *MockTChanNode) GetWriteNewSeriesAsync(ctx thrift.Context) (*NodeWriteNewSeriesAsyncResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesAsync", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesAsync indicates an expected call of GetWriteNewSeriesAsync -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesAsync(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesAsync), ctx) -} - -// GetWriteNewSeriesBackoffDuration mocks base method -func (m *MockTChanNode) GetWriteNewSeriesBackoffDuration(ctx thrift.Context) (*NodeWriteNewSeriesBackoffDurationResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesBackoffDuration", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesBackoffDuration indicates an expected call of GetWriteNewSeriesBackoffDuration -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesBackoffDuration(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesBackoffDuration), ctx) -} - -// GetWriteNewSeriesLimitPerShardPerSecond mocks base method -func (m *MockTChanNode) GetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesLimitPerShardPerSecond", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of GetWriteNewSeriesLimitPerShardPerSecond -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesLimitPerShardPerSecond(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesLimitPerShardPerSecond), ctx) -} - -// Health mocks base method -func (m *MockTChanNode) Health(ctx thrift.Context) (*NodeHealthResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Health", ctx) - ret0, _ := ret[0].(*NodeHealthResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Health indicates an expected call of Health -func (mr *MockTChanNodeMockRecorder) Health(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanNode)(nil).Health), ctx) -} - -// Query mocks base method -func (m *MockTChanNode) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Query", ctx, req) - ret0, _ := ret[0].(*QueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Query indicates an expected call of Query -func (mr *MockTChanNodeMockRecorder) Query(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanNode)(nil).Query), ctx, req) -} - -// Repair mocks base method -func (m *MockTChanNode) Repair(ctx thrift.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Repair", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// Repair indicates an expected call of Repair -func (mr *MockTChanNodeMockRecorder) Repair(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Repair", reflect.TypeOf((*MockTChanNode)(nil).Repair), ctx) -} - -// SetPersistRateLimit mocks base method -func (m *MockTChanNode) SetPersistRateLimit(ctx thrift.Context, req *NodeSetPersistRateLimitRequest) (*NodePersistRateLimitResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetPersistRateLimit", ctx, req) - ret0, _ := ret[0].(*NodePersistRateLimitResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetPersistRateLimit indicates an expected call of SetPersistRateLimit -func (mr *MockTChanNodeMockRecorder) SetPersistRateLimit(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).SetPersistRateLimit), ctx, req) -} - -// SetWriteNewSeriesAsync mocks base method -func (m *MockTChanNode) SetWriteNewSeriesAsync(ctx thrift.Context, req *NodeSetWriteNewSeriesAsyncRequest) (*NodeWriteNewSeriesAsyncResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesAsync", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesAsync indicates an expected call of SetWriteNewSeriesAsync -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesAsync(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesAsync), ctx, req) -} - -// SetWriteNewSeriesBackoffDuration mocks base method -func (m *MockTChanNode) SetWriteNewSeriesBackoffDuration(ctx thrift.Context, req *NodeSetWriteNewSeriesBackoffDurationRequest) (*NodeWriteNewSeriesBackoffDurationResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesBackoffDuration", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesBackoffDuration indicates an expected call of SetWriteNewSeriesBackoffDuration -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesBackoffDuration(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesBackoffDuration), ctx, req) -} - -// SetWriteNewSeriesLimitPerShardPerSecond mocks base method -func (m *MockTChanNode) SetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context, req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesLimitPerShardPerSecond", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of SetWriteNewSeriesLimitPerShardPerSecond -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesLimitPerShardPerSecond), ctx, req) -} - -// Truncate mocks base method -func (m *MockTChanNode) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Truncate", ctx, req) - ret0, _ := ret[0].(*TruncateResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Truncate indicates an expected call of Truncate -func (mr *MockTChanNodeMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanNode)(nil).Truncate), ctx, req) -} - -// Write mocks base method -func (m *MockTChanNode) Write(ctx thrift.Context, req *WriteRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Write", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// Write indicates an expected call of Write -func (mr *MockTChanNodeMockRecorder) Write(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanNode)(nil).Write), ctx, req) -} - -// WriteBatchRaw mocks base method -func (m *MockTChanNode) WriteBatchRaw(ctx thrift.Context, req *WriteBatchRawRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteBatchRaw", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteBatchRaw indicates an expected call of WriteBatchRaw -func (mr *MockTChanNodeMockRecorder) WriteBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRaw), ctx, req) -} - -// WriteBatchRawV2 mocks base method -func (m *MockTChanNode) WriteBatchRawV2(ctx thrift.Context, req *WriteBatchRawV2Request) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteBatchRawV2", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteBatchRawV2 indicates an expected call of WriteBatchRawV2 -func (mr *MockTChanNodeMockRecorder) WriteBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRawV2), ctx, req) -} - -// WriteTagged mocks base method -func (m *MockTChanNode) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTagged", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTagged indicates an expected call of WriteTagged -func (mr *MockTChanNodeMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanNode)(nil).WriteTagged), ctx, req) -} - -// WriteTaggedBatchRaw mocks base method -func (m *MockTChanNode) WriteTaggedBatchRaw(ctx thrift.Context, req *WriteTaggedBatchRawRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTaggedBatchRaw", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTaggedBatchRaw indicates an expected call of WriteTaggedBatchRaw -func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRaw), ctx, req) -} - -// WriteTaggedBatchRawV2 mocks base method -func (m *MockTChanNode) WriteTaggedBatchRawV2(ctx thrift.Context, req *WriteTaggedBatchRawV2Request) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTaggedBatchRawV2", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTaggedBatchRawV2 indicates an expected call of WriteTaggedBatchRawV2 -func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRawV2), ctx, req) -} 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 f7e88d4230..cfedac8782 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,99 @@ 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 + ) + if v := req.IntervalNanos; v != nil { + interval = time.Duration(*v) + } + if v := req.DurationNanos; v != nil { + duration = time.Duration(*v) + } + 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/x/debug/triggering_profile.go b/src/x/debug/triggering_profile.go new file mode 100644 index 0000000000..adecf5c196 --- /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") + errProfileName = 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, errProfileName + } + 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") + }) + } +} From 9a0314490bd8879ca5e1bce82a058f4ff906eb12 Mon Sep 17 00:00:00 2001 From: Rob Skillington Date: Tue, 16 Jun 2020 23:49:23 -0400 Subject: [PATCH 2/5] Add missing mock --- src/dbnode/generated/thrift/rpc/rpc_mock.go | 639 ++++++++++++++++++++ 1 file changed, 639 insertions(+) create mode 100644 src/dbnode/generated/thrift/rpc/rpc_mock.go diff --git a/src/dbnode/generated/thrift/rpc/rpc_mock.go b/src/dbnode/generated/thrift/rpc/rpc_mock.go new file mode 100644 index 0000000000..647e08992b --- /dev/null +++ b/src/dbnode/generated/thrift/rpc/rpc_mock.go @@ -0,0 +1,639 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/m3db/m3/src/dbnode/generated/thrift/rpc/tchan-go + +// 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 rpc is a generated GoMock package. +package rpc + +import ( + "reflect" + + "github.com/golang/mock/gomock" + "github.com/uber/tchannel-go/thrift" +) + +// MockTChanCluster is a mock of TChanCluster interface +type MockTChanCluster struct { + ctrl *gomock.Controller + recorder *MockTChanClusterMockRecorder +} + +// MockTChanClusterMockRecorder is the mock recorder for MockTChanCluster +type MockTChanClusterMockRecorder struct { + mock *MockTChanCluster +} + +// NewMockTChanCluster creates a new mock instance +func NewMockTChanCluster(ctrl *gomock.Controller) *MockTChanCluster { + mock := &MockTChanCluster{ctrl: ctrl} + mock.recorder = &MockTChanClusterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTChanCluster) EXPECT() *MockTChanClusterMockRecorder { + return m.recorder +} + +// Aggregate mocks base method +func (m *MockTChanCluster) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Aggregate", ctx, req) + ret0, _ := ret[0].(*AggregateQueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Aggregate indicates an expected call of Aggregate +func (mr *MockTChanClusterMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanCluster)(nil).Aggregate), ctx, req) +} + +// Fetch mocks base method +func (m *MockTChanCluster) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Fetch", ctx, req) + ret0, _ := ret[0].(*FetchResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Fetch indicates an expected call of Fetch +func (mr *MockTChanClusterMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanCluster)(nil).Fetch), ctx, req) +} + +// Health mocks base method +func (m *MockTChanCluster) Health(ctx thrift.Context) (*HealthResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", ctx) + ret0, _ := ret[0].(*HealthResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health +func (mr *MockTChanClusterMockRecorder) Health(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanCluster)(nil).Health), ctx) +} + +// Query mocks base method +func (m *MockTChanCluster) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, req) + ret0, _ := ret[0].(*QueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query +func (mr *MockTChanClusterMockRecorder) Query(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanCluster)(nil).Query), ctx, req) +} + +// Truncate mocks base method +func (m *MockTChanCluster) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Truncate", ctx, req) + ret0, _ := ret[0].(*TruncateResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Truncate indicates an expected call of Truncate +func (mr *MockTChanClusterMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanCluster)(nil).Truncate), ctx, req) +} + +// Write mocks base method +func (m *MockTChanCluster) Write(ctx thrift.Context, req *WriteRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// Write indicates an expected call of Write +func (mr *MockTChanClusterMockRecorder) Write(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanCluster)(nil).Write), ctx, req) +} + +// WriteTagged mocks base method +func (m *MockTChanCluster) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTagged", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTagged indicates an expected call of WriteTagged +func (mr *MockTChanClusterMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanCluster)(nil).WriteTagged), ctx, req) +} + +// MockTChanNode is a mock of TChanNode interface +type MockTChanNode struct { + ctrl *gomock.Controller + recorder *MockTChanNodeMockRecorder +} + +// MockTChanNodeMockRecorder is the mock recorder for MockTChanNode +type MockTChanNodeMockRecorder struct { + mock *MockTChanNode +} + +// NewMockTChanNode creates a new mock instance +func NewMockTChanNode(ctrl *gomock.Controller) *MockTChanNode { + mock := &MockTChanNode{ctrl: ctrl} + mock.recorder = &MockTChanNodeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTChanNode) EXPECT() *MockTChanNodeMockRecorder { + return m.recorder +} + +// Aggregate mocks base method +func (m *MockTChanNode) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Aggregate", ctx, req) + ret0, _ := ret[0].(*AggregateQueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Aggregate indicates an expected call of Aggregate +func (mr *MockTChanNodeMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanNode)(nil).Aggregate), ctx, req) +} + +// AggregateRaw mocks base method +func (m *MockTChanNode) AggregateRaw(ctx thrift.Context, req *AggregateQueryRawRequest) (*AggregateQueryRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AggregateRaw", ctx, req) + ret0, _ := ret[0].(*AggregateQueryRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AggregateRaw indicates an expected call of AggregateRaw +func (mr *MockTChanNodeMockRecorder) AggregateRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateRaw", reflect.TypeOf((*MockTChanNode)(nil).AggregateRaw), ctx, req) +} + +// Bootstrapped mocks base method +func (m *MockTChanNode) Bootstrapped(ctx thrift.Context) (*NodeBootstrappedResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrapped", ctx) + ret0, _ := ret[0].(*NodeBootstrappedResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Bootstrapped indicates an expected call of Bootstrapped +func (mr *MockTChanNodeMockRecorder) Bootstrapped(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrapped", reflect.TypeOf((*MockTChanNode)(nil).Bootstrapped), ctx) +} + +// BootstrappedInPlacementOrNoPlacement mocks base method +func (m *MockTChanNode) BootstrappedInPlacementOrNoPlacement(ctx thrift.Context) (*NodeBootstrappedInPlacementOrNoPlacementResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BootstrappedInPlacementOrNoPlacement", ctx) + ret0, _ := ret[0].(*NodeBootstrappedInPlacementOrNoPlacementResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BootstrappedInPlacementOrNoPlacement indicates an expected call of BootstrappedInPlacementOrNoPlacement +func (mr *MockTChanNodeMockRecorder) BootstrappedInPlacementOrNoPlacement(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootstrappedInPlacementOrNoPlacement", reflect.TypeOf((*MockTChanNode)(nil).BootstrappedInPlacementOrNoPlacement), ctx) +} + +// DebugIndexMemorySegments mocks base method +func (m *MockTChanNode) DebugIndexMemorySegments(ctx thrift.Context, req *DebugIndexMemorySegmentsRequest) (*DebugIndexMemorySegmentsResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugIndexMemorySegments", ctx, req) + ret0, _ := ret[0].(*DebugIndexMemorySegmentsResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DebugIndexMemorySegments indicates an expected call of DebugIndexMemorySegments +func (mr *MockTChanNodeMockRecorder) DebugIndexMemorySegments(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + 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() + ret := m.ctrl.Call(m, "Fetch", ctx, req) + ret0, _ := ret[0].(*FetchResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Fetch indicates an expected call of Fetch +func (mr *MockTChanNodeMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanNode)(nil).Fetch), ctx, req) +} + +// FetchBatchRaw mocks base method +func (m *MockTChanNode) FetchBatchRaw(ctx thrift.Context, req *FetchBatchRawRequest) (*FetchBatchRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBatchRaw", ctx, req) + ret0, _ := ret[0].(*FetchBatchRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBatchRaw indicates an expected call of FetchBatchRaw +func (mr *MockTChanNodeMockRecorder) FetchBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRaw), ctx, req) +} + +// FetchBatchRawV2 mocks base method +func (m *MockTChanNode) FetchBatchRawV2(ctx thrift.Context, req *FetchBatchRawV2Request) (*FetchBatchRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBatchRawV2", ctx, req) + ret0, _ := ret[0].(*FetchBatchRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBatchRawV2 indicates an expected call of FetchBatchRawV2 +func (mr *MockTChanNodeMockRecorder) FetchBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRawV2), ctx, req) +} + +// FetchBlocksMetadataRawV2 mocks base method +func (m *MockTChanNode) FetchBlocksMetadataRawV2(ctx thrift.Context, req *FetchBlocksMetadataRawV2Request) (*FetchBlocksMetadataRawV2Result_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBlocksMetadataRawV2", ctx, req) + ret0, _ := ret[0].(*FetchBlocksMetadataRawV2Result_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBlocksMetadataRawV2 indicates an expected call of FetchBlocksMetadataRawV2 +func (mr *MockTChanNodeMockRecorder) FetchBlocksMetadataRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksMetadataRawV2), ctx, req) +} + +// FetchBlocksRaw mocks base method +func (m *MockTChanNode) FetchBlocksRaw(ctx thrift.Context, req *FetchBlocksRawRequest) (*FetchBlocksRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBlocksRaw", ctx, req) + ret0, _ := ret[0].(*FetchBlocksRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBlocksRaw indicates an expected call of FetchBlocksRaw +func (mr *MockTChanNodeMockRecorder) FetchBlocksRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksRaw), ctx, req) +} + +// FetchTagged mocks base method +func (m *MockTChanNode) FetchTagged(ctx thrift.Context, req *FetchTaggedRequest) (*FetchTaggedResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchTagged", ctx, req) + ret0, _ := ret[0].(*FetchTaggedResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchTagged indicates an expected call of FetchTagged +func (mr *MockTChanNodeMockRecorder) FetchTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockTChanNode)(nil).FetchTagged), ctx, req) +} + +// GetPersistRateLimit mocks base method +func (m *MockTChanNode) GetPersistRateLimit(ctx thrift.Context) (*NodePersistRateLimitResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPersistRateLimit", ctx) + ret0, _ := ret[0].(*NodePersistRateLimitResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPersistRateLimit indicates an expected call of GetPersistRateLimit +func (mr *MockTChanNodeMockRecorder) GetPersistRateLimit(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).GetPersistRateLimit), ctx) +} + +// GetWriteNewSeriesAsync mocks base method +func (m *MockTChanNode) GetWriteNewSeriesAsync(ctx thrift.Context) (*NodeWriteNewSeriesAsyncResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesAsync", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesAsync indicates an expected call of GetWriteNewSeriesAsync +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesAsync), ctx) +} + +// GetWriteNewSeriesBackoffDuration mocks base method +func (m *MockTChanNode) GetWriteNewSeriesBackoffDuration(ctx thrift.Context) (*NodeWriteNewSeriesBackoffDurationResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesBackoffDuration", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesBackoffDuration indicates an expected call of GetWriteNewSeriesBackoffDuration +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesBackoffDuration(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesBackoffDuration), ctx) +} + +// GetWriteNewSeriesLimitPerShardPerSecond mocks base method +func (m *MockTChanNode) GetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesLimitPerShardPerSecond", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of GetWriteNewSeriesLimitPerShardPerSecond +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesLimitPerShardPerSecond(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesLimitPerShardPerSecond), ctx) +} + +// Health mocks base method +func (m *MockTChanNode) Health(ctx thrift.Context) (*NodeHealthResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", ctx) + ret0, _ := ret[0].(*NodeHealthResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health +func (mr *MockTChanNodeMockRecorder) Health(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanNode)(nil).Health), ctx) +} + +// Query mocks base method +func (m *MockTChanNode) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, req) + ret0, _ := ret[0].(*QueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query +func (mr *MockTChanNodeMockRecorder) Query(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanNode)(nil).Query), ctx, req) +} + +// Repair mocks base method +func (m *MockTChanNode) Repair(ctx thrift.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Repair", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// Repair indicates an expected call of Repair +func (mr *MockTChanNodeMockRecorder) Repair(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Repair", reflect.TypeOf((*MockTChanNode)(nil).Repair), ctx) +} + +// SetPersistRateLimit mocks base method +func (m *MockTChanNode) SetPersistRateLimit(ctx thrift.Context, req *NodeSetPersistRateLimitRequest) (*NodePersistRateLimitResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPersistRateLimit", ctx, req) + ret0, _ := ret[0].(*NodePersistRateLimitResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetPersistRateLimit indicates an expected call of SetPersistRateLimit +func (mr *MockTChanNodeMockRecorder) SetPersistRateLimit(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).SetPersistRateLimit), ctx, req) +} + +// SetWriteNewSeriesAsync mocks base method +func (m *MockTChanNode) SetWriteNewSeriesAsync(ctx thrift.Context, req *NodeSetWriteNewSeriesAsyncRequest) (*NodeWriteNewSeriesAsyncResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesAsync", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesAsync indicates an expected call of SetWriteNewSeriesAsync +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesAsync(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesAsync), ctx, req) +} + +// SetWriteNewSeriesBackoffDuration mocks base method +func (m *MockTChanNode) SetWriteNewSeriesBackoffDuration(ctx thrift.Context, req *NodeSetWriteNewSeriesBackoffDurationRequest) (*NodeWriteNewSeriesBackoffDurationResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesBackoffDuration", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesBackoffDuration indicates an expected call of SetWriteNewSeriesBackoffDuration +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesBackoffDuration(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesBackoffDuration), ctx, req) +} + +// SetWriteNewSeriesLimitPerShardPerSecond mocks base method +func (m *MockTChanNode) SetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context, req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesLimitPerShardPerSecond", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of SetWriteNewSeriesLimitPerShardPerSecond +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesLimitPerShardPerSecond), ctx, req) +} + +// Truncate mocks base method +func (m *MockTChanNode) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Truncate", ctx, req) + ret0, _ := ret[0].(*TruncateResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Truncate indicates an expected call of Truncate +func (mr *MockTChanNodeMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanNode)(nil).Truncate), ctx, req) +} + +// Write mocks base method +func (m *MockTChanNode) Write(ctx thrift.Context, req *WriteRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// Write indicates an expected call of Write +func (mr *MockTChanNodeMockRecorder) Write(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanNode)(nil).Write), ctx, req) +} + +// WriteBatchRaw mocks base method +func (m *MockTChanNode) WriteBatchRaw(ctx thrift.Context, req *WriteBatchRawRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteBatchRaw", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteBatchRaw indicates an expected call of WriteBatchRaw +func (mr *MockTChanNodeMockRecorder) WriteBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRaw), ctx, req) +} + +// WriteBatchRawV2 mocks base method +func (m *MockTChanNode) WriteBatchRawV2(ctx thrift.Context, req *WriteBatchRawV2Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteBatchRawV2", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteBatchRawV2 indicates an expected call of WriteBatchRawV2 +func (mr *MockTChanNodeMockRecorder) WriteBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRawV2), ctx, req) +} + +// WriteTagged mocks base method +func (m *MockTChanNode) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTagged", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTagged indicates an expected call of WriteTagged +func (mr *MockTChanNodeMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanNode)(nil).WriteTagged), ctx, req) +} + +// WriteTaggedBatchRaw mocks base method +func (m *MockTChanNode) WriteTaggedBatchRaw(ctx thrift.Context, req *WriteTaggedBatchRawRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTaggedBatchRaw", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTaggedBatchRaw indicates an expected call of WriteTaggedBatchRaw +func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRaw), ctx, req) +} + +// WriteTaggedBatchRawV2 mocks base method +func (m *MockTChanNode) WriteTaggedBatchRawV2(ctx thrift.Context, req *WriteTaggedBatchRawV2Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTaggedBatchRawV2", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTaggedBatchRawV2 indicates an expected call of WriteTaggedBatchRawV2 +func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRawV2), ctx, req) +} From 90d0a1a3b22f4a370a3cf2a76ea64a86c1c401c5 Mon Sep 17 00:00:00 2001 From: Rob Skillington Date: Wed, 17 Jun 2020 00:19:29 -0400 Subject: [PATCH 3/5] Parse interval and duration --- src/dbnode/generated/thrift/rpc.thrift | 4 +- src/dbnode/generated/thrift/rpc/rpc.go | 80 +-- src/dbnode/generated/thrift/rpc/rpc_mock.go | 639 ------------------ .../server/tchannelthrift/node/service.go | 15 +- 4 files changed, 53 insertions(+), 685 deletions(-) delete mode 100644 src/dbnode/generated/thrift/rpc/rpc_mock.go diff --git a/src/dbnode/generated/thrift/rpc.thrift b/src/dbnode/generated/thrift/rpc.thrift index 775d19e319..1f5adf1c25 100644 --- a/src/dbnode/generated/thrift/rpc.thrift +++ b/src/dbnode/generated/thrift/rpc.thrift @@ -493,8 +493,8 @@ struct Query { struct DebugProfileStartRequest { 1: required string name 2: required string filePathTemplate - 3: optional i64 intervalNanos - 4: optional i64 durationNanos + 3: optional string interval + 4: optional string duration 5: optional i64 debug 6: optional i64 conditionalNumGoroutinesGreaterThan 7: optional i64 conditionalNumGoroutinesLessThan diff --git a/src/dbnode/generated/thrift/rpc/rpc.go b/src/dbnode/generated/thrift/rpc/rpc.go index 28276e591d..b0242cd18c 100644 --- a/src/dbnode/generated/thrift/rpc/rpc.go +++ b/src/dbnode/generated/thrift/rpc/rpc.go @@ -12863,21 +12863,21 @@ func (p *Query) String() string { // Attributes: // - Name // - FilePathTemplate -// - IntervalNanos -// - DurationNanos +// - 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"` - IntervalNanos *int64 `thrift:"intervalNanos,3" db:"intervalNanos" json:"intervalNanos,omitempty"` - DurationNanos *int64 `thrift:"durationNanos,4" db:"durationNanos" json:"durationNanos,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"` + 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 { @@ -12892,22 +12892,22 @@ func (p *DebugProfileStartRequest) GetFilePathTemplate() string { return p.FilePathTemplate } -var DebugProfileStartRequest_IntervalNanos_DEFAULT int64 +var DebugProfileStartRequest_Interval_DEFAULT string -func (p *DebugProfileStartRequest) GetIntervalNanos() int64 { - if !p.IsSetIntervalNanos() { - return DebugProfileStartRequest_IntervalNanos_DEFAULT +func (p *DebugProfileStartRequest) GetInterval() string { + if !p.IsSetInterval() { + return DebugProfileStartRequest_Interval_DEFAULT } - return *p.IntervalNanos + return *p.Interval } -var DebugProfileStartRequest_DurationNanos_DEFAULT int64 +var DebugProfileStartRequest_Duration_DEFAULT string -func (p *DebugProfileStartRequest) GetDurationNanos() int64 { - if !p.IsSetDurationNanos() { - return DebugProfileStartRequest_DurationNanos_DEFAULT +func (p *DebugProfileStartRequest) GetDuration() string { + if !p.IsSetDuration() { + return DebugProfileStartRequest_Duration_DEFAULT } - return *p.DurationNanos + return *p.Duration } var DebugProfileStartRequest_Debug_DEFAULT int64 @@ -12945,12 +12945,12 @@ func (p *DebugProfileStartRequest) GetConditionalIsOverloaded() bool { } return *p.ConditionalIsOverloaded } -func (p *DebugProfileStartRequest) IsSetIntervalNanos() bool { - return p.IntervalNanos != nil +func (p *DebugProfileStartRequest) IsSetInterval() bool { + return p.Interval != nil } -func (p *DebugProfileStartRequest) IsSetDurationNanos() bool { - return p.DurationNanos != nil +func (p *DebugProfileStartRequest) IsSetDuration() bool { + return p.Duration != nil } func (p *DebugProfileStartRequest) IsSetDebug() bool { @@ -13060,19 +13060,19 @@ func (p *DebugProfileStartRequest) ReadField2(iprot thrift.TProtocol) error { } func (p *DebugProfileStartRequest) ReadField3(iprot thrift.TProtocol) error { - if v, err := iprot.ReadI64(); err != nil { + if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 3: ", err) } else { - p.IntervalNanos = &v + p.Interval = &v } return nil } func (p *DebugProfileStartRequest) ReadField4(iprot thrift.TProtocol) error { - if v, err := iprot.ReadI64(); err != nil { + if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 4: ", err) } else { - p.DurationNanos = &v + p.Duration = &v } return nil } @@ -13179,30 +13179,30 @@ func (p *DebugProfileStartRequest) writeField2(oprot thrift.TProtocol) (err erro } func (p *DebugProfileStartRequest) writeField3(oprot thrift.TProtocol) (err error) { - if p.IsSetIntervalNanos() { - if err := oprot.WriteFieldBegin("intervalNanos", thrift.I64, 3); err != nil { - return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:intervalNanos: ", p), err) + 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.WriteI64(int64(*p.IntervalNanos)); err != nil { - return thrift.PrependError(fmt.Sprintf("%T.intervalNanos (3) field write error: ", 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:intervalNanos: ", p), err) + 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.IsSetDurationNanos() { - if err := oprot.WriteFieldBegin("durationNanos", thrift.I64, 4); err != nil { - return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:durationNanos: ", p), err) + 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.WriteI64(int64(*p.DurationNanos)); err != nil { - return thrift.PrependError(fmt.Sprintf("%T.durationNanos (4) field write error: ", 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:durationNanos: ", p), err) + return thrift.PrependError(fmt.Sprintf("%T write field end error 4:duration: ", p), err) } } return err diff --git a/src/dbnode/generated/thrift/rpc/rpc_mock.go b/src/dbnode/generated/thrift/rpc/rpc_mock.go deleted file mode 100644 index 647e08992b..0000000000 --- a/src/dbnode/generated/thrift/rpc/rpc_mock.go +++ /dev/null @@ -1,639 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/m3db/m3/src/dbnode/generated/thrift/rpc/tchan-go - -// 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 rpc is a generated GoMock package. -package rpc - -import ( - "reflect" - - "github.com/golang/mock/gomock" - "github.com/uber/tchannel-go/thrift" -) - -// MockTChanCluster is a mock of TChanCluster interface -type MockTChanCluster struct { - ctrl *gomock.Controller - recorder *MockTChanClusterMockRecorder -} - -// MockTChanClusterMockRecorder is the mock recorder for MockTChanCluster -type MockTChanClusterMockRecorder struct { - mock *MockTChanCluster -} - -// NewMockTChanCluster creates a new mock instance -func NewMockTChanCluster(ctrl *gomock.Controller) *MockTChanCluster { - mock := &MockTChanCluster{ctrl: ctrl} - mock.recorder = &MockTChanClusterMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTChanCluster) EXPECT() *MockTChanClusterMockRecorder { - return m.recorder -} - -// Aggregate mocks base method -func (m *MockTChanCluster) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Aggregate", ctx, req) - ret0, _ := ret[0].(*AggregateQueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Aggregate indicates an expected call of Aggregate -func (mr *MockTChanClusterMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanCluster)(nil).Aggregate), ctx, req) -} - -// Fetch mocks base method -func (m *MockTChanCluster) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Fetch", ctx, req) - ret0, _ := ret[0].(*FetchResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Fetch indicates an expected call of Fetch -func (mr *MockTChanClusterMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanCluster)(nil).Fetch), ctx, req) -} - -// Health mocks base method -func (m *MockTChanCluster) Health(ctx thrift.Context) (*HealthResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Health", ctx) - ret0, _ := ret[0].(*HealthResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Health indicates an expected call of Health -func (mr *MockTChanClusterMockRecorder) Health(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanCluster)(nil).Health), ctx) -} - -// Query mocks base method -func (m *MockTChanCluster) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Query", ctx, req) - ret0, _ := ret[0].(*QueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Query indicates an expected call of Query -func (mr *MockTChanClusterMockRecorder) Query(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanCluster)(nil).Query), ctx, req) -} - -// Truncate mocks base method -func (m *MockTChanCluster) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Truncate", ctx, req) - ret0, _ := ret[0].(*TruncateResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Truncate indicates an expected call of Truncate -func (mr *MockTChanClusterMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanCluster)(nil).Truncate), ctx, req) -} - -// Write mocks base method -func (m *MockTChanCluster) Write(ctx thrift.Context, req *WriteRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Write", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// Write indicates an expected call of Write -func (mr *MockTChanClusterMockRecorder) Write(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanCluster)(nil).Write), ctx, req) -} - -// WriteTagged mocks base method -func (m *MockTChanCluster) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTagged", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTagged indicates an expected call of WriteTagged -func (mr *MockTChanClusterMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanCluster)(nil).WriteTagged), ctx, req) -} - -// MockTChanNode is a mock of TChanNode interface -type MockTChanNode struct { - ctrl *gomock.Controller - recorder *MockTChanNodeMockRecorder -} - -// MockTChanNodeMockRecorder is the mock recorder for MockTChanNode -type MockTChanNodeMockRecorder struct { - mock *MockTChanNode -} - -// NewMockTChanNode creates a new mock instance -func NewMockTChanNode(ctrl *gomock.Controller) *MockTChanNode { - mock := &MockTChanNode{ctrl: ctrl} - mock.recorder = &MockTChanNodeMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTChanNode) EXPECT() *MockTChanNodeMockRecorder { - return m.recorder -} - -// Aggregate mocks base method -func (m *MockTChanNode) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Aggregate", ctx, req) - ret0, _ := ret[0].(*AggregateQueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Aggregate indicates an expected call of Aggregate -func (mr *MockTChanNodeMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanNode)(nil).Aggregate), ctx, req) -} - -// AggregateRaw mocks base method -func (m *MockTChanNode) AggregateRaw(ctx thrift.Context, req *AggregateQueryRawRequest) (*AggregateQueryRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AggregateRaw", ctx, req) - ret0, _ := ret[0].(*AggregateQueryRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AggregateRaw indicates an expected call of AggregateRaw -func (mr *MockTChanNodeMockRecorder) AggregateRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateRaw", reflect.TypeOf((*MockTChanNode)(nil).AggregateRaw), ctx, req) -} - -// Bootstrapped mocks base method -func (m *MockTChanNode) Bootstrapped(ctx thrift.Context) (*NodeBootstrappedResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Bootstrapped", ctx) - ret0, _ := ret[0].(*NodeBootstrappedResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Bootstrapped indicates an expected call of Bootstrapped -func (mr *MockTChanNodeMockRecorder) Bootstrapped(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrapped", reflect.TypeOf((*MockTChanNode)(nil).Bootstrapped), ctx) -} - -// BootstrappedInPlacementOrNoPlacement mocks base method -func (m *MockTChanNode) BootstrappedInPlacementOrNoPlacement(ctx thrift.Context) (*NodeBootstrappedInPlacementOrNoPlacementResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BootstrappedInPlacementOrNoPlacement", ctx) - ret0, _ := ret[0].(*NodeBootstrappedInPlacementOrNoPlacementResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BootstrappedInPlacementOrNoPlacement indicates an expected call of BootstrappedInPlacementOrNoPlacement -func (mr *MockTChanNodeMockRecorder) BootstrappedInPlacementOrNoPlacement(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootstrappedInPlacementOrNoPlacement", reflect.TypeOf((*MockTChanNode)(nil).BootstrappedInPlacementOrNoPlacement), ctx) -} - -// DebugIndexMemorySegments mocks base method -func (m *MockTChanNode) DebugIndexMemorySegments(ctx thrift.Context, req *DebugIndexMemorySegmentsRequest) (*DebugIndexMemorySegmentsResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DebugIndexMemorySegments", ctx, req) - ret0, _ := ret[0].(*DebugIndexMemorySegmentsResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DebugIndexMemorySegments indicates an expected call of DebugIndexMemorySegments -func (mr *MockTChanNodeMockRecorder) DebugIndexMemorySegments(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - 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() - ret := m.ctrl.Call(m, "Fetch", ctx, req) - ret0, _ := ret[0].(*FetchResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Fetch indicates an expected call of Fetch -func (mr *MockTChanNodeMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanNode)(nil).Fetch), ctx, req) -} - -// FetchBatchRaw mocks base method -func (m *MockTChanNode) FetchBatchRaw(ctx thrift.Context, req *FetchBatchRawRequest) (*FetchBatchRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBatchRaw", ctx, req) - ret0, _ := ret[0].(*FetchBatchRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBatchRaw indicates an expected call of FetchBatchRaw -func (mr *MockTChanNodeMockRecorder) FetchBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRaw), ctx, req) -} - -// FetchBatchRawV2 mocks base method -func (m *MockTChanNode) FetchBatchRawV2(ctx thrift.Context, req *FetchBatchRawV2Request) (*FetchBatchRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBatchRawV2", ctx, req) - ret0, _ := ret[0].(*FetchBatchRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBatchRawV2 indicates an expected call of FetchBatchRawV2 -func (mr *MockTChanNodeMockRecorder) FetchBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRawV2), ctx, req) -} - -// FetchBlocksMetadataRawV2 mocks base method -func (m *MockTChanNode) FetchBlocksMetadataRawV2(ctx thrift.Context, req *FetchBlocksMetadataRawV2Request) (*FetchBlocksMetadataRawV2Result_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBlocksMetadataRawV2", ctx, req) - ret0, _ := ret[0].(*FetchBlocksMetadataRawV2Result_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBlocksMetadataRawV2 indicates an expected call of FetchBlocksMetadataRawV2 -func (mr *MockTChanNodeMockRecorder) FetchBlocksMetadataRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksMetadataRawV2), ctx, req) -} - -// FetchBlocksRaw mocks base method -func (m *MockTChanNode) FetchBlocksRaw(ctx thrift.Context, req *FetchBlocksRawRequest) (*FetchBlocksRawResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchBlocksRaw", ctx, req) - ret0, _ := ret[0].(*FetchBlocksRawResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchBlocksRaw indicates an expected call of FetchBlocksRaw -func (mr *MockTChanNodeMockRecorder) FetchBlocksRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksRaw), ctx, req) -} - -// FetchTagged mocks base method -func (m *MockTChanNode) FetchTagged(ctx thrift.Context, req *FetchTaggedRequest) (*FetchTaggedResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FetchTagged", ctx, req) - ret0, _ := ret[0].(*FetchTaggedResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FetchTagged indicates an expected call of FetchTagged -func (mr *MockTChanNodeMockRecorder) FetchTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockTChanNode)(nil).FetchTagged), ctx, req) -} - -// GetPersistRateLimit mocks base method -func (m *MockTChanNode) GetPersistRateLimit(ctx thrift.Context) (*NodePersistRateLimitResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPersistRateLimit", ctx) - ret0, _ := ret[0].(*NodePersistRateLimitResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPersistRateLimit indicates an expected call of GetPersistRateLimit -func (mr *MockTChanNodeMockRecorder) GetPersistRateLimit(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).GetPersistRateLimit), ctx) -} - -// GetWriteNewSeriesAsync mocks base method -func (m *MockTChanNode) GetWriteNewSeriesAsync(ctx thrift.Context) (*NodeWriteNewSeriesAsyncResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesAsync", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesAsync indicates an expected call of GetWriteNewSeriesAsync -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesAsync(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesAsync), ctx) -} - -// GetWriteNewSeriesBackoffDuration mocks base method -func (m *MockTChanNode) GetWriteNewSeriesBackoffDuration(ctx thrift.Context) (*NodeWriteNewSeriesBackoffDurationResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesBackoffDuration", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesBackoffDuration indicates an expected call of GetWriteNewSeriesBackoffDuration -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesBackoffDuration(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesBackoffDuration), ctx) -} - -// GetWriteNewSeriesLimitPerShardPerSecond mocks base method -func (m *MockTChanNode) GetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetWriteNewSeriesLimitPerShardPerSecond", ctx) - ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of GetWriteNewSeriesLimitPerShardPerSecond -func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesLimitPerShardPerSecond(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesLimitPerShardPerSecond), ctx) -} - -// Health mocks base method -func (m *MockTChanNode) Health(ctx thrift.Context) (*NodeHealthResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Health", ctx) - ret0, _ := ret[0].(*NodeHealthResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Health indicates an expected call of Health -func (mr *MockTChanNodeMockRecorder) Health(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanNode)(nil).Health), ctx) -} - -// Query mocks base method -func (m *MockTChanNode) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Query", ctx, req) - ret0, _ := ret[0].(*QueryResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Query indicates an expected call of Query -func (mr *MockTChanNodeMockRecorder) Query(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanNode)(nil).Query), ctx, req) -} - -// Repair mocks base method -func (m *MockTChanNode) Repair(ctx thrift.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Repair", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// Repair indicates an expected call of Repair -func (mr *MockTChanNodeMockRecorder) Repair(ctx interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Repair", reflect.TypeOf((*MockTChanNode)(nil).Repair), ctx) -} - -// SetPersistRateLimit mocks base method -func (m *MockTChanNode) SetPersistRateLimit(ctx thrift.Context, req *NodeSetPersistRateLimitRequest) (*NodePersistRateLimitResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetPersistRateLimit", ctx, req) - ret0, _ := ret[0].(*NodePersistRateLimitResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetPersistRateLimit indicates an expected call of SetPersistRateLimit -func (mr *MockTChanNodeMockRecorder) SetPersistRateLimit(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).SetPersistRateLimit), ctx, req) -} - -// SetWriteNewSeriesAsync mocks base method -func (m *MockTChanNode) SetWriteNewSeriesAsync(ctx thrift.Context, req *NodeSetWriteNewSeriesAsyncRequest) (*NodeWriteNewSeriesAsyncResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesAsync", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesAsync indicates an expected call of SetWriteNewSeriesAsync -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesAsync(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesAsync), ctx, req) -} - -// SetWriteNewSeriesBackoffDuration mocks base method -func (m *MockTChanNode) SetWriteNewSeriesBackoffDuration(ctx thrift.Context, req *NodeSetWriteNewSeriesBackoffDurationRequest) (*NodeWriteNewSeriesBackoffDurationResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesBackoffDuration", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesBackoffDuration indicates an expected call of SetWriteNewSeriesBackoffDuration -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesBackoffDuration(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesBackoffDuration), ctx, req) -} - -// SetWriteNewSeriesLimitPerShardPerSecond mocks base method -func (m *MockTChanNode) SetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context, req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetWriteNewSeriesLimitPerShardPerSecond", ctx, req) - ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of SetWriteNewSeriesLimitPerShardPerSecond -func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesLimitPerShardPerSecond), ctx, req) -} - -// Truncate mocks base method -func (m *MockTChanNode) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Truncate", ctx, req) - ret0, _ := ret[0].(*TruncateResult_) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Truncate indicates an expected call of Truncate -func (mr *MockTChanNodeMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanNode)(nil).Truncate), ctx, req) -} - -// Write mocks base method -func (m *MockTChanNode) Write(ctx thrift.Context, req *WriteRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Write", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// Write indicates an expected call of Write -func (mr *MockTChanNodeMockRecorder) Write(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanNode)(nil).Write), ctx, req) -} - -// WriteBatchRaw mocks base method -func (m *MockTChanNode) WriteBatchRaw(ctx thrift.Context, req *WriteBatchRawRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteBatchRaw", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteBatchRaw indicates an expected call of WriteBatchRaw -func (mr *MockTChanNodeMockRecorder) WriteBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRaw), ctx, req) -} - -// WriteBatchRawV2 mocks base method -func (m *MockTChanNode) WriteBatchRawV2(ctx thrift.Context, req *WriteBatchRawV2Request) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteBatchRawV2", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteBatchRawV2 indicates an expected call of WriteBatchRawV2 -func (mr *MockTChanNodeMockRecorder) WriteBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRawV2), ctx, req) -} - -// WriteTagged mocks base method -func (m *MockTChanNode) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTagged", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTagged indicates an expected call of WriteTagged -func (mr *MockTChanNodeMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanNode)(nil).WriteTagged), ctx, req) -} - -// WriteTaggedBatchRaw mocks base method -func (m *MockTChanNode) WriteTaggedBatchRaw(ctx thrift.Context, req *WriteTaggedBatchRawRequest) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTaggedBatchRaw", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTaggedBatchRaw indicates an expected call of WriteTaggedBatchRaw -func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRaw(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRaw), ctx, req) -} - -// WriteTaggedBatchRawV2 mocks base method -func (m *MockTChanNode) WriteTaggedBatchRawV2(ctx thrift.Context, req *WriteTaggedBatchRawV2Request) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WriteTaggedBatchRawV2", ctx, req) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteTaggedBatchRawV2 indicates an expected call of WriteTaggedBatchRawV2 -func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRawV2(ctx, req interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRawV2), ctx, req) -} diff --git a/src/dbnode/network/server/tchannelthrift/node/service.go b/src/dbnode/network/server/tchannelthrift/node/service.go index cfedac8782..6e35a4d711 100644 --- a/src/dbnode/network/server/tchannelthrift/node/service.go +++ b/src/dbnode/network/server/tchannelthrift/node/service.go @@ -1999,12 +1999,19 @@ func (s *service) DebugProfileStart( interval time.Duration duration time.Duration debug int + err error ) - if v := req.IntervalNanos; v != nil { - interval = time.Duration(*v) + if v := req.Interval; v != nil { + interval, err = time.ParseDuration(*v) + if err != nil { + return nil, tterrors.NewBadRequestError(err) + } } - if v := req.DurationNanos; v != nil { - duration = time.Duration(*v) + 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) From 15cc881bc57594b4ed505a125538c2df1f552270 Mon Sep 17 00:00:00 2001 From: Rob Skillington Date: Wed, 17 Jun 2020 14:49:34 -0400 Subject: [PATCH 4/5] Address feedback --- src/dbnode/storage/namespace.go | 11 ++++++----- src/x/debug/triggering_profile.go | 4 ++-- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/dbnode/storage/namespace.go b/src/dbnode/storage/namespace.go index a45065acbe..09ff809be7 100644 --- a/src/dbnode/storage/namespace.go +++ b/src/dbnode/storage/namespace.go @@ -302,13 +302,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 index adecf5c196..473e8b6756 100644 --- a/src/x/debug/triggering_profile.go +++ b/src/x/debug/triggering_profile.go @@ -43,7 +43,7 @@ var ( defaultConditional = func() bool { return true } defaultInterval = time.Second errNoFilePathTemplate = errors.New("no file path template") - errProfileName = errors.New("no profile name") + errNoProfileName = errors.New("no profile name") errNoInstrumentOptions = errors.New("no instrument options") errAlreadyOpen = errors.New("already open") errNotOpen = errors.New("not open") @@ -90,7 +90,7 @@ func NewContinuousFileProfile( return nil, errNoFilePathTemplate } if opts.ProfileName == "" { - return nil, errProfileName + return nil, errNoProfileName } if opts.Conditional == nil { opts.Conditional = defaultConditional From 8c6053244c2afb140e8de528ed08fd4850f7a124 Mon Sep 17 00:00:00 2001 From: Rob Skillington Date: Wed, 17 Jun 2020 17:28:30 -0400 Subject: [PATCH 5/5] Add missing mock --- src/dbnode/generated/thrift/rpc/rpc_mock.go | 639 ++++++++++++++++++++ 1 file changed, 639 insertions(+) create mode 100644 src/dbnode/generated/thrift/rpc/rpc_mock.go diff --git a/src/dbnode/generated/thrift/rpc/rpc_mock.go b/src/dbnode/generated/thrift/rpc/rpc_mock.go new file mode 100644 index 0000000000..647e08992b --- /dev/null +++ b/src/dbnode/generated/thrift/rpc/rpc_mock.go @@ -0,0 +1,639 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/m3db/m3/src/dbnode/generated/thrift/rpc/tchan-go + +// 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 rpc is a generated GoMock package. +package rpc + +import ( + "reflect" + + "github.com/golang/mock/gomock" + "github.com/uber/tchannel-go/thrift" +) + +// MockTChanCluster is a mock of TChanCluster interface +type MockTChanCluster struct { + ctrl *gomock.Controller + recorder *MockTChanClusterMockRecorder +} + +// MockTChanClusterMockRecorder is the mock recorder for MockTChanCluster +type MockTChanClusterMockRecorder struct { + mock *MockTChanCluster +} + +// NewMockTChanCluster creates a new mock instance +func NewMockTChanCluster(ctrl *gomock.Controller) *MockTChanCluster { + mock := &MockTChanCluster{ctrl: ctrl} + mock.recorder = &MockTChanClusterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTChanCluster) EXPECT() *MockTChanClusterMockRecorder { + return m.recorder +} + +// Aggregate mocks base method +func (m *MockTChanCluster) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Aggregate", ctx, req) + ret0, _ := ret[0].(*AggregateQueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Aggregate indicates an expected call of Aggregate +func (mr *MockTChanClusterMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanCluster)(nil).Aggregate), ctx, req) +} + +// Fetch mocks base method +func (m *MockTChanCluster) Fetch(ctx thrift.Context, req *FetchRequest) (*FetchResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Fetch", ctx, req) + ret0, _ := ret[0].(*FetchResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Fetch indicates an expected call of Fetch +func (mr *MockTChanClusterMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanCluster)(nil).Fetch), ctx, req) +} + +// Health mocks base method +func (m *MockTChanCluster) Health(ctx thrift.Context) (*HealthResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", ctx) + ret0, _ := ret[0].(*HealthResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health +func (mr *MockTChanClusterMockRecorder) Health(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanCluster)(nil).Health), ctx) +} + +// Query mocks base method +func (m *MockTChanCluster) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, req) + ret0, _ := ret[0].(*QueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query +func (mr *MockTChanClusterMockRecorder) Query(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanCluster)(nil).Query), ctx, req) +} + +// Truncate mocks base method +func (m *MockTChanCluster) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Truncate", ctx, req) + ret0, _ := ret[0].(*TruncateResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Truncate indicates an expected call of Truncate +func (mr *MockTChanClusterMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanCluster)(nil).Truncate), ctx, req) +} + +// Write mocks base method +func (m *MockTChanCluster) Write(ctx thrift.Context, req *WriteRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// Write indicates an expected call of Write +func (mr *MockTChanClusterMockRecorder) Write(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanCluster)(nil).Write), ctx, req) +} + +// WriteTagged mocks base method +func (m *MockTChanCluster) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTagged", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTagged indicates an expected call of WriteTagged +func (mr *MockTChanClusterMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanCluster)(nil).WriteTagged), ctx, req) +} + +// MockTChanNode is a mock of TChanNode interface +type MockTChanNode struct { + ctrl *gomock.Controller + recorder *MockTChanNodeMockRecorder +} + +// MockTChanNodeMockRecorder is the mock recorder for MockTChanNode +type MockTChanNodeMockRecorder struct { + mock *MockTChanNode +} + +// NewMockTChanNode creates a new mock instance +func NewMockTChanNode(ctrl *gomock.Controller) *MockTChanNode { + mock := &MockTChanNode{ctrl: ctrl} + mock.recorder = &MockTChanNodeMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTChanNode) EXPECT() *MockTChanNodeMockRecorder { + return m.recorder +} + +// Aggregate mocks base method +func (m *MockTChanNode) Aggregate(ctx thrift.Context, req *AggregateQueryRequest) (*AggregateQueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Aggregate", ctx, req) + ret0, _ := ret[0].(*AggregateQueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Aggregate indicates an expected call of Aggregate +func (mr *MockTChanNodeMockRecorder) Aggregate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockTChanNode)(nil).Aggregate), ctx, req) +} + +// AggregateRaw mocks base method +func (m *MockTChanNode) AggregateRaw(ctx thrift.Context, req *AggregateQueryRawRequest) (*AggregateQueryRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AggregateRaw", ctx, req) + ret0, _ := ret[0].(*AggregateQueryRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AggregateRaw indicates an expected call of AggregateRaw +func (mr *MockTChanNodeMockRecorder) AggregateRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateRaw", reflect.TypeOf((*MockTChanNode)(nil).AggregateRaw), ctx, req) +} + +// Bootstrapped mocks base method +func (m *MockTChanNode) Bootstrapped(ctx thrift.Context) (*NodeBootstrappedResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrapped", ctx) + ret0, _ := ret[0].(*NodeBootstrappedResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Bootstrapped indicates an expected call of Bootstrapped +func (mr *MockTChanNodeMockRecorder) Bootstrapped(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrapped", reflect.TypeOf((*MockTChanNode)(nil).Bootstrapped), ctx) +} + +// BootstrappedInPlacementOrNoPlacement mocks base method +func (m *MockTChanNode) BootstrappedInPlacementOrNoPlacement(ctx thrift.Context) (*NodeBootstrappedInPlacementOrNoPlacementResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BootstrappedInPlacementOrNoPlacement", ctx) + ret0, _ := ret[0].(*NodeBootstrappedInPlacementOrNoPlacementResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BootstrappedInPlacementOrNoPlacement indicates an expected call of BootstrappedInPlacementOrNoPlacement +func (mr *MockTChanNodeMockRecorder) BootstrappedInPlacementOrNoPlacement(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootstrappedInPlacementOrNoPlacement", reflect.TypeOf((*MockTChanNode)(nil).BootstrappedInPlacementOrNoPlacement), ctx) +} + +// DebugIndexMemorySegments mocks base method +func (m *MockTChanNode) DebugIndexMemorySegments(ctx thrift.Context, req *DebugIndexMemorySegmentsRequest) (*DebugIndexMemorySegmentsResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugIndexMemorySegments", ctx, req) + ret0, _ := ret[0].(*DebugIndexMemorySegmentsResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DebugIndexMemorySegments indicates an expected call of DebugIndexMemorySegments +func (mr *MockTChanNodeMockRecorder) DebugIndexMemorySegments(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + 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() + ret := m.ctrl.Call(m, "Fetch", ctx, req) + ret0, _ := ret[0].(*FetchResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Fetch indicates an expected call of Fetch +func (mr *MockTChanNodeMockRecorder) Fetch(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockTChanNode)(nil).Fetch), ctx, req) +} + +// FetchBatchRaw mocks base method +func (m *MockTChanNode) FetchBatchRaw(ctx thrift.Context, req *FetchBatchRawRequest) (*FetchBatchRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBatchRaw", ctx, req) + ret0, _ := ret[0].(*FetchBatchRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBatchRaw indicates an expected call of FetchBatchRaw +func (mr *MockTChanNodeMockRecorder) FetchBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRaw), ctx, req) +} + +// FetchBatchRawV2 mocks base method +func (m *MockTChanNode) FetchBatchRawV2(ctx thrift.Context, req *FetchBatchRawV2Request) (*FetchBatchRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBatchRawV2", ctx, req) + ret0, _ := ret[0].(*FetchBatchRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBatchRawV2 indicates an expected call of FetchBatchRawV2 +func (mr *MockTChanNodeMockRecorder) FetchBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBatchRawV2), ctx, req) +} + +// FetchBlocksMetadataRawV2 mocks base method +func (m *MockTChanNode) FetchBlocksMetadataRawV2(ctx thrift.Context, req *FetchBlocksMetadataRawV2Request) (*FetchBlocksMetadataRawV2Result_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBlocksMetadataRawV2", ctx, req) + ret0, _ := ret[0].(*FetchBlocksMetadataRawV2Result_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBlocksMetadataRawV2 indicates an expected call of FetchBlocksMetadataRawV2 +func (mr *MockTChanNodeMockRecorder) FetchBlocksMetadataRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataRawV2", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksMetadataRawV2), ctx, req) +} + +// FetchBlocksRaw mocks base method +func (m *MockTChanNode) FetchBlocksRaw(ctx thrift.Context, req *FetchBlocksRawRequest) (*FetchBlocksRawResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchBlocksRaw", ctx, req) + ret0, _ := ret[0].(*FetchBlocksRawResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchBlocksRaw indicates an expected call of FetchBlocksRaw +func (mr *MockTChanNodeMockRecorder) FetchBlocksRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksRaw", reflect.TypeOf((*MockTChanNode)(nil).FetchBlocksRaw), ctx, req) +} + +// FetchTagged mocks base method +func (m *MockTChanNode) FetchTagged(ctx thrift.Context, req *FetchTaggedRequest) (*FetchTaggedResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchTagged", ctx, req) + ret0, _ := ret[0].(*FetchTaggedResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchTagged indicates an expected call of FetchTagged +func (mr *MockTChanNodeMockRecorder) FetchTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockTChanNode)(nil).FetchTagged), ctx, req) +} + +// GetPersistRateLimit mocks base method +func (m *MockTChanNode) GetPersistRateLimit(ctx thrift.Context) (*NodePersistRateLimitResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPersistRateLimit", ctx) + ret0, _ := ret[0].(*NodePersistRateLimitResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPersistRateLimit indicates an expected call of GetPersistRateLimit +func (mr *MockTChanNodeMockRecorder) GetPersistRateLimit(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).GetPersistRateLimit), ctx) +} + +// GetWriteNewSeriesAsync mocks base method +func (m *MockTChanNode) GetWriteNewSeriesAsync(ctx thrift.Context) (*NodeWriteNewSeriesAsyncResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesAsync", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesAsync indicates an expected call of GetWriteNewSeriesAsync +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesAsync), ctx) +} + +// GetWriteNewSeriesBackoffDuration mocks base method +func (m *MockTChanNode) GetWriteNewSeriesBackoffDuration(ctx thrift.Context) (*NodeWriteNewSeriesBackoffDurationResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesBackoffDuration", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesBackoffDuration indicates an expected call of GetWriteNewSeriesBackoffDuration +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesBackoffDuration(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesBackoffDuration), ctx) +} + +// GetWriteNewSeriesLimitPerShardPerSecond mocks base method +func (m *MockTChanNode) GetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWriteNewSeriesLimitPerShardPerSecond", ctx) + ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of GetWriteNewSeriesLimitPerShardPerSecond +func (mr *MockTChanNodeMockRecorder) GetWriteNewSeriesLimitPerShardPerSecond(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).GetWriteNewSeriesLimitPerShardPerSecond), ctx) +} + +// Health mocks base method +func (m *MockTChanNode) Health(ctx thrift.Context) (*NodeHealthResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", ctx) + ret0, _ := ret[0].(*NodeHealthResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health +func (mr *MockTChanNodeMockRecorder) Health(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockTChanNode)(nil).Health), ctx) +} + +// Query mocks base method +func (m *MockTChanNode) Query(ctx thrift.Context, req *QueryRequest) (*QueryResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, req) + ret0, _ := ret[0].(*QueryResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query +func (mr *MockTChanNodeMockRecorder) Query(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTChanNode)(nil).Query), ctx, req) +} + +// Repair mocks base method +func (m *MockTChanNode) Repair(ctx thrift.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Repair", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// Repair indicates an expected call of Repair +func (mr *MockTChanNodeMockRecorder) Repair(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Repair", reflect.TypeOf((*MockTChanNode)(nil).Repair), ctx) +} + +// SetPersistRateLimit mocks base method +func (m *MockTChanNode) SetPersistRateLimit(ctx thrift.Context, req *NodeSetPersistRateLimitRequest) (*NodePersistRateLimitResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPersistRateLimit", ctx, req) + ret0, _ := ret[0].(*NodePersistRateLimitResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetPersistRateLimit indicates an expected call of SetPersistRateLimit +func (mr *MockTChanNodeMockRecorder) SetPersistRateLimit(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistRateLimit", reflect.TypeOf((*MockTChanNode)(nil).SetPersistRateLimit), ctx, req) +} + +// SetWriteNewSeriesAsync mocks base method +func (m *MockTChanNode) SetWriteNewSeriesAsync(ctx thrift.Context, req *NodeSetWriteNewSeriesAsyncRequest) (*NodeWriteNewSeriesAsyncResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesAsync", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesAsyncResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesAsync indicates an expected call of SetWriteNewSeriesAsync +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesAsync(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesAsync", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesAsync), ctx, req) +} + +// SetWriteNewSeriesBackoffDuration mocks base method +func (m *MockTChanNode) SetWriteNewSeriesBackoffDuration(ctx thrift.Context, req *NodeSetWriteNewSeriesBackoffDurationRequest) (*NodeWriteNewSeriesBackoffDurationResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesBackoffDuration", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesBackoffDurationResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesBackoffDuration indicates an expected call of SetWriteNewSeriesBackoffDuration +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesBackoffDuration(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesBackoffDuration", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesBackoffDuration), ctx, req) +} + +// SetWriteNewSeriesLimitPerShardPerSecond mocks base method +func (m *MockTChanNode) SetWriteNewSeriesLimitPerShardPerSecond(ctx thrift.Context, req *NodeSetWriteNewSeriesLimitPerShardPerSecondRequest) (*NodeWriteNewSeriesLimitPerShardPerSecondResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWriteNewSeriesLimitPerShardPerSecond", ctx, req) + ret0, _ := ret[0].(*NodeWriteNewSeriesLimitPerShardPerSecondResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of SetWriteNewSeriesLimitPerShardPerSecond +func (mr *MockTChanNodeMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteNewSeriesLimitPerShardPerSecond", reflect.TypeOf((*MockTChanNode)(nil).SetWriteNewSeriesLimitPerShardPerSecond), ctx, req) +} + +// Truncate mocks base method +func (m *MockTChanNode) Truncate(ctx thrift.Context, req *TruncateRequest) (*TruncateResult_, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Truncate", ctx, req) + ret0, _ := ret[0].(*TruncateResult_) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Truncate indicates an expected call of Truncate +func (mr *MockTChanNodeMockRecorder) Truncate(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockTChanNode)(nil).Truncate), ctx, req) +} + +// Write mocks base method +func (m *MockTChanNode) Write(ctx thrift.Context, req *WriteRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// Write indicates an expected call of Write +func (mr *MockTChanNodeMockRecorder) Write(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTChanNode)(nil).Write), ctx, req) +} + +// WriteBatchRaw mocks base method +func (m *MockTChanNode) WriteBatchRaw(ctx thrift.Context, req *WriteBatchRawRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteBatchRaw", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteBatchRaw indicates an expected call of WriteBatchRaw +func (mr *MockTChanNodeMockRecorder) WriteBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRaw), ctx, req) +} + +// WriteBatchRawV2 mocks base method +func (m *MockTChanNode) WriteBatchRawV2(ctx thrift.Context, req *WriteBatchRawV2Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteBatchRawV2", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteBatchRawV2 indicates an expected call of WriteBatchRawV2 +func (mr *MockTChanNodeMockRecorder) WriteBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteBatchRawV2), ctx, req) +} + +// WriteTagged mocks base method +func (m *MockTChanNode) WriteTagged(ctx thrift.Context, req *WriteTaggedRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTagged", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTagged indicates an expected call of WriteTagged +func (mr *MockTChanNodeMockRecorder) WriteTagged(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockTChanNode)(nil).WriteTagged), ctx, req) +} + +// WriteTaggedBatchRaw mocks base method +func (m *MockTChanNode) WriteTaggedBatchRaw(ctx thrift.Context, req *WriteTaggedBatchRawRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTaggedBatchRaw", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTaggedBatchRaw indicates an expected call of WriteTaggedBatchRaw +func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRaw(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRaw", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRaw), ctx, req) +} + +// WriteTaggedBatchRawV2 mocks base method +func (m *MockTChanNode) WriteTaggedBatchRawV2(ctx thrift.Context, req *WriteTaggedBatchRawV2Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTaggedBatchRawV2", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteTaggedBatchRawV2 indicates an expected call of WriteTaggedBatchRawV2 +func (mr *MockTChanNodeMockRecorder) WriteTaggedBatchRawV2(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTaggedBatchRawV2", reflect.TypeOf((*MockTChanNode)(nil).WriteTaggedBatchRawV2), ctx, req) +}